[libclang] Add `CXSymbolRole role` to CXIdxEntityRefInfo

[MaskRay]

Summary

CXIdxEntityRefInfo contains the member CXIdxEntityRefKind kind; to
differentiate implicit and direct calls. However, there are more roles
defined in SymbolRole. Among them, Read/Write are probably the most
useful ones as they can be used to differentiate Read/Write occurrences
of a symbol for document highlight in a text document.

See export namespace DocumentHighlightKind
on https://microsoft.github.io/language-server-protocol/specification

[yvvan]

I feel quite ok about this patch.

Can you please add unit-tests?

[MaskRay]

Update c-index-test.c and clang/test/Index tests

[MaskRay]

In D42895#998617, @yvvan wrote:

I feel quite ok about this patch.

Can you please add unit-tests?

Added

// CHECK:      [indexEntityReference]: kind: field | name: y | {{.*}} | loc: 70:5 | {{.*}} | role: ref write
// CHECK:      [indexEntityReference]: kind: field | name: x | {{.*}} | loc: 70:11 | {{.*}} | role: ref read
// CHECK:      [indexEntityReference]: kind: function | name: foo3 | {{.*}} | loc: 71:10 | {{.*}} | role: ref addressof
// CHECK:      [indexEntityReference]: kind: function | name: foo4 | {{.*}} | loc: 72:3 | {{.*}} | role: ref call

to clang/test/Index/index-refs.cpp. I will implement read/write after this revision is landed.. https://github.com/cquery-project/cquery/issues/262

[MaskRay]

Simplify

[MaskRay]

.

[yvvan]

Looks ok-ish, I haven't built it though.
Also I don't have much exp with indexing part of libclang. Adding more reviewers.

[ilya-biryukov]

include/clang-c/Index.h

6163

Why do we need to store both CXIdxEntityRefKind and CXSymbolRole? Can we store just CXSymbolRole?
Is this for compatibility with existing clients?

If so, maybe we could:

• remove Implicit and Direct from the CXSymbolRole
• keep it only in CXIdxEntityRefKind
• not deprecate the CXIdxEntityRefKind

tools/libclang/CXIndexDataConsumer.cpp

154

SymbolRoleSet seems to have more roles not covered by CXSymbolRole.
Should they be accepted by this function?
If yes, maybe zero those bits?
If no, maybe add an assert?

The extra roles are:

RelationChildOf     = 1 << 9,
RelationBaseOf      = 1 << 10,
RelationOverrideOf  = 1 << 11,
RelationReceivedBy  = 1 << 12,
RelationCalledBy    = 1 << 13,
RelationExtendedBy  = 1 << 14,
RelationAccessorOf  = 1 << 15,
RelationContainedBy = 1 << 16,
RelationIBTypeOf    = 1 << 17,
RelationSpecializationOf = 1 << 18,

[MaskRay]

include/clang-c/Index.h

6163

I think CXIdxEntityRefKind should be deprecated but for compatibility we do not remove the field for this minor version upgrade. But they can be removed after a major version upgrade.

For what I have observed, Implicit is only used by Objective-C

tools/libclang/CXIndexDataConsumer.cpp

154

Yes, it has more relations, but most are only used by Objective-C. In all test/Index tests, I have only seen RelationContainedBy used for .cpp files. Many have not occurred in .m files. So I do not want to expose them, at least for now.

[ilya-biryukov]

include/clang-c/Index.h

6163

We should definitely loop the owners of libclang in if we want to deprecate the API, I'm not familiar with the contract of libclang regarding the API deprecation.
I'm not sure who's responsible for that, asking at the cfe-dev mailing list could be your best bet for that.

The alternative I suggest is removing Implicit from CXSymbolRole, making this change an extension of existing API. I expect that this could be done without more through discussion.

tools/libclang/CXIndexDataConsumer.cpp

154

It's fine, but let's add a comment and zero those bits out.

Could you also a comments to both SymbolRoleSet and CXSymbolRole that they mirror each other and need to be updated together?

[MaskRay]

Don't deprecate CXIdxEntityRefInfo

[MaskRay]

include/clang-c/Index.h

6163

I'll keep CXSymbolRole_Implicit and make it duplicate the functionality provided by CXIdxEntityRefKind, with a comment that CXIdxEntityRefKind may be deprecated in a future version.

