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;
-      getIndexedEntityInfo(D, IdxEntityInfo, EntityInfo, DeclInfo, SA);
-      CXIdxVariableInfo Info = { &IdxEntityInfo,
-                                 D->isThisDeclarationADefinition() };
-
-      idxEntity = CB.indexVariable(ClientData, &Info);
-    }
-
-    addEntityInMap(D, idxEntity);
+void IndexingContext::handleFunction(const FunctionDecl *D) {
+  DeclInfo DInfo;
+  handleDecl(D, D->getLocation(), getCursor(D),
+             !D->isFirstDeclaration(), D->isThisDeclarationADefinition(),
+             DInfo);
+}
 
-  } else {
-    if (CB.indexVariableRedeclaration) {
-      CXIdxIndexedDeclInfo DeclInfo;
-      CXIdxIndexedRedeclInfo RedeclInfo;
-      getIndexedRedeclInfo(D, RedeclInfo, DeclInfo);
-      CXIdxVariableRedeclInfo Info = { &RedeclInfo,
-                                       D->isThisDeclarationADefinition() };
-
-      CB.indexVariableRedeclaration(ClientData, &Info);
-    }
-  }
+void IndexingContext::handleVar(const VarDecl *D) {
+  DeclInfo DInfo;
+  handleDecl(D, D->getLocation(), getCursor(D),
+             !D->isFir