[libclang] Simplify the indexing API.

Cut down the number of callbacks to more generic ones. Clients can check
an enum to find out what kind of declaration it is and they can call functions
to get more specific information than the generic provided info.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@144343 91177308-0d34-0410-b5e6-96231b3b80d8

7 files changed, 529 insertions, 668 deletions

diff --git a/tools/c-index-test/c-index-test.c b/tools/c-index-test/c-index-test.c
index 44b90b13e1..eb992395f2 100644
--- a/tools/c-index-test/c-index-test.c
+++ b/tools/c-index-test/c-index-test.c
@@ -1547,7 +1547,7 @@ static void printCheck(IndexData *data) {
   }
 }
 
-static void printCXIndexFile(CXIdxFile file) {
+static void printCXIndexFile(CXIdxClientFile file) {
   CXString filename = clang_getFileName((CXFile)file);
   printf("%s", clang_getCString(filename));
   clang_disposeString(filename);
@@ -1556,7 +1556,7 @@ static void printCXIndexFile(CXIdxFile file) {
 static void printCXIndexLoc(CXIdxLoc loc) {
   CXString filename;
   const char *cname, *end;
-  CXIdxFile file;
+  CXIdxClientFile file;
   unsigned line, column;
   int isHeader;
   
@@ -1577,88 +1577,63 @@ static void printCXIndexLoc(CXIdxLoc loc) {
   printf("%d:%d", line, column);
 }
 
-static CXIdxEntity makeCXIndexEntity(CXIdxIndexedEntityInfo *info) {
+static CXIdxClientEntity makeClientEntity(CXIdxEntityInfo *info, CXIdxLoc loc) {
   const char *name;
-  CXIdxLoc loc;
   char *newStr;
-  CXIdxFile file;
+  CXIdxClientFile file;
   unsigned line, column;
   
-  name = info->entityInfo->name;
+  name = info->name;
   if (!name)
     name = "<anon-tag>";
 
-  loc = info->declInfo->loc;
   clang_indexLoc_getFileLocation(loc, &file, 0, &line, &column, 0);
   /* FIXME: free these.*/
   newStr = (char *)malloc(strlen(name) + 10);
   sprintf(newStr, "%s:%d:%d", name, line, column);
-  return (CXIdxEntity)newStr;
+  return (CXIdxClientEntity)newStr;
 }
 
-static CXIdxContainer makeCXIndexContainer(CXIdxEntity entity) {
-  return (CXIdxContainer)entity;
-}
-
-static void printCXIndexEntity(CXIdxEntity entity) {
-  printf("{%s}", (const char *)entity);
-}
-
-static void printCXIndexContainer(CXIdxContainer container) {
+static void printCXIndexContainer(CXIdxClientContainer container) {
   printf("[%s]", (const char *)container);
 }
 
-static void printIndexedDeclInfo(CXIdxIndexedDeclInfo *info) {
-  printf(" | cursor: ");
-  PrintCursor(info->cursor);
-  printf(" | loc: ");
-  printCXIndexLoc(info->loc);
-  printf(" | container: ");
-  printCXIndexContainer(info->container);
-}
-
-static void printIndexedEntityInfo(const char *cb,
-                                   CXClientData client_data,
-                                   CXIdxIndexedEntityInfo *info) {
+static const char *getEntityKindString(CXIdxEntityKind kind) {
+  switch (kind) {
+  case CXIdxEntity_Unexposed: return "<<UNEXPOSED>>";
+  case CXIdxEntity_Typedef: return "typedef";
+  case CXIdxEntity_Function: return "function";
+  case CXIdxEntity_Variable: return "variable";
+  case CXIdxEntity_Field: return "field";
+  case CXIdxEntity_EnumConstant: return "enumerator";
+  case CXIdxEntity_ObjCClass: return "objc-class";
+  case CXIdxEntity_ObjCProtocol: return "objc-protocol";
+  case CXIdxEntity_ObjCCategory: return "objc-category";
+  case CXIdxEntity_ObjCMethod: return "objc-method";
+  case CXIdxEntity_ObjCProperty: return "objc-property";
+  case CXIdxEntity_ObjCIvar: return "objc-ivar";
+  case CXIdxEntity_Enum: return "enum";
+  case CXIdxEntity_Struct: return "struct";
+  case CXIdxEntity_Union: return "union";
+  case CXIdxEntity_CXXClass: return "c++-class";
+  }
+}
+
+static void printEntityInfo(const char *cb,
+                            CXClientData client_data,
+                            CXIdxEntityInfo *info) {
   const char *name;
   IndexData *index_data;
   index_data = (IndexData *)client_data;
   printCheck(index_data);
 
-  name = info->entityInfo->name;
+  name = info->name;
   if (!name)
     name = "<anon-tag>";
 
-  printf("%s: %s", cb, info->entityInfo->name);
-  printIndexedDeclInfo(info->declInfo);
-  printf(" | USR: %s", info->entityInfo->USR);
-}
-
-static void printIndexedRedeclInfo(const char *cb,
-                                   CXClientData client_data,
-                                   CXIdxIndexedRedeclInfo *info) {
-  IndexData *index_data;
-  index_data = (IndexData *)client_data;
-  printCheck(index_data);
-
-  printf("%s redeclaration: ", cb);
-  printCXIndexEntity(info->entity);
-  printIndexedDeclInfo(info->declInfo);
-}
-
-static void printStartedContainerInfo(const char *cb,
-                                   CXClientData client_data,
-                                   CXIdxContainerInfo *info) {
-  IndexData *index_data;
-  index_data = (IndexData *)client_data;
-  printCheck(index_data);
-
-  printf("%s: ", cb);
-  printCXIndexEntity(info->entity);
-  printf(" | cursor: ");
-  PrintCursor(info->cursor);
-  printf(" | loc: ");
-  printCXIndexLoc(info->loc);
+  printf("%s: kind: %s", cb, getEntityKindString(info->kind));
+  printf(" | name: %s", name);
+  printf(" | USR: %s", info->USR);
 }
 
 static void index_diagnostic(CXClientData client_data,
@@ -1680,26 +1655,36 @@ static void index_diagnostic(CXClientData client_data,
   }
 }
 
-static CXIdxFile index_recordFile(CXClientData client_data,
-                                  CXFile file, void *reserved) {
-  return (CXIdxFile)file;
+static CXIdxClientFile index_enteredMainFile(CXClientData client_data,
+                                       CXFile file, void *reserved) {
+  IndexData *index_data;
+  index_data = (IndexData *)client_data;
+  printCheck(index_data);
+
+  printf("[enteredMainFile]: ");
+  printCXIndexFile((CXIdxClientFile)file);
+  printf("\n");
+
+  return (CXIdxClientFile)file;
 }
 
-static void index_ppIncludedFile(CXClientData client_data,
-                                 CXIdxIncludedFileInfo *info) {
+static CXIdxClientFile index_ppIncludedFile(CXClientData client_data,
+                                      CXIdxIncludedFileInfo *info) {
   IndexData *index_data;
   index_data = (IndexData *)client_data;
   printCheck(index_data);
 
   printf("[ppIncludedFile]: ");
-  printCXIndexFile(info->file);
+  printCXIndexFile((CXIdxClientFile)info->file);
   printf(" | name: \"%s\"", info->filename);
   printf(" | hash loc: ");
   printCXIndexLoc(info->hashLoc);
   printf(" | isImport: %d | isAngled: %d\n", info->isImport, info->isAngled);
+
+  return (CXIdxClientFile)info->file;
 }
 
-static CXIdxMacro index_ppMacroDefined(CXClientData client_data,
+static CXIdxClientMacro index_ppMacroDefined(CXClientData client_data,
                                        CXIdxMacroDefinedInfo *info) {
   IndexData *index_data;
   index_data = (IndexData *)client_data;
@@ -1712,7 +1697,7 @@ static CXIdxMacro index_ppMacroDefined(CXClientData client_data,
   printCXIndexLoc(info->defBegin);
   printf(" | length: %d\n", info->defLength);
 
-  return (CXIdxMacro)info->macroInfo->name;
+  return (CXIdxClientMacro)info->macroInfo->name;
 }
 
 static void index_ppMacroUndefined(CXClientData client_data,
@@ -1739,217 +1724,105 @@ static void index_ppMacroExpanded(CXClientData client_data,
   printf("\n");
 }
 
-static CXIdxEntity index_importedEntity(CXClientData client_data,
+static CXIdxClientEntity index_importedEntity(CXClientData client_data,
                                         CXIdxImportedEntityInfo *info) {
   IndexData *index_data;
-  CXIdxIndexedDeclInfo DeclInfo;
-  CXIdxIndexedEntityInfo EntityInfo;
-  const char *name;
-  DeclInfo.cursor = info->cursor;
-  DeclInfo.loc = info->loc;
-  DeclInfo.container = 0;
-  EntityInfo.entityInfo = info->entityInfo;
-  EntityInfo.declInfo = &DeclInfo;
   index_data = (IndexData *)client_data;
   printCheck(index_data);
 
-  name = info->entityInfo->name;
-  if (!name)
-    name = "<anon-tag>";
-
-  printf("[importedEntity]: %s", name);
+  printEntityInfo("[importedEntity]", client_data, info->entityInfo);
   printf(" | cursor: ");
   PrintCursor(info->cursor);
   printf(" | loc: ");
   printCXIndexLoc(info->loc);
   printf("\n");
 
-  return makeCXIndexEntity(&EntityInfo);
+  return makeClientEntity(info->entityInfo, info->loc);
 }
 
-static CXIdxContainer index_startedTranslationUnit(CXClientData client_data,
+static CXIdxClientContainer index_startedTranslationUnit(CXClientData client_data,
                                                    void *reserved) {
   IndexData *index_data;
   index_data = (IndexData *)client_data;
   printCheck(index_data);
 
   printf("[startedTranslationUnit]\n");
-  return (CXIdxContainer)"TU";
-}
-
-static CXIdxEntity index_indexTypedef(CXClientData client_data,
-                                      CXIdxTypedefInfo *info) {
-  printIndexedEntityInfo("[indexTypedef]", client_data, info->indexedEntityInfo);
-  printf("\n");
-  
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static CXIdxEntity index_indexFunction(CXClientData client_data,
-                                       CXIdxFunctionInfo *info) {
-  printIndexedEntityInfo("[indexFunction]", client_data, info->indexedEntityInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static void index_indexFunctionRedeclaration(CXClientData client_data,
-                                             CXIdxFunctionRedeclInfo *info) {
-  printIndexedRedeclInfo("[indexFunctionRedeclaration]", client_data,
-                         info->indexedRedeclInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-}
-
-static CXIdxEntity index_indexVariable(CXClientData client_data,
-                                       CXIdxVariableInfo *info) {
-  printIndexedEntityInfo("[indexVariable]", client_data, info->indexedEntityInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static void index_indexVariableRedeclaration(CXClientData client_data,
-                                             CXIdxVariableRedeclInfo *info) {
-  printIndexedRedeclInfo("[indexVariableRedeclaration]", client_data,
-                         info->indexedRedeclInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-}
-
-static CXIdxEntity index_indexTagType(CXClientData client_data,
-                                       CXIdxTagTypeInfo *info) {
-  printIndexedEntityInfo("[indexTagType]", client_data, info->indexedEntityInfo);
-  printf(" | isDefinition: %d | anon: %d\n",
-         info->isDefinition, info->isAnonymous);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
+  return (CXIdxClientContainer)"TU";
 }
 
-static void index_indexTagTypeRedeclaration(CXClientData client_data,
-                                             CXIdxTagTypeRedeclInfo *info) {
-  printIndexedRedeclInfo("[indexTagTypeRedeclaration]", client_data,
-                         info->indexedRedeclInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-}
-
-static CXIdxEntity index_indexField(CXClientData client_data,
-                                      CXIdxFieldInfo *info) {
-  printIndexedEntityInfo("[indexField]", client_data, info->indexedEntityInfo);
-  printf("\n");
-  
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
+static CXIdxClientEntity index_indexDeclaration(CXClientData client_data,
+                                                    CXIdxDeclInfo *info) {
+  IndexData *index_data;
+  index_data = (IndexData *)client_data;
 
-static CXIdxEntity index_indexEnumerator(CXClientData client_data,
-                                         CXIdxEnumeratorInfo *info) {
-  printIndexedEntityInfo("[indexEnumerator]", client_data,
-                         info->indexedEntityInfo);
-  printf("\n");
-  
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
+  printEntityInfo("[indexDeclaration]", client_data, info->entityInfo);
+  printf(" | cursor: ");
+  PrintCursor(info->cursor);
+  printf(" | loc: ");
+  printCXIndexLoc(info->loc);
+  printf(" | container: ");
+  printCXIndexContainer(info->container);
+  printf(" | isRedecl: %d", info->isRedeclaration);
+  printf(" | isDef: %d\n", info->isDefinition);
 
-static CXIdxContainer
-index_startedTagTypeDefinition(CXClientData client_data,
-                               CXIdxTagTypeDefinitionInfo *info) {
-  printStartedContainerInfo("[startedTagTypeDefinition]", client_data,
-                            info->containerInfo);
-  printf("\n");
   
-  return makeCXIndexContainer(info->containerInfo->entity);
-}
-
-static CXIdxEntity index_indexObjCClass(CXClientData client_data,
-                                       CXIdxObjCClassInfo *info) {
-  printIndexedEntityInfo("[indexObjCClass]", client_data,
-                         info->indexedEntityInfo);
-  printf(" | forward ref: %d\n", info->isForwardRef);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static CXIdxEntity index_indexObjCProtocol(CXClientData client_data,
-                                       CXIdxObjCProtocolInfo *info) {
-  printIndexedEntityInfo("[indexObjCProtocol]", client_data,
-                         info->indexedEntityInfo);
-  printf(" | forward ref: %d\n", info->isForwardRef);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static CXIdxEntity index_indexObjCCategory(CXClientData client_data,
-                                           CXIdxObjCCategoryInfo *info) {
-  printIndexedEntityInfo("[indexObjCCategory]", client_data,
-                         info->indexedEntityInfo);
-  printf(" | class: ");
-  printCXIndexEntity(info->objcClass);
-  printf("\n");
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
-
-static CXIdxEntity index_indexObjCMethod(CXClientData client_data,
-                                       CXIdxObjCMethodInfo *info) {
-  printIndexedEntityInfo("[indexObjCMethod]", client_data,
-                         info->indexedEntityInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
-
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
+  if (clang_index_isEntityTagKind(info->entityInfo->kind)) {
+    printCheck(index_data);
+    printf("     <TagInfo>: isAnonymous: %d\n",
+           clang_index_getTagDeclInfo(info)->isAnonymous);
+  }
+
+  if (clang_index_isEntityObjCContainerKind(info->entityInfo->kind)) {
+    const char *kindName = 0;
+    CXIdxObjCContainerKind K = clang_index_getObjCContainerDeclInfo(info)->kind;
+    switch (K) {
+    case CXIdxObjCContainer_ForwardRef:
+      kindName = "forward-ref"; break;
+    case CXIdxObjCContainer_Interface:
+      kindName = "interface"; break;
+    case CXIdxObjCContainer_Implementation:
+      kindName = "implementation"; break;
+    }
+    printCheck(index_data);
+    printf("     <ObjCContainerInfo>: kind: %s\n", kindName);
+  }
 
-static CXIdxEntity index_indexObjCProperty(CXClientData client_data,
-                                           CXIdxObjCPropertyInfo *info) {
-  printIndexedEntityInfo("[indexObjCProperty]", client_data,
-                         info->indexedEntityInfo);
-  printf("\n");
+  if (clang_index_isEntityObjCCategoryKind(info->entityInfo->kind)) {
+    CXIdxObjCCategoryDeclInfo *
+      CatInfo = clang_index_getObjCCategoryDeclInfo(info);
+    printEntityInfo("     <ObjCCategoryInfo>: class", client_data,
+                    CatInfo->objcClass);
+    printf("\n");
+  }
 
-  return makeCXIndexEntity(info->indexedEntityInfo);
-}
+  if (!info->isRedeclaration)
+    return makeClientEntity(info->entityInfo, info->loc);
 
-static void index_indexObjCMethodRedeclaration(CXClientData client_data,
-                                             CXIdxObjCMethodRedeclInfo *info) {
-  printIndexedRedeclInfo("[indexObjCMethodRedeclaration]", client_data,
-                         info->indexedRedeclInfo);
-  printf(" | isDefinition: %d\n", info->isDefinition);
+  return 0;
 }
 
-static CXIdxContainer
-index_startedStatementBody(CXClientData client_data,
-                           CXIdxStmtBodyInfo *info) {
-  printStartedContainerInfo("[startedStatementBody]", client_data,
-                            info->containerInfo);
-  printf(" | body: ");
-  printCXIndexLoc(info->bodyBegin);
-  printf("\n");
-  
-  return makeCXIndexContainer(info->containerInfo->entity);
-}
+static CXIdxClientContainer
+index_startedContainer(CXClientData client_data, CXIdxContainerInfo *info) {
+  printEntityInfo("[startedContainer]", client_data, info->entity);
+  printf(" | cursor: ");
+  PrintCursor(info->cursor);
+  printf(" | loc: ");
+  printCXIndexLoc(info->loc);
+  printf(" | isObjCImpl: %d\n", info->isObjCImpl);
 
-static CXIdxContainer
-index_startedObjCContainer(CXClientData client_data,
-                           CXIdxObjCContainerInfo *info) {
-  printStartedContainerInfo("[startedObjCContainer]", client_data,
-                            info->containerInfo);
-  printf("\n");
-  
-  return makeCXIndexContainer(info->containerInfo->entity);
+  return (CXIdxClientContainer)info->entity->clientEntity;
 }
 
 static void index_defineObjCClass(CXClientData client_data,
                                   CXIdxObjCClassDefineInfo *info) {
-  IndexData *index_data;
-  index_data = (IndexData *)client_data;
-  printCheck(index_data);
-
-  printf("[defineObjCClass]: ");
-  printCXIndexEntity(info->objcClass);
+  printEntityInfo("[defineObjCClass]", client_data, info->objcClass);
   printf(" | cursor: ");
   PrintCursor(info->cursor);
   printf(" | container: ");
   printCXIndexContainer(info->container);
   
   if (info->baseInfo) {
-    printf(" | base: ");
-    printCXIndexEntity(info->baseInfo->objcClass);
+    printEntityInfo(" | <base>", client_data, info->baseInfo->objcClass);
     printf(" | base loc: ");
     printCXIndexLoc(info->baseInfo->loc);
   }
@@ -1972,18 +1845,12 @@ static void index_endedContainer(CXClientData client_data,
 
 static void index_indexEntityReference(CXClientData client_data,
                                        CXIdxEntityRefInfo *info) {
-  IndexData *index_data;
-  index_data = (IndexData *)client_data;
-  printCheck(index_data);
-
-  printf("[indexEntityReference]: ");
-  printCXIndexEntity(info->referencedEntity);
+  printEntityInfo("[indexEntityReference]", client_data, info->referencedEntity);
   printf(" | cursor: ");
   PrintCursor(info->cursor);
   printf(" | loc: ");
   printCXIndexLoc(info->loc);
-  printf(" | parent: ");
-  printCXIndexEntity(info->parentEntity);
+  printEntityInfo(" | <parent>:", client_data, info->parentEntity);
   printf(" | container: ");
   printCXIndexContainer(info->container);
   printf(" | kind: ");
@@ -1996,7 +1863,7 @@ static void index_indexEntityReference(CXClientData client_data,
 
 static IndexerCallbacks IndexCB = {
   index_diagnostic,
-  index_recordFile,
+  index_enteredMainFile,
   index_ppIncludedFile,
   index_ppMacroDefined,
   index_ppMacroUndefined,
@@ -2005,24 +1872,8 @@ static IndexerCallbacks IndexCB = {
   index_importedEntity,
   0,/*index_importedMacro,*/
   index_startedTranslationUnit,
-  index_indexTypedef,
-  index_indexFunction,
-  index_indexFunctionRedeclaration,
-  index_indexVariable,
-  index_indexVariableRedeclaration,
-  index_indexTagType,
-  index_indexTagTypeRedeclaration,
-  index_indexField,
-  index_indexEnumerator,
-  index_startedTagTypeDefinition,
-  index_indexObjCClass,
-  index_indexObjCProtocol,
-  index_indexObjCCategory,
-  index_indexObjCMethod,
-  index_indexObjCProperty,
-  index_indexObjCMethodRedeclaration,
-  index_startedStatementBody,
-  index_startedObjCContainer,
+  index_indexDeclaration,
+  index_startedContainer,
   index_defineObjCClass,
   index_endedContainer,
   index_indexEntityReference
diff --git a/tools/libclang/IndexDecl.cpp b/tools/libclang/IndexDecl.cpp
index 5cf9f80263..5087355a8d 100644
--- a/tools/libclang/IndexDecl.cpp
+++ b/tools/libclang/IndexDecl.cpp
@@ -29,9 +29,9 @@ public:
     if (D->isThisDeclarationADefinition()) {
       const Stmt *Body = D->getBody();
       if (Body) {
-        IndexCtx.invokeStartedStatementBody(D, D);
+        IndexCtx.startContainer(D, /*isBody=*/true);
         IndexCtx.indexBody(Body, D);
-        IndexCtx.invokeEndedContainer(D);
+        IndexCtx.endContainer(D);
       }
     }
     return true;
@@ -68,15 +68,7 @@ public:
   }
 
   bool VisitObjCClassDecl(ObjCClassDecl *D) {
-    ObjCClassDecl::ObjCClassRef *Ref = D->getForwardDecl();
-    if (Ref->getInterface()->getLocation() == Ref->getLocation()) {
-      IndexCtx.handleObjCInterface(Ref->getInterface());
-    } else {
-      IndexCtx.handleReference(Ref->getInterface(),
-                               Ref->getLocation(),
-                               0,
-                               Ref->getInterface()->getDeclContext());
-    }
+    IndexCtx.handleObjCClass(D);
     return true;
   }
 
@@ -87,74 +79,71 @@ public:
       SourceLocation Loc = *LI;
       ObjCProtocolDecl *PD = *I;
 
-      if (PD->getLocation() == Loc) {
-        IndexCtx.handleObjCProtocol(PD);
-      } else {
-        IndexCtx.handleReference(PD, Loc, 0, PD->getDeclContext());
-      }
+      bool isRedeclaration = PD->getLocation() != Loc;
+      IndexCtx.handleObjCForwardProtocol(PD, Loc, isRedeclaration);
     }
     return true;
   }
 
   bool VisitObjCInterfaceDecl(ObjCInterfaceDecl *D) {
-    // Only definitions are handled here.
+    // Forward decls are handled at VisitObjCClassDecl.
     if (D->isForwardDecl())
       return true;
 
-    if (!D->isInitiallyForwardDecl())
-      IndexCtx.handleObjCInterface(D);
+    IndexCtx.handleObjCInterface(D);
 
     IndexCtx.indexTUDeclsInObjCContainer();
-    IndexCtx.invokeStartedObjCContainer(D);
+    IndexCtx.startContainer(D);
     IndexCtx.defineObjCInterface(D);
     IndexCtx.indexDeclContext(D);
-    IndexCtx.invokeEndedContainer(D);
+    IndexCtx.endContainer(D);
     return true;
   }
 
   bool VisitObjCProtocolDecl(ObjCProtocolDecl *D) {
-    // Only definitions are handled here.
+    // Forward decls are handled at VisitObjCForwardProtocolDecl.
     if (D->isForwardDecl())
       return true;
 
-    if (!D->isInitiallyForwardDecl())
-      IndexCtx.handleObjCProtocol(D);
+    IndexCtx.handleObjCProtocol(D);
 
     IndexCtx.indexTUDeclsInObjCContainer();
-    IndexCtx.invokeStartedObjCContainer(D);
+    IndexCtx.startContainer(D);
     IndexCtx.indexDeclContext(D);
-    IndexCtx.invokeEndedContainer(D);
+    IndexCtx.endContainer(D);
     return true;
   }
 
   bool VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
-    ObjCInterfaceDecl *Class = D->getClassInterface();
-    if (Class->isImplicitInterfaceDecl())
-      IndexCtx.handleObjCInterface(Class);
+    IndexCtx.handleObjCImplementation(D);
 
     IndexCtx.indexTUDeclsInObjCContainer();
-    IndexCtx.invokeStartedObjCContainer(D);
+    IndexCtx.startContainer(D);
     IndexCtx.indexDeclContext(D);
-    IndexCtx.invokeEndedContainer(D);
+    IndexCtx.endContainer(D);
     return true;
   }
 
   bool VisitObjCCategoryDecl(ObjCCategoryDecl *D) {
-    if (!D->IsClassExtension())
-      IndexCtx.handleObjCCategory(D);
+    IndexCtx.handleObjCCategory(D);
 
     IndexCtx.indexTUDeclsInObjCContainer();
-    IndexCtx.invokeStartedObjCContainer(D);
+    IndexCtx.startContainer(D);
     IndexCtx.indexDeclContext(D);
-    IndexCtx.invokeEndedContainer(D);
+    IndexCtx.endContainer(D);
     return true;
   }
 
   bool VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
+    if (D->getCategoryDecl()->getLocation().isInvalid())
+      return true;
+
+    IndexCtx.handleObjCCategoryImpl(D);
+
     IndexCtx.indexTUDeclsInObjCContainer();
-    IndexCtx.invokeStartedObjCContainer(D);
+    IndexCtx.startContainer(D);
     IndexCtx.indexDeclContext(D);
-    IndexCtx.invokeEndedContainer(D);
+    IndexCtx.endContainer(D);
     return true;
   }
 
@@ -168,9 +157,9 @@ public:
     if (D->isThisDeclarationADefinition()) {
       const Stmt *Body = D->getBody();
       if (Body) {
-        IndexCtx.invokeStartedStatementBody(D, D);
+        IndexCtx.startContainer(D, /*isBody=*/true);
         IndexCtx.indexBody(Body, D);
-        IndexCtx.invokeEndedContainer(D);
+        IndexCtx.endContainer(D);
       }
     }
     return true;
diff --git a/tools/libclang/IndexTypeSourceInfo.cpp b/tools/libclang/IndexTypeSourceInfo.cpp
index 63446450f3..bba9dbb6e7 100644
--- a/tools/libclang/IndexTypeSourceInfo.cpp
+++ b/tools/libclang/IndexTypeSourceInfo.cpp
@@ -87,8 +87,8 @@ void IndexingContext::indexTypeLoc(TypeLoc TL,
 void IndexingContext::indexTagDecl(const TagDecl *D) {
   handleTagDecl(D);
   if (D->isThisDeclarationADefinition()) {
-    invokeStartedTagTypeDefinition(D);
+    startContainer(D);
     indexDeclContext(D);
-    invokeEndedContainer(D);
+    endContainer(D);
   }
 }
diff --git a/tools/libclang/Indexing.cpp b/tools/libclang/Indexing.cpp
index 7f296ae1d1..4bea88f8de 100644
--- a/tools/libclang/Indexing.cpp
+++ b/tools/libclang/Indexing.cpp
@@ -40,10 +40,25 @@ namespace {
 class IndexPPCallbacks : public PPCallbacks {
   Preprocessor &PP;
   IndexingContext &IndexCtx;
+  bool IsMainFileEntered;
 
 public:
   IndexPPCallbacks(Preprocessor &PP, IndexingContext &indexCtx)
-    : PP(PP), IndexCtx(indexCtx) { }
+    : PP(PP), IndexCtx(indexCtx), IsMainFileEntered(false) { }
+
+  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
+                          SrcMgr::CharacteristicKind FileType, FileID PrevFID) {
+    if (IsMainFileEntered)
+      return;
+
+    SourceManager &SM = PP.getSourceManager();
+    SourceLocation MainFileLoc = SM.getLocForStartOfFile(SM.getMainFileID());
+
+    if (Loc == MainFileLoc && Reason == PPCallbacks::EnterFile) {
+      IsMainFileEntered = true;
+      IndexCtx.enteredMainFile(SM.getFileEntryForID(SM.getMainFileID()));
+    }
+  }
 
   virtual void InclusionDirective(SourceLocation HashLoc,
                                   const Token &IncludeTok,
@@ -389,6 +404,41 @@ static void clang_indexTranslationUnit_Impl(void *UserData) {
 
 extern "C" {
 
+int clang_index_isEntityTagKind(CXIdxEntityKind K) {
+  return CXIdxEntity_Enum <= K && K <= CXIdxEntity_CXXClass;
+}
+
+CXIdxTagDeclInfo *clang_index_getTagDeclInfo(CXIdxDeclInfo *DInfo) {
+  if (clang_index_isEntityTagKind(DInfo->entityInfo->kind))
+    return &static_cast<TagDeclInfo*>(DInfo)->CXTagDeclInfo;
+
+  return 0;
+}
+
+int clang_index_isEntityObjCContainerKind(CXIdxEntityKind K) {
+  return CXIdxEntity_ObjCClass <= K && K <= CXIdxEntity_ObjCCategory;
+}
+
+CXIdxObjCContainerDeclInfo *
+clang_index_getObjCContainerDeclInfo(CXIdxDeclInfo *DInfo) {
+  if (clang_index_isEntityObjCContainerKind(DInfo->entityInfo->kind))
+    return &static_cast<ObjCContainerDeclInfo*>(DInfo)->CXObjCContDeclInfo;
+
+  return 0;
+}
+
+int clang_index_isEntityObjCCategoryKind(CXIdxEntityKind K) {
+  return K == CXIdxEntity_ObjCCategory;
+}
+
+CXIdxObjCCategoryDeclInfo *
+clang_index_getObjCCategoryDeclInfo(CXIdxDeclInfo *DInfo){
+  if (clang_index_isEntityObjCCategoryKind(DInfo->entityInfo->kind))
+    return &static_cast<ObjCCategoryDeclInfo*>(DInfo)->CXObjCCatDeclInfo;
+
+  return 0;
+}
+
 int clang_indexTranslationUnit(CXIndex CIdx,
                                 CXClientData client_data,
                                 IndexerCallbacks *index_callbacks,
@@ -445,7 +495,7 @@ int clang_indexTranslationUnit(CXIndex CIdx,
 }
 
 void clang_indexLoc_getFileLocation(CXIdxLoc location,
-                                    CXIdxFile *indexFile,
+                                    CXIdxClientFile *indexFile,
                                     CXFile *file,
                                     unsigned *line,
                                     unsigned *column,
diff --git a/tools/libclang/IndexingContext.cpp b/tools/libclang/IndexingContext.cpp
index 0f00bac948..3d3277210e 100644
--- a/tools/libclang/IndexingContext.cpp
+++ b/tools/libclang/IndexingContext.cpp
@@ -33,6 +33,13 @@ void IndexingContext::setASTContext(ASTContext &ctx) {
   static_cast<ASTUnit*>(CXTU->TUData)->setASTContext(&ctx);
 }
 
+void IndexingContext::enteredMainFile(const FileEntry *File) {
+  if (File && CB.enteredMainFile) {
+    CXIdxClientFile idxFile = CB.enteredMainFile(ClientData, (CXFile)File, 0);
+    FileMap[File] = idxFile;
+  }
+}
+
 void IndexingContext::ppIncludedFile(SourceLocation hashLoc,
                                      StringRef filename,
                                      const FileEntry *File,
@@ -40,12 +47,13 @@ void IndexingContext::ppIncludedFile(SourceLocation hashLoc,
   if (!CB.ppIncludedFile)
     return;
 
-  StrAdapter SA(this);
+  StrAdapter SA(*this);
   CXIdxIncludedFileInfo Info = { getIndexLoc(hashLoc),
                                  SA.toCStr(filename),
-                                 getIndexFile(File),
+                                 (CXFile)File,
                                  isImport, isAngled };
-  CB.ppIncludedFile(ClientData, &Info);
+  CXIdxClientFile idxFile = CB.ppIncludedFile(ClientData, &Info);
+  FileMap[File] = idxFile;
 }
 
 void IndexingContext::ppMacroDefined(SourceLocation Loc, StringRef Name,
@@ -54,11 +62,11 @@ void IndexingContext::ppMacroDefined(SourceLocation Loc, StringRef Name,
   if (!CB.ppMacroDefined)
     return;
 
-  StrAdapter SA(this);
+  StrAdapter SA(*this);
   CXIdxMacroInfo MacroInfo =  { getIndexLoc(Loc), SA.toCStr(Name) }; 
   CXIdxMacroDefinedInfo Info = { &MacroInfo,
                                  getIndexLoc(DefBegin), Length };
-  CXIdxMacro idxMacro = CB.ppMacroDefined(ClientData, &Info);
+  CXIdxClientMacro idxMacro = CB.ppMacroDefined(ClientData, &Info);
   MacroMap[OpaqueMacro] = idxMacro;
 }
 
@@ -67,7 +75,7 @@ void IndexingContext::ppMacroUndefined(SourceLocation Loc, StringRef Name,
   if (!CB.ppMacroUndefined)
     return;
 
-  StrAdapter SA(this);
+  StrAdapter SA(*this);
   CXIdxMacroUndefinedInfo Info = { getIndexLoc(Loc),
                                    SA.toCStr(Name), 0 };
   CB.ppMacroUndefined(ClientData, &Info);
@@ -78,21 +86,21 @@ void IndexingContext::ppMacroExpanded(SourceLocation Loc, StringRef Name,
   if (!CB.ppMacroExpanded)
     return;
 
-  StrAdapter SA(this);
+  StrAdapter SA(*this);
   CXIdxMacroExpandedInfo Info = { getIndexLoc(Loc),
                                    SA.toCStr(Name), 0 };
   CB.ppMacroExpanded(ClientData, &Info);
 }
 
 void IndexingContext::invokeStartedTranslationUnit() {
-  CXIdxContainer idxCont = 0;
+  CXIdxClientContainer idxCont = 0;
   if (CB.startedTranslationUnit)
     idxCont = CB.startedTranslationUnit(ClientData, 0);
   addContainerInMap(Ctx->getTranslationUnitDecl(), idxCont);
 }
 
 void IndexingContext::invokeFinishedTranslationUnit() {
-  invokeEndedContainer(Ctx->getTranslationUnitDecl());
+  endContainer(Ctx->getTranslationUnitDecl());
 }
 
 void IndexingContext::handleDiagnostic(const StoredDiagnostic &StoredDiag) {
@@ -103,197 +111,172 @@ void IndexingContext::handleDiagnostic(const StoredDiagnostic &StoredDiag) {
   CB.diagnostic(ClientData, &CXDiag, 0);
 }
 
-void IndexingContext::handleFunction(const FunctionDecl *D) {
-  StrAdapter SA(this);
-
-  if (D->isFirstDeclaration()) {
-    CXIdxEntity idxEntity = 0;
-    if (CB.indexFunction) {
-      CXIdxEntityInfo EntityInfo;
-      CXIdxIndexedDeclInfo DeclInfo;
-      CXIdxIndexedEntityInfo IdxEntityInfo;
-      getIndexedEntityInfo(D, IdxEntityInfo, EntityInfo, DeclInfo, SA);
-      CXIdxFunctionInfo Info = { &IdxEntityInfo,
-                                 D->isThisDeclarationADefinition() };
-
-      idxEntity = CB.indexFunction(ClientData, &Info);
-    }
+void IndexingContext::handleDecl(const NamedDecl *D,
+                                 SourceLocation Loc, CXCursor Cursor,
+                                 bool isRedeclaration, bool isDefinition,
+                                 DeclInfo &DInfo) {
+  if (!CB.indexDeclaration)
+    return;
 
-    addEntityInMap(D, idxEntity);
+  StrAdapter SA(*this);
+  getEntityInfo(D, DInfo.CXEntInfo, SA);
+  DInfo.entityInfo = &DInfo.CXEntInfo;
+  DInfo.cursor = Cursor;
+  DInfo.loc = getIndexLoc(Loc);
+  DInfo.container = getIndexContainer(D);
+  DInfo.isRedeclaration = isRedeclaration;
+  DInfo.isDefinition = isDefinition;
+
+  CXIdxClientEntity
+    clientEnt = CB.indexDeclaration(ClientData, &DInfo);
+
+  if (!isRedeclaration)
+    addEntityInMap(D, clientEnt);
+}
+
+void IndexingContext::handleObjCContainer(const ObjCContainerDecl *D,
+                                          SourceLocation Loc, CXCursor Cursor,
+                                          bool isForwardRef,
+                                          bool isRedeclaration,
+                                          bool isImplementation,
+                                          ObjCContainerDeclInfo &ContDInfo) {
+  ContDInfo.CXObjCContDeclInfo.declInfo = &ContDInfo;
+  if (isForwardRef)
+    ContDInfo.CXObjCContDeclInfo.kind = CXIdxObjCContainer_ForwardRef;
+  else if (isImplementation)
+    ContDInfo.CXObjCContDeclInfo.kind = CXIdxObjCContainer_Implementation;
+  else
+    ContDInfo.CXObjCContDeclInfo.kind = CXIdxObjCContainer_Interface;
 
-  } else {
-    if (CB.indexFunctionRedeclaration) {
-      CXIdxIndexedDeclInfo DeclInfo;
-      CXIdxIndexedRedeclInfo RedeclInfo;
-      getIndexedRedeclInfo(D, RedeclInfo, DeclInfo);
-      CXIdxFunctionRedeclInfo Info = { &RedeclInfo,
-                                       D->isThisDeclarationADefinition() };
-
-      CB.indexFunctionRedeclaration(ClientData, &Info);
-    }
-  }
+  handleDecl(D, Loc, Cursor,
+             isRedeclaration, /*isDefinition=*/!isForwardRef, ContDInfo);
 }
 
-void IndexingContext::handleVar(const VarDecl *D) {
-  StrAdapter SA(this);
-
-  if (D->isFirstDeclaration()) {
-    CXIdxEntity idxEntity = 0;
-    if (CB.indexVariable) {
-      CXIdxEntityInfo EntityInfo;
-      CXIdxIndexedDeclInfo DeclInfo;
-      CXIdxIndexedEntityInfo IdxEntityInfo;