Thanks, I'll also ask the cfe-dev mailing list.

tools/libclang/CXIndexDataConsumer.cpp

154

zeroed high bits of CXSymbolRole and left comments.

[ilya-biryukov]

include/clang-c/Index.h

6163

LG, thanks.

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

3545

Maybe keep this debug-printing of refkind? We're not removing it in this patch.

[MaskRay]

Bring back refkind:

[MaskRay]

Ping. Now this is a pure API extension to current implicit/direct roles. Is it possible to see this landed before clang+llvm 6 is released? This will be an amazing feature for LSP...

[ilya-biryukov]

LGTM.

Is it possible to see this landed before clang+llvm 6 is released?

I don't know in detail how releases work, but I believe the release branch has already been created and this patch will need to be merged into it separately (i.e. landing this upstream won't get it into the release automatically).
But again, I'm not sure how releases work. Asking on cfe-dev or llvm-dev should be your best bet.

[MaskRay]

Thx!

include/clang-c/Index.h

  * \brief The version constants for the libclang API.
  * CINDEX_VERSION_MINOR should increase when there are API additions.
  * CINDEX_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
  *
  * The policy about the libclang API was always to keep it source and ABI
  * compatible, thus CINDEX_VERSION_MAJOR is expected to remain stable.
  */
 #define CINDEX_VERSION_MAJOR 0
