Added functions to retrieve information about whether a vardecl is local in libclang and its python bindings.

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping.

[RedX2501]

The code owners file says you are the owner of all parts that do not belong to somebody else. So i hope it is ok if i attach you as reviewer to this.

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[rsmith]

include/clang-c/Index.h

3831–3837

It might be better to combine these into a single function (getLocalVarKind?) returning an enum { not local, non-static local, static local }.

[RedX2501]

include/clang-c/Index.h

3831–3837

Combining these into one function with an enum is much more work when porting to python (which is also den in this patch). Therefore unless there are reasons beyond stylistic ones i'd prefer to keep them separate.

IMHO this also increases the friendliness as you can directly infer from the documentation at http://clang.llvm.org/doxygen/ what they should do as they just forward the calls..

[rsmith]

Argyrios, I'd appreciate your thoughts here.

tools/libclang/CIndex.cpp

6744–6768

I don't think the names of these are really specific enough for what they do. As members of VarDecl, they're good enough, but as operations on a general Cursor, it's less so. For instance, temporary objects in C++ might also have local storage or be static locals. Renaming isStaticLocal to isStaticLocalVar would help.

hasLocalStorage is not really a very user-friendly name for this functionality, even though it currently matches our C++ API (the C API has long-term stability guarantees whereas the C++ API does not, so we need to take more care when naming C API functions, even though matching the C++ API does generally make the C API more user-friendly). isStaticLocalVar versus isNonStaticLocalVar might be better if you don't want to go the enum route.

[RedX2501]

No longer export two functions but only one.

On further thought I only need the information is the variable was declared local or not. I don't really need the information where the storage ultimately is.

Added python and libclang tests.

[RedX2501]

Ping

[RedX2501]

Ping

[akyrtzi]

The patch does not apply cleanly, could you provide a more up-to-date one ?

[RedX2501]

Fixed compiler warnings.

[RedX2501]

Fix compilation error introduced due to breaking a long string.
Fixed indentation.

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping

[RedX2501]

Ping?

bindings/python/clang/cindex.py