-#define CINDEX_VERSION_MINOR 47
+#define CINDEX_VERSION_MINOR 48
 
 #define CINDEX_VERSION_ENCODE(major, minor) ( \
       ((major) * 10000)                       \
     + ((minor) *     1))
 
 #define CINDEX_VERSION CINDEX_VERSION_ENCODE( \
     CINDEX_VERSION_MAJOR,                     \
     CINDEX_VERSION_MINOR )

 typedef struct {
   const CXIdxDeclInfo *declInfo;
   const CXIdxBaseClassInfo *const *bases;
   unsigned numBases;
 } CXIdxCXXClassDeclInfo;
 
 /**
  * \brief Data for IndexerCallbacks#indexEntityReference.
+ *
+ * This may be deprecated in a future version as this duplicates
+ * the \c CXSymbolRole_Implicit bit in \c CXSymbolRole.
  */
 typedef enum {
   /**
    * \brief The entity is referenced directly in user's code.
    */
   CXIdxEntityRef_Direct = 1,
   /**
    * \brief An implicit reference, e.g. a reference of an Objective-C method
    * via the dot syntax.
    */
   CXIdxEntityRef_Implicit = 2
 } CXIdxEntityRefKind;
 
 /**
+ * \brief Roles that are attributed to symbol occurrences.
+ *
+ * Internal: this currently mirrors low 9 bits of clang::index::SymbolRole with
+ * higher bits zeroed. These high bits may be exposed in the future.
+ */
+typedef enum {
+  CXSymbolRole_None = 0,
+  CXSymbolRole_Declaration = 1 << 0,
+  CXSymbolRole_Definition = 1 << 1,
+  CXSymbolRole_Reference = 1 << 2,
+  CXSymbolRole_Read = 1 << 3,
+  CXSymbolRole_Write = 1 << 4,
+  CXSymbolRole_Call = 1 << 5,
+  CXSymbolRole_Dynamic = 1 << 6,
+  CXSymbolRole_AddressOf = 1 << 7,
+  CXSymbolRole_Implicit = 1 << 8
+} CXSymbolRole;
+
+/**
  * \brief Data for IndexerCallbacks#indexEntityReference.
  */
 typedef struct {
   CXIdxEntityRefKind kind;
   /**
    * \brief Reference cursor.
    */
   CXCursor cursor;
typedef struct {
    * For references inside statement bodies of functions/methods,
    * the parentEntity will be the function/method.
    */
   const CXIdxEntityInfo *parentEntity;
   /**
    * \brief Lexical container context of the reference.
    */
   const CXIdxContainerInfo *container;
+  /**
+   * \brief Sets of symbol roles of the reference.
+   */
+  CXSymbolRole role;
 } CXIdxEntityRefInfo;
 
 /**
  * \brief A group of callbacks used by #clang_indexSourceFile and
  * #clang_indexTranslationUnit.
  */
 typedef struct {
   /**

include/clang/Index/IndexSymbol.h

enum class SymbolProperty : SymbolPropertySet {
   IBAnnotated                   = 1 << 4,
   IBOutletCollection            = 1 << 5,
   GKInspectable                 = 1 << 6,
   Local                         = 1 << 7,
 };
 static const unsigned SymbolPropertyBitNum = 8;
 
 /// Set of roles that are attributed to symbol occurrences.
+///
+/// Low 9 bits of clang-c/include/Index.h CXSymbolRole mirrors this enum.
 enum class SymbolRole : uint32_t {
   Declaration = 1 << 0,
   Definition  = 1 << 1,
   Reference   = 1 << 2,
   Read        = 1 << 3,
   Write       = 1 << 4,
   Call        = 1 << 5,
   Dynamic     = 1 << 6,

test/Index/index-refs.cpp

 void foo4(int p = default_param);
 
 struct S2 {
   int x,y;
 };
 
 void foo5() {
   struct S2 s = { .y = 1, .x = 4};
+  s.y = s.x + 1;
+  (void)&foo3;
+  foo4(s.y);
 }
 
 int ginitlist[] = {EnumVal};
 
 // RUN: c-index-test -index-file %s | FileCheck %s
 // CHECK:      [indexDeclaration]: kind: namespace | name: NS
 // CHECK-NEXT: [indexDeclaration]: kind: variable | name: gx
 // CHECK-NEXT: [indexDeclaration]: kind: typedef | name: MyInt

 // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: NS | {{.*}} | loc: 43:17
 // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: Inn | {{.*}} | loc: 43:21
 // CHECK-NEXT: [indexEntityReference]: kind: namespace | name: NS | {{.*}} | loc: 44:7
 // CHECK-NEXT: [indexEntityReference]: kind: typedef | name: Foo | {{.*}} | loc: 44:11
 
 // CHECK:      [indexDeclaration]: kind: c++-class-template | name: TS | {{.*}} | loc: 47:8
 // CHECK-NEXT: [indexDeclaration]: kind: struct-template-partial-spec | name: TS | USR: c:@SP>1#T@TS>#t0.0#I | {{.*}} | loc: 50:8
 // CHECK-NEXT: [indexDeclaration]: kind: typedef | name: MyInt | USR: c:index-refs.cpp@SP>1#T@TS>#t0.0#I@T@MyInt | {{.*}} | loc: 51:15 | semantic-container: [TS:50:8] | lexical-container: [TS:50:8]
-// CHECK-NEXT: [indexEntityReference]: kind: c++-class-template | name: TS | USR: c:@ST>2#T#T@TS | lang: C++ | cursor: TemplateRef=TS:47:8 | loc: 50:8 | <parent>:: <<NULL>> | container: [TU] | refkind: direct
+// CHECK-NEXT: [indexEntityReference]: kind: c++-class-template | name: TS | USR: c:@ST>2#T#T@TS | lang: C++ | cursor: TemplateRef=TS:47:8 | loc: 50:8 | <parent>:: <<NULL>> | container: [TU] | refkind: direct | role: ref
 /* when indexing implicit instantiations
   [indexDeclaration]: kind: struct-template-spec | name: TS | USR: c:@S@TS>#I | {{.*}} | loc: 50:8
   [indexDeclaration]: kind: typedef | name: MyInt | USR: c:index-refs.cpp@593@S@TS>#I@T@MyInt | {{.*}} | loc: 51:15 | semantic-container: [TS:50:8] | lexical-container: [TS:50:8]
  */
 // CHECK-NEXT: [indexDeclaration]: kind: function | name: foo3
 /* when indexing implicit instantiations
   [indexEntityReference]: kind: struct-template-spec | name: TS | USR: c:@S@TS>#I | {{.*}} | loc: 55:3
 */
 // CHECK-NEXT: [indexEntityReference]: kind: c++-class-template | name: TS | USR: c:@ST>2#T#T@TS | {{.*}} | loc: 55:3
 
 // CHECK:      [indexEntityReference]: kind: variable | name: array_size | {{.*}} | loc: 59:22
-// CHECK:      [indexEntityReference]: kind: variable | name: default_param | {{.*}} | loc: 62:19
+// CHECK:      [indexEntityReference]: kind: variable | name: default_param | {{.*}} | loc: 62:19 | {{.*}} | role: ref read
 // CHECK-NOT:  [indexEntityReference]: kind: variable | name: default_param | {{.*}} | loc: 62:19
 
 // CHECK:      [indexEntityReference]: kind: field | name: y | {{.*}} | loc: 69:20
 // CHECK-NEXT: [indexEntityReference]: kind: field | name: x | {{.*}} | loc: 69:28
 // CHECK-NOT:  [indexEntityReference]: kind: field | name: y | {{.*}} | loc: 69:20
 // CHECK-NOT:  [indexEntityReference]: kind: field | name: x | {{.*}} | loc: 69:28
 
+// CHECK:      [indexEntityReference]: kind: field | name: y | {{.*}} | loc: 70:5 | {{.*}} | role: ref write
+// CHECK:      [indexEntityReference]: kind: field | name: x | {{.*}} | loc: 70:11 | {{.*}} | role: ref read
+// CHECK:      [indexEntityReference]: kind: function | name: foo3 | {{.*}} | loc: 71:10 | {{.*}} | role: ref addr
+// CHECK:      [indexEntityReference]: kind: function | name: foo4 | {{.*}} | loc: 72:3 | {{.*}} | role: ref call
+
 // CHECK:      [indexDeclaration]: kind: variable | name: ginitlist |
-// CHECK:      [indexEntityReference]: kind: enumerator | name: EnumVal | {{.*}} | loc: 72:20
-// CHECK-NOT:  [indexEntityReference]: kind: enumerator | name: EnumVal | {{.*}} | loc: 72:20
+// CHECK:      [indexEntityReference]: kind: enumerator | name: EnumVal | {{.*}} | loc: 75:20
+// CHECK-NOT:  [indexEntityReference]: kind: enumerator | name: EnumVal | {{.*}} | loc: 75:20

test/Index/index-subscripting-literals.m

void testDict() {
   oldObject = dictionary[key];
   dictionary[key] = newObject;
   NSDictionary *dict = @{ key: newObject, key: oldObject };
 }
 
 // RUN: c-index-test -index-file -target x86_64-apple-macosx10.7 %s | FileCheck %s
 
 // CHECK:      [indexEntityReference]: kind: variable | name: idx | USR: c:@idx | lang: C | cursor: DeclRefExpr=idx:22:5 | loc: 27:9
-// CHECK-NEXT: [indexEntityReference]: kind: variable | name: p | USR: c:@p | lang: C | cursor: DeclRefExpr=p:23:4 | loc: 27:16 | <parent>:: kind: function | name: testArray | USR: c:@F@testArray | lang: C | container: [testArray:25:4] | refkind: direct
+// CHECK-NEXT: [indexEntityReference]: kind: variable | name: p | USR: c:@p | lang: C | cursor: DeclRefExpr=p:23:4 | loc: 27:16 | <parent>:: kind: function | name: testArray | USR: c:@F@testArray | lang: C | container: [testArray:25:4] | refkind: direct | role: ref
 // CHECK-NEXT: [indexEntityReference]: kind: objc-instance-method | name: setObject:atIndexedSubscript:
 // CHECK-NEXT: [indexEntityReference]: kind: objc-class | name: NSArray
 // CHECK-NEXT: [indexEntityReference]: kind: objc-class-method | name: arrayWithObjects:count: 
 // CHECK-NEXT: [indexEntityReference]: kind: variable | name: p | USR: c:@p | lang: C | cursor: DeclRefExpr=p:23:4 | loc: 28:21
 // CHECK-NEXT: [indexEntityReference]: kind: variable | name: p | USR: c:@p | lang: C | cursor: DeclRefExpr=p:23:4 | loc: 28:24
 // CHECK-NEXT: [indexEntityReference]: kind: variable | name: idx | USR: c:@idx | lang: C | cursor: DeclRefExpr=idx:22:5 | loc: 29:16
 // CHECK-NEXT: [indexEntityReference]: kind: objc-instance-method | name: objectAtIndexedSubscript:
 // CHECK-NEXT: [indexDeclaration]: kind: variable | name: key

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

for (i = 0; i < ProtoInfo->numProtocols; ++i) {
     printf(" | cursor: ");
     PrintCursor(ProtoInfo->protocols[i]->cursor, NULL);
     printf(" | loc: ");
     printCXIndexLoc(ProtoInfo->protocols[i]->loc, client_data);
     printf("\n");
   }
 }
 
+static void printSymbolRole(CXSymbolRole role) {
+  if (role & CXSymbolRole_Declaration)
+    printf(" decl");
+  if (role & CXSymbolRole_Definition)
+    printf(" def");
+  if (role & CXSymbolRole_Reference)
+    printf(" ref");
+  if (role & CXSymbolRole_Read)
+    printf(" read");
+  if (role & CXSymbolRole_Write)
+    printf(" write");
+  if (role & CXSymbolRole_Call)
+    printf(" call");
+  if (role & CXSymbolRole_Dynamic)
+    printf(" dyn");
+  if (role & CXSymbolRole_AddressOf)
+    printf(" addr");
+  if (role & CXSymbolRole_Implicit)
+    printf(" implicit");
+}
+
 static void index_diagnostic(CXClientData client_data,
                              CXDiagnosticSet diagSet, void *reserved) {
   CXString str;
   const char *cstr;
   unsigned numDiags, i;
   CXDiagnostic diag;
   IndexData *index_data;
   index_data = (IndexData *)client_data;
printEntityInfo("[indexEntityReference]", client_data,
                   info->referencedEntity);
   printf(" | cursor: ");
   PrintCursor(info->cursor, NULL);
   printf(" | loc: ");
   printCXIndexLoc(info->loc, client_data);
   printEntityInfo(" | <parent>:", client_data, info->parentEntity);
   printf(" | container: ");
   printCXIndexContainer(info->container);
   printf(" | refkind: ");
   switch (info->kind) {
     case CXIdxEntityRef_Direct: printf("direct"); break;
     case CXIdxEntityRef_Implicit: printf("implicit"); break;
   }
+  printf(" | role:");
+  printSymbolRole(info->role);
   printf("\n");
 }
 
 static int index_abortQuery(CXClientData client_data, void *reserved) {
   IndexData *index_data;
   index_data = (IndexData *)client_data;
   return index_data->abort;
 }

tools/libclang/CXIndexDataConsumer.h

public:
   bool handleClassTemplate(const ClassTemplateDecl *D);
   bool handleFunctionTemplate(const FunctionTemplateDecl *D);
   bool handleTypeAliasTemplate(const TypeAliasTemplateDecl *D);
 
   bool handleReference(const NamedDecl *D, SourceLocation Loc, CXCursor Cursor,
                        const NamedDecl *Parent,
                        const DeclContext *DC,
                        const Expr *E = nullptr,
-                       CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct);
+                       CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct,
+                       CXSymbolRole Role = CXSymbolRole_None);
 
   bool handleReference(const NamedDecl *D, SourceLocation Loc,
                        const NamedDecl *Parent,
                        const DeclContext *DC,
                        const Expr *E = nullptr,
-                       CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct);
+                       CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct,
+                       CXSymbolRole Role = CXSymbolRole_None);
 
   bool isNotFromSourceFile(SourceLocation Loc) const;
 
   void indexTopLevelDecl(const Decl *D);
   void indexDeclGroupRef(DeclGroupRef DG);
 
   void translateLoc(SourceLocation Loc, CXIdxClientFile *indexFile, CXFile *file,
                     unsigned *line, unsigned *column, unsigned *offset);

tools/libclang/CXIndexDataConsumer.cpp

bool VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
     return true;
   }
 
   bool VisitImportDecl(const ImportDecl *D) {
     DataConsumer.importedModule(D);
     return true;
   }
 };
+
+CXSymbolRole getSymbolRole(SymbolRoleSet Role) {
+  // CXSymbolRole mirrors low 9 bits of clang::index::SymbolRole.
+  return CXSymbolRole(static_cast<uint32_t>(Role) & ((1 << 9) - 1));
+}
 }
 
 bool CXIndexDataConsumer::handleDeclOccurence(const Decl *D,
                                               SymbolRoleSet Roles,
                                              ArrayRef<SymbolRelation> Relations,
                                               FileID FID, unsigned Offset,
                                               ASTNodeInfo ASTNode) {
   SourceLocation Loc = getASTContext().getSourceManager()
if (auto *ObjCPD = dyn_cast_or_null<ObjCProtocolDecl>(ASTNode.OrigD)) {
         return true;
       }
     }
 
     CXIdxEntityRefKind Kind = CXIdxEntityRef_Direct;
     if (Roles & (unsigned)SymbolRole::Implicit) {
       Kind = CXIdxEntityRef_Implicit;
     }
+    CXSymbolRole CXRole = getSymbolRole(Roles);
 
     CXCursor Cursor;
     if (ASTNode.OrigE) {
       Cursor = cxcursor::MakeCXCursor(ASTNode.OrigE,
                                       cast<Decl>(ASTNode.ContainerDC),
                                       getCXTU());
     } else {
       if (ASTNode.OrigD) {
         if (auto *OrigND = dyn_cast<NamedDecl>(ASTNode.OrigD))
           Cursor = getRefCursor(OrigND, Loc);
         else
           Cursor = MakeCXCursor(ASTNode.OrigD, CXTU);
       } else {
         Cursor = getRefCursor(ND, Loc);
       }
     }
     handleReference(ND, Loc, Cursor,
                     dyn_cast_or_null<NamedDecl>(ASTNode.Parent),
-                    ASTNode.ContainerDC, ASTNode.OrigE, Kind);
+                    ASTNode.ContainerDC, ASTNode.OrigE, Kind, CXRole);
 
   } else {
     const DeclContext *LexicalDC = ASTNode.ContainerDC;
     if (!LexicalDC) {
       for (const auto &SymRel : Relations) {
         if (SymRel.Roles & (unsigned)SymbolRole::RelationChildOf)
           LexicalDC = dyn_cast<DeclContext>(SymRel.RelatedSymbol);
       }
DeclInfo DInfo(/*isRedeclaration=*/!D->isCanonicalDecl(),
                  /*isDefinition=*/true, /*isContainer=*/false);
   return handleDecl(D, D->getLocation(), getCursor(D), DInfo);
 }
 
 bool CXIndexDataConsumer::handleReference(const NamedDecl *D, SourceLocation Loc,
                                       const NamedDecl *Parent,
                                       const DeclContext *DC,
                                       const Expr *E,
-                                      CXIdxEntityRefKind Kind) {
+                                      CXIdxEntityRefKind Kind,
+                                      CXSymbolRole Role) {
   if (!D || !DC)
     return false;
 
   CXCursor Cursor = E ? MakeCXCursor(E, cast<Decl>(DC), CXTU)
                       : getRefCursor(D, Loc);
-  return handleReference(D, Loc, Cursor, Parent, DC, E, Kind);
+  return handleReference(D, Loc, Cursor, Parent, DC, E, Kind, Role);
 }
 
 bool CXIndexDataConsumer::handleReference(const NamedDecl *D, SourceLocation Loc,
                                       CXCursor Cursor,
                                       const NamedDecl *Parent,
                                       const DeclContext *DC,
                                       const Expr *E,
-                                      CXIdxEntityRefKind Kind) {
+                                      CXIdxEntityRefKind Kind,
+                                      CXSymbolRole Role) {
   if (!CB.indexEntityReference)
     return false;
 
   if (!D || !DC)
     return false;
   if (Loc.isInvalid())
     return false;
   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalDecl(D))
bool CXIndexDataConsumer::handleReference(const NamedDecl *D, SourceLocation Loc,
   ContainerInfo Container;
   getContainerInfo(DC, Container);
 
   CXIdxEntityRefInfo Info = { Kind,
                               Cursor,
                               getIndexLoc(Loc),
                               &RefEntity,
                               Parent ? &ParentEntity : nullptr,
-                              &Container };
+                              &Container,
+                              Role };
   CB.indexEntityReference(ClientData, &Info);
   return true;
 }
 
 bool CXIndexDataConsumer::isNotFromSourceFile(SourceLocation Loc) const {
   if (Loc.isInvalid())
     return true;
   SourceManager &SM = Ctx->getSourceManager();