def referenced(self):
         representing the entity that it references.
         """
         if not hasattr(self, '_referenced'):
             self._referenced = conf.lib.clang_getCursorReferenced(self)
 
         return self._referenced
 
     @property
+    def is_local_var(self):
+        if not hasattr(self, '_is_local_var'):
+            self._is_local_var = conf.lib.clang_Cursor_isLocalVarDecl(self)
+
+        return self._is_local_var
+
+    @property
     def brief_comment(self):
         """Returns the brief comment text associated with that Cursor"""
         return conf.lib.clang_Cursor_getBriefCommentText(self)
 
     @property
     def raw_comment(self):
         """Returns the raw comment text associated with that Cursor"""
         return conf.lib.clang_Cursor_getRawCommentText(self)

bindings/python/tests/cindex/test_cursor.py

def test_annotation_attribute():
 
     for c in foo.get_children():
         if c.kind == CursorKind.ANNOTATE_ATTR:
             assert c.displayname == "here be annotation attribute"
             break
     else:
         assert False, "Couldn't find annotation"
 
+local_var = """
+extern "C" {
+  int var0;
+  static int var1;
+
+  void func(void){
+    static int var2;
+    int var3;
+  }
+};
+
+int var4;
+
+class Classy {
+  static int var5;
+
+  void member(){
+    int var6;
+    static int var7;
+  }
+};
+"""
+
+def test_is_local_var():
+    tu = get_tu(local_var, lang="cpp")
+    var0 = get_cursor(tu, "var0")
+    var1 = get_cursor(tu, "var1")
+    var2 = get_cursor(tu, "var2")
+    var3 = get_cursor(tu, "var3")
+    var4 = get_cursor(tu, "var4")
+    var5 = get_cursor(tu, "var5")
+    var6 = get_cursor(tu, "var6")
+    var7 = get_cursor(tu, "var7")
+    assert not var0.is_local_var
+    assert not var1.is_local_var
+    assert var2.is_local_var
+    assert var3.is_local_var
+    assert not var4.is_local_var
+    assert not var5.is_local_var
+    assert var6.is_local_var
+    assert var7.is_local_var
+    
 def test_result_type():
     tu = get_tu('int foo();')
     foo = get_cursor(tu, 'foo')
 
     assert foo is not None
     t = foo.result_type
     assert t.kind == TypeKind.INT
 
def test_mangled_name():
     foo = get_cursor(tu, 'foo')
 
     # Since libclang does not link in targets, we cannot pass a triple to it
     # and force the target. To enable this test to pass on all platforms, accept
     # all valid manglings.
     # [c-index-test handles this by running the source through clang, emitting
     #  an AST file and running libclang on that AST file]
     assert foo.mangled_name in ('_Z3fooii', '__Z3fooii', '?foo@@YAHHH')
+

include/clang-c/Index.h

  */
 CINDEX_LINKAGE unsigned clang_Cursor_isObjCOptional(CXCursor C);
 
 /**
  * \brief Returns non-zero if the given cursor is a variadic function or method.
  */
 CINDEX_LINKAGE unsigned clang_Cursor_isVariadic(CXCursor C);
 
 /**
+ * \brief Returns non-zero if the Cursor refers to a local VarDecl.
+ */
+CINDEX_LINKAGE unsigned clang_Cursor_isLocalVarDecl(CXCursor C);
+
+/**
  * \brief Given a cursor that represents a declaration, return the associated
  * comment's source range.  The range may include multiple consecutive comments
  * with whitespace in between.
  */
 CINDEX_LINKAGE CXSourceRange clang_Cursor_getCommentRange(CXCursor C);
 
 /**
  * \brief Given a cursor that represents a declaration, return the associated
  * comment text, including comment markers.

test/Index/islocalvardecl.cpp

+// RUN: c-index-test -test-print-local-var-kind %s | FileCheck %s
+
+extern "C" {
+  int var0;
+  static int var1;
+
+  void func(void){
+    static int var2;
+    int var3;
+  }
+};
+
+int var4;
+
+class Classy {
+  static int var5;
+
+  void member(){
+    int var6;
+    static int var7;
+  }
+};
+
+// CHECK: VarDecl=var0:3:5 (Definition) IsLocalVarDecl=0
+// CHECK: VarDecl=var1:4:12 (Definition) IsLocalVarDecl=0
+// CHECK: VarDecl=var2:7:14 (Definition) IsLocalVarDecl=1
+// CHECK: VarDecl=var3:8:7 (Definition) IsLocalVarDecl=1
+// CHECK: VarDecl=var4:13:5 (Definition) IsLocalVarDecl=0
+// CHECK: VarDecl=var5:17:12 IsLocalVarDecl=0
+// CHECK: VarDecl=var6:20:9 (Definition) IsLocalVarDecl=1
+// CHECK: VarDecl=var7:21:16 (Definition) IsLocalVarDecl=1
+

tools/c-index-test/c-index-test.c

if (linkage) {
     PrintCursor(cursor, NULL);
     printf("linkage=%s\n", linkage);
   }
 
   return CXChildVisit_Recurse;
 }
 
 /******************************************************************************/
+/* Local VarKind testing.                                                     */
+/******************************************************************************/
+
+static enum ChildVisitResult PrintIsLocalVarDecl(CXCursor C, CXClientData CD){
+
+  if (clang_getCursorKind(C) != CXCursor_VarDecl)
+    return CXChildVisit_Recurse;
+
+  PrintCursor(C, NULL);
+  printf(" IsLocalVarDecl=%d\n", clang_Cursor_isLocalVarDecl(C));
+
+  return CXChildVisit_Recurse;
+}
+
+/******************************************************************************/
 /* Typekind testing.                                                          */
 /******************************************************************************/
 
 static void PrintTypeAndTypeKind(CXType T, const char *Format) {
   CXString TypeSpelling, TypeKindSpelling;
 
   TypeSpelling = clang_getTypeSpelling(T);
   TypeKindSpelling = clang_getTypeKindSpelling(T.kind);
fprintf(stderr,
     "       c-index-test -test-load-source-usrs <symbol filter> {<args>}*\n"
     "       c-index-test -test-load-source-usrs-memory-usage "
           "<symbol filter> {<args>}*\n"
     "       c-index-test -test-annotate-tokens=<range> {<args>}*\n"
     "       c-index-test -test-inclusion-stack-source {<args>}*\n"
     "       c-index-test -test-inclusion-stack-tu <AST file>\n");
   fprintf(stderr,
     "       c-index-test -test-print-linkage-source {<args>}*\n"
+    "       c-index-test -test-print-is-local-var {<args>}*\n"
     "       c-index-test -test-print-type {<args>}*\n"
     "       c-index-test -test-print-type-size {<args>}*\n"
     "       c-index-test -test-print-bitwidth {<args>}*\n"
     "       c-index-test -print-usr [<CursorKind> {<args>}]*\n"
     "       c-index-test -print-usr-file <file>\n"
     "       c-index-test -write-pch <file> <compiler arguments>\n");
   fprintf(stderr,
     "       c-index-test -compilation-db [lookup <filename>] database\n");
else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-source") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all", NULL,
                                     PrintInclusionStack);
   else if (argc > 2 && strcmp(argv[1], "-test-inclusion-stack-tu") == 0)
     return perform_test_load_tu(argv[2], "all", NULL, NULL,
                                 PrintInclusionStack);
   else if (argc > 2 && strcmp(argv[1], "-test-print-linkage-source") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all", PrintLinkage,
                                     NULL);
+  else if (argc > 2 && strcmp(argv[1], "-test-print-is-local-var") == 0)
+    return perform_test_load_source(argc - 2, argv + 2, "all", PrintIsLocalVarDecl,
+                                    NULL);
   else if (argc > 2 && strcmp(argv[1], "-test-print-type") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintType, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-type-size") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",
                                     PrintTypeSize, 0);
   else if (argc > 2 && strcmp(argv[1], "-test-print-bitwidth") == 0)
     return perform_test_load_source(argc - 2, argv + 2, "all",

tools/libclang/CIndex.cpp

unsigned clang_Cursor_isVariadic(CXCursor C) {
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
     return FD->isVariadic();
   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D))
     return MD->isVariadic();
 
   return 0;
 }
 
+unsigned clang_Cursor_isLocalVarDecl(CXCursor C){
+  if (C.kind != CXCursor_VarDecl) {
+    return 0;
+  }
+
+  const Decl *D = getCursorDecl(C);
+  if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
+    return VD->isLocalVarDecl();
+  }
+
+  return 0;
+}
+
 CXSourceRange clang_Cursor_getCommentRange(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return clang_getNullRange();
 
   const Decl *D = getCursorDecl(C);
   ASTContext &Context = getCursorContext(C);
   const RawComment *RC = Context.getRawCommentForAnyRedecl(D);
   if (!RC)
     return clang_getNullRange();
 
   return cxloc::translateSourceRange(Context, RC->getSourceRange());
 }
 
 CXString clang_Cursor_getRawCommentText(CXCursor C) {
   if (!clang_isDeclaration(C.kind))
     return cxstring::createNull();
 
   const Decl *D = getCursorDecl(C);
   ASTContext &Context = getCursorContext(C);
   const RawComment *RC = Context.getRawCommentForAnyRedecl(D);

tools/libclang/libclang.exports

 clang_Cursor_getTranslationUnit
 clang_Cursor_getReceiverType
 clang_Cursor_isAnonymous
 clang_Cursor_isBitField
 clang_Cursor_isDynamicCall
 clang_Cursor_isNull
 clang_Cursor_isObjCOptional
 clang_Cursor_isVariadic
+clang_Cursor_isLocalVarDecl
 clang_Cursor_getModule
 clang_Cursor_getStorageClass
 clang_File_isEqual
 clang_Module_getASTFile
 clang_Module_getParent
 clang_Module_getName
 clang_Module_getFullName
 clang_Module_getNumTopLevelHeaders