[libclang] Expose completion result kind in `CXCompletionResult`

[egorzhdan]

Summary

This allows clients of libclang to check whether a completion result is a keyword. Previously, keywords had CursorKind == CXCursor_NotImplemented and it wasn't trivial to distinguish a keyword from a pattern.

This change moves CodeCompletionResult::ResultKind to clang-c under a new name CXCompletionResultKind. It also tweaks c-index-test to print the result kind instead of NotImplemented, and adjusts the tests for the new output.

rdar://91852088

[kadircet]

clang/include/clang/Sema/CodeCompleteConsumer.h

755

i don't follow the reason for replacing this struct with CXCompletionResultKind and renaming occurrences in half of the codebase. can we keep this around, introduce the new enum type into Index.h and have clang/tools/libclang/CIndexCodeCompletion.cpp do the conversion from Sema type to Index type instead?

Unless I am missing some other requirement for doing so. i feel like the conceptual dependency from Sema to Index is one we should get rid of, rather than make tighter.

[egorzhdan]

Fix clangd compilation

[egorzhdan]

clang/include/clang/Sema/CodeCompleteConsumer.h

755

This was mostly done to be consistent with the way CXCursorKind and CXAvailabilityKind are declared in Index.h and used as fields of CodeCompletionResult. I think updating the enum name in a few source files shouldn't be a major problem, but I can avoid it if you feel strongly against this approach.

[kadircet]

clang/include/clang/Sema/CodeCompleteConsumer.h

755

I completely agree with the consistency argument, but IMO the conceptual dependency from clang-sema to clang-cindex is just wrong.

cindex is mostly implemented by libclang, which is part of clang-tools. all of this works today because clang-sema is only using declarations visible in headers and doesn't properly depend on libclang in the build files.

Hence I believe rather than preserving consistency here, we should be moving towards breaking that dependency over time. Therefore I was opposing the idea of introducing another type usage that'll make this dependency more strong.

[egorzhdan]

clang/include/clang/Sema/CodeCompleteConsumer.h

755

all of this works today because clang-sema is only using declarations visible in headers and doesn't properly depend on libclang in the build files.

Oh I see, this is a great point, I didn't realize that. I'll update the patch.

[egorzhdan]

Preserve CodeCompletionResult::ResultKind and do the conversion to
CXCompletionResultKind in CIndexCodeCompletion.cpp.

[bnbarham]

Thanks Egor!

[arphaman]

LGTM!

[omjavaid]

Hi this broke https://lab.llvm.org/buildbot/#/builders/245/builds/761
I have reverted the change to make the buildbot green.

clang-tools-extra/clangd/CodeComplete.cpp

case SK::TemplateTemplateParm:
     return CompletionItemKind::TypeParameter;
   case SK::Concept:
     return CompletionItemKind::Interface;
   }
   llvm_unreachable("Unhandled clang::index::SymbolKind.");
 }
 
 CompletionItemKind
-toCompletionItemKind(CodeCompletionResult::ResultKind ResKind,
+toCompletionItemKind(CXCompletionResultKind ResKind,
                      const NamedDecl *Decl,
                      CodeCompletionContext::Kind CtxKind) {
   if (Decl)
     return toCompletionItemKind(index::getSymbolInfo(Decl).Kind);
   if (CtxKind == CodeCompletionContext::CCC_IncludedFile)
     return CompletionItemKind::File;
   switch (ResKind) {
-  case CodeCompletionResult::RK_Declaration:
-    llvm_unreachable("RK_Declaration without Decl");
-  case CodeCompletionResult::RK_Keyword:
+  case CXCompletionResult_Declaration:
+    llvm_unreachable("CXCompletionResult_Declaration without Decl");
+  case CXCompletionResult_Keyword:
     return CompletionItemKind::Keyword;
-  case CodeCompletionResult::RK_Macro:
+  case CXCompletionResult_Macro:
     return CompletionItemKind::Text; // unfortunately, there's no 'Macro'
                                      // completion items in LSP.
-  case CodeCompletionResult::RK_Pattern:
+  case CXCompletionResult_Pattern:
     return CompletionItemKind::Snippet;
   }
   llvm_unreachable("Unhandled CodeCompletionResult::ResultKind.");
 }
 
 // FIXME: find a home for this (that can depend on both markup and Protocol).
 MarkupContent renderDoc(const markup::Document &Doc, MarkupKind Kind) {
   MarkupContent Result;
CodeCompletionBuilder(ASTContext *ASTCtx, const CompletionCandidate &C,
     Completion.Deprecated = true; // cleared by any non-deprecated overload.
     add(C, SemaCCS);
     if (C.SemaResult) {
       assert(ASTCtx);
       Completion.Origin |= SymbolOrigin::AST;
       Completion.Name = std::string(llvm::StringRef(SemaCCS->getTypedText()));
       Completion.FilterText = SemaCCS->getAllTypedText();
       if (Completion.Scope.empty()) {
-        if ((C.SemaResult->Kind == CodeCompletionResult::RK_Declaration) ||
-            (C.SemaResult->Kind == CodeCompletionResult::RK_Pattern))
+        if ((C.SemaResult->Kind == CXCompletionResult_Declaration) ||
+            (C.SemaResult->Kind == CXCompletionResult_Pattern))
           if (const auto *D = C.SemaResult->getDeclaration())
             if (const auto *ND = dyn_cast<NamedDecl>(D))
               Completion.Scope = std::string(
                   splitQualifiedName(printQualifiedName(*ND)).first);
       }
       Completion.Kind = toCompletionItemKind(
           C.SemaResult->Kind, C.SemaResult->Declaration, ContextKind);
       // Sema could provide more info on whether the completion was a file or
std::stable_partition(Completion.Includes.begin(),
                           });
   }
 
   void add(const CompletionCandidate &C, CodeCompletionString *SemaCCS) {
     assert(bool(C.SemaResult) == bool(SemaCCS));
     Bundled.emplace_back();
     BundledEntry &S = Bundled.back();
     if (C.SemaResult) {
-      bool IsPattern = C.SemaResult->Kind == CodeCompletionResult::RK_Pattern;
+      bool IsPattern = C.SemaResult->Kind == CXCompletionResult_Pattern;
       getSignature(*SemaCCS, &S.Signature, &S.SnippetSuffix,
                    &Completion.RequiredQualifier, IsPattern);
       S.ReturnType = getReturnType(*SemaCCS);
     } else if (C.IndexResult) {
       S.Signature = std::string(C.IndexResult->Signature);
       S.SnippetSuffix = std::string(C.IndexResult->CompletionSnippetSuffix);
       S.ReturnType = std::string(C.IndexResult->ReturnType);
     }
private:
   // arguments are already present.
   bool IsUsingDeclaration;
   tok::TokenKind NextTokenKind;
 };
 
 // Determine the symbol ID for a Sema code completion result, if possible.
 SymbolID getSymbolID(const CodeCompletionResult &R, const SourceManager &SM) {
   switch (R.Kind) {
-  case CodeCompletionResult::RK_Declaration:
-  case CodeCompletionResult::RK_Pattern: {
+  case CXCompletionResult_Declaration:
+  case CXCompletionResult_Pattern: {
     // Computing USR caches linkage, which may change after code completion.
     if (hasUnstableLinkage(R.Declaration))
       return {};
     return clang::clangd::getSymbolID(R.Declaration);
   }
-  case CodeCompletionResult::RK_Macro:
+  case CXCompletionResult_Macro:
     return clang::clangd::getSymbolID(R.Macro->getName(), R.MacroDefInfo, SM);
-  case CodeCompletionResult::RK_Keyword:
+  case CXCompletionResult_Keyword:
     return {};
   }
   llvm_unreachable("unknown CodeCompletionResult kind");
 }
 
 // Scopes of the partial identifier we're trying to complete.
 // It is used when we query the index for more completion results.
 struct SpecifiedScope {
struct CompletionRecorder : public CodeCompleteConsumer {
 
   CodeCompletionAllocator &getAllocator() override { return *CCAllocator; }
   CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return CCTUInfo; }
 
   // Returns the filtering/sorting name for Result, which must be from Results.
   // Returned string is owned by this recorder (or the AST).
   llvm::StringRef getName(const CodeCompletionResult &Result) {
     switch (Result.Kind) {
-    case CodeCompletionResult::RK_Declaration:
+    case CXCompletionResult_Declaration:
       if (auto *ID = Result.Declaration->getIdentifier())
         return ID->getName();
       break;
-    case CodeCompletionResult::RK_Keyword:
+    case CXCompletionResult_Keyword:
       return Result.Keyword;
-    case CodeCompletionResult::RK_Macro:
+    case CXCompletionResult_Macro:
       return Result.Macro->getName();
-    case CodeCompletionResult::RK_Pattern:
+    case CXCompletionResult_Pattern:
       break;
     }
     auto *CCS = codeCompletionString(Result);
     const CodeCompletionString::Chunk *OnlyText = nullptr;
     for (auto &C : *CCS) {
       if (C.Kind != CodeCompletionString::CK_TypedText)
         continue;
       if (OnlyText)
mergeResults(const std::vector<CodeCompletionResult> &SemaResults,
     for (auto &Bundle : Bundles)
       addCandidate(Top, std::move(Bundle));
     return std::move(Top).items();
   }
 
   llvm::Optional<float> fuzzyScore(const CompletionCandidate &C) {
     // Macros can be very spammy, so we only support prefix completion.
     if (((C.SemaResult &&
-          C.SemaResult->Kind == CodeCompletionResult::RK_Macro) ||
+          C.SemaResult->Kind == CXCompletionResult_Macro) ||
          (C.IndexResult &&
           C.IndexResult->SymInfo.Kind == index::SymbolKind::Macro)) &&
         !C.Name.startswith_insensitive(Filter->pattern()))
       return None;
     return Filter->match(C.Name);
   }
 
   CodeCompletion::Scores

clang-tools-extra/clangd/CodeCompletionStrings.cpp

bool looksLikeDocComment(llvm::StringRef CommentText) {
   return CommentText.find_first_not_of("/*-= \t\r\n") != llvm::StringRef::npos;
 }
 
 } // namespace
 
 std::string getDocComment(const ASTContext &Ctx,
                           const CodeCompletionResult &Result,
                           bool CommentsFromHeaders) {
-  // FIXME: clang's completion also returns documentation for RK_Pattern if they
-  // contain a pattern for ObjC properties. Unfortunately, there is no API to
-  // get this declaration, so we don't show documentation in that case.
-  if (Result.Kind != CodeCompletionResult::RK_Declaration)
+  // FIXME: clang's completion also returns documentation for
+  // CXCompletionResult_Pattern if they contain a pattern for ObjC properties.
+  // Unfortunately, there is no API to get this declaration, so we don't show
+  // documentation in that case.
+  if (Result.Kind != CXCompletionResult_Declaration)
     return "";
   return Result.getDeclaration() ? getDeclComment(Ctx, *Result.getDeclaration())
                                  : "";
 }
 
 std::string getDeclComment(const ASTContext &Ctx, const NamedDecl &Decl) {
   if (isa<NamespaceDecl>(Decl)) {
     // Namespaces often have too many redecls for any particular redecl comment

clang-tools-extra/clangd/Quality.cpp

#undef MAP
   };
   return Switch().Visit(&ND);
 }
 
 static SymbolQualitySignals::SymbolCategory
 categorize(const CodeCompletionResult &R) {
   if (R.Declaration)
     return categorize(*R.Declaration);
-  if (R.Kind == CodeCompletionResult::RK_Macro)
+  if (R.Kind == CXCompletionResult_Macro)
     return SymbolQualitySignals::Macro;
   // Everything else is a keyword or a pattern. Patterns are mostly keywords
   // too, except a few which we recognize by cursor kind.
   switch (R.CursorKind) {
   case CXCursor_CXXMethod:
     return SymbolQualitySignals::Function;
   case CXCursor_ModuleImportDecl:
     return SymbolQualitySignals::Namespace;

 void SymbolQualitySignals::merge(const CodeCompletionResult &SemaCCResult) {
   Deprecated |= (SemaCCResult.Availability == CXAvailability_Deprecated);
   Category = categorize(SemaCCResult);
 
   if (SemaCCResult.Declaration) {
     ImplementationDetail |= isImplementationDetail(SemaCCResult.Declaration);
     if (auto *ID = SemaCCResult.Declaration->getIdentifier())
       ReservedName = ReservedName || isReservedName(ID->getName());
-  } else if (SemaCCResult.Kind == CodeCompletionResult::RK_Macro)
+  } else if (SemaCCResult.Kind == CXCompletionResult_Macro)
     ReservedName =
         ReservedName || isReservedName(SemaCCResult.Macro->getName());
 }
 
 void SymbolQualitySignals::merge(const Symbol &IndexResult) {
   Deprecated |= (IndexResult.Flags & Symbol::Deprecated);
   ImplementationDetail |= (IndexResult.Flags & Symbol::ImplementationDetail);
   References = std::max(IndexResult.References, References);
ScopeRefsInFile =
                  MainFileSignals->RelatedNamespaces.lookup(IndexResult.Scope));
   }
 }
 
 void SymbolRelevanceSignals::computeASTSignals(
     const CodeCompletionResult &SemaResult) {
   if (!MainFileSignals)
     return;
-  if ((SemaResult.Kind != CodeCompletionResult::RK_Declaration) &&
-      (SemaResult.Kind != CodeCompletionResult::RK_Pattern))
+  if ((SemaResult.Kind != CXCompletionResult_Declaration) &&
+      (SemaResult.Kind != CXCompletionResult_Pattern))
     return;
   if (const NamedDecl *ND = SemaResult.getDeclaration()) {
     auto ID = getSymbolID(ND);
     if (!ID)
       return;
     MainFileRefs =
         std::max(MainFileRefs, MainFileSignals->ReferencedSymbols.lookup(ID));
     if (const auto *NSD = dyn_cast<NamespaceDecl>(ND->getDeclContext())) {

clang/include/clang-c/Index.h

 
   /**
    * A code completion overload candidate.
    */
   CXCursor_OverloadCandidate = 700
 };
 
 /**
+ * Describes the kind of result generated.
+ */
+enum CXCompletionResultKind {
+  /** Refers to a declaration. */
+  CXCompletionResult_Declaration = 0,
+
+  /** Refers to a keyword or symbol. */
+  CXCompletionResult_Keyword = 1,
+
+  /** Refers to a macro. */
+  CXCompletionResult_Macro = 2,
+
+  /** Refers to a precomputed pattern. */
+  CXCompletionResult_Pattern = 3
+};
+
+/**
  * A cursor representing some element in the abstract syntax tree for
  * a translation unit.
  *
  * The cursor abstraction unifies the different kinds of entities in a
  * program--declaration, statements, expressions, references to declarations,
  * etc.--under a single "cursor" abstraction with a common set of operations.
  * Common operation for a cursor include: getting the physical location in
  * a source file where the cursor points, getting the name associated with a

  *
  * These routines are used for testing and debugging, only, and should not
  * be relied upon.
  *
  * @{
  */
 
 /* for debug/testing */
+CINDEX_LINKAGE CXString
+clang_getCompletionResultKindSpelling(enum CXCompletionResultKind Kind);
 CINDEX_LINKAGE CXString clang_getCursorKindSpelling(enum CXCursorKind Kind);
 CINDEX_LINKAGE void clang_getDefinitionSpellingAndExtent(
     CXCursor, const char **startBuf, const char **endBuf, unsigned *startLine,
     unsigned *startColumn, unsigned *endLine, unsigned *endColumn);
 CINDEX_LINKAGE void clang_enableStackTraces(void);
 CINDEX_LINKAGE void clang_executeOnThread(void (*fn)(void *), void *user_data,
                                           unsigned stack_size);
 

  */
 typedef void *CXCompletionString;
 
 /**
  * A single result of code completion.
  */
 typedef struct {
   /**
+   * The kind of this completion result.
+   * Useful to distinguish between declarations and keywords.
+   */
+  enum CXCompletionResultKind ResultKind;
+
+  /**
    * The kind of entity that this completion refers to.
    *
-   * The cursor kind will be a macro, keyword, or a declaration (one of the
-   * *Decl cursor kinds), describing the entity that the completion is
-   * referring to.
+   * The cursor kind will be a macro or a declaration (one of the *Decl cursor
+   * kinds), describing the entity that the completion is referring to.
    *
    * \todo In the future, we would like to provide a full cursor, to allow
    * the client to extract additional information from declaration.
    */
   enum CXCursorKind CursorKind;
 
   /**
    * The code-completion string that describes how to insert this

clang/include/clang/Sema/CodeCompleteConsumer.h

public:
   void addBriefComment(StringRef Comment);
 
   StringRef getParentName() const { return ParentName; }
 };
 
 /// Captures a result of code completion.
 class CodeCompletionResult {
 public:
-  /// Describes the kind of result generated.
-  enum ResultKind {
-    /// Refers to a declaration.
-    RK_Declaration = 0,
-
-    /// Refers to a keyword or symbol.
-    RK_Keyword,
-
-    /// Refers to a macro.
-    RK_Macro,
-
-    /// Refers to a precomputed pattern.
-    RK_Pattern
-  };
-
-  /// When Kind == RK_Declaration or RK_Pattern, the declaration we are
+  /// When Kind == CXCompletionResult_Declaration or CXCompletionResult_Pattern, the declaration we are
   /// referring to. In the latter case, the declaration might be NULL.
   const NamedDecl *Declaration = nullptr;
 
   union {
-    /// When Kind == RK_Keyword, the string representing the keyword
+    /// When Kind == CXCompletionResult_Keyword, the string representing the keyword
     /// or symbol's spelling.
     const char *Keyword;
 
-    /// When Kind == RK_Pattern, the code-completion string that
+    /// When Kind == CXCompletionResult_Pattern, the code-completion string that
     /// describes the completion text to insert.
     CodeCompletionString *Pattern;
 
-    /// When Kind == RK_Macro, the identifier that refers to a macro.
+    /// When Kind == CXCompletionResult_Macro, the identifier that refers to a macro.
     const IdentifierInfo *Macro;
   };
 
   /// The priority of this particular code-completion result.
   unsigned Priority;
 
   /// Specifies which parameter (of a function, Objective-C method,
   /// macro, etc.) we should start with when formatting the result.
   unsigned StartParameter = 0;
 
   /// The kind of result stored here.
-  ResultKind Kind;
+  CXCompletionResultKind Kind;
 
   /// The cursor kind that describes this result.
   CXCursorKind CursorKind;
 
   /// The availability of this result.
   CXAvailabilityKind Availability = CXAvailability_Available;
 
   /// Fix-its that *must* be applied before inserting the text for the
public:
   NestedNameSpecifier *Qualifier = nullptr;
 
   /// If this Decl was unshadowed by using declaration, this can store a
   /// pointer to the UsingShadowDecl which was used in the unshadowing process.
   /// This information can be used to uprank CodeCompletionResults / which have
   /// corresponding `using decl::qualified::name;` nearby.
   const UsingShadowDecl *ShadowDecl = nullptr;
 
-  /// If the result is RK_Macro, this can store the information about the macro
+  /// If the result is CXCompletionResult_Macro, this can store the information about the macro
   /// definition. This should be set in most cases but can be missing when
   /// the macro has been undefined.
   const MacroInfo *MacroDefInfo = nullptr;
 
   /// Build a result that refers to a declaration.
   CodeCompletionResult(const NamedDecl *Declaration, unsigned Priority,
                        NestedNameSpecifier *Qualifier = nullptr,
                        bool QualifierIsInformative = false,
                        bool Accessible = true,
                        std::vector<FixItHint> FixIts = std::vector<FixItHint>())
-      : Declaration(Declaration), Priority(Priority), Kind(RK_Declaration),
+      : Declaration(Declaration), Priority(Priority), Kind(CXCompletionResult_Declaration),
         FixIts(std::move(FixIts)), Hidden(false), InBaseClass(false),
         QualifierIsInformative(QualifierIsInformative),
         StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
         DeclaringEntity(false), Qualifier(Qualifier) {
     // FIXME: Add assert to check FixIts range requirements.
     computeCursorKindAndAvailability(Accessible);
   }
 
   /// Build a result that refers to a keyword or symbol.
   CodeCompletionResult(const char *Keyword, unsigned Priority = CCP_Keyword)
-      : Keyword(Keyword), Priority(Priority), Kind(RK_Keyword),
+      : Keyword(Keyword), Priority(Priority), Kind(CXCompletionResult_Keyword),
         CursorKind(CXCursor_NotImplemented), Hidden(false), InBaseClass(false),
         QualifierIsInformative(false), StartsNestedNameSpecifier(false),
         AllParametersAreInformative(false), DeclaringEntity(false) {}
 
   /// Build a result that refers to a macro.
   CodeCompletionResult(const IdentifierInfo *Macro,
                        const MacroInfo *MI = nullptr,
                        unsigned Priority = CCP_Macro)
-      : Macro(Macro), Priority(Priority), Kind(RK_Macro),
+      : Macro(Macro), Priority(Priority), Kind(CXCompletionResult_Macro),
         CursorKind(CXCursor_MacroDefinition), Hidden(false), InBaseClass(false),
         QualifierIsInformative(false), StartsNestedNameSpecifier(false),
         AllParametersAreInformative(false), DeclaringEntity(false),
         MacroDefInfo(MI) {}
 
   /// Build a result that refers to a pattern.
   CodeCompletionResult(
       CodeCompletionString *Pattern, unsigned Priority = CCP_CodePattern,
       CXCursorKind CursorKind = CXCursor_NotImplemented,
       CXAvailabilityKind Availability = CXAvailability_Available,
       const NamedDecl *D = nullptr)
-      : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
+      : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(CXCompletionResult_Pattern),
         CursorKind(CursorKind), Availability(Availability), Hidden(false),
         InBaseClass(false), QualifierIsInformative(false),
         StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
         DeclaringEntity(false) {}
 
   /// Build a result that refers to a pattern with an associated
   /// declaration.
   CodeCompletionResult(CodeCompletionString *Pattern, const NamedDecl *D,
                        unsigned Priority)
-      : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
+      : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(CXCompletionResult_Pattern),
         Hidden(false), InBaseClass(false), QualifierIsInformative(false),
         StartsNestedNameSpecifier(false), AllParametersAreInformative(false),
         DeclaringEntity(false) {
     computeCursorKindAndAvailability();
   }
 
   /// Retrieve the declaration stored in this result. This might be nullptr if
-  /// Kind is RK_Pattern.
+  /// Kind is CXCompletionResult_Pattern.
   const NamedDecl *getDeclaration() const {
-    assert(((Kind == RK_Declaration) || (Kind == RK_Pattern)) &&
+    assert(((Kind == CXCompletionResult_Declaration) || (Kind == CXCompletionResult_Pattern)) &&
            "Not a declaration or pattern result");
     return Declaration;
   }
 
   /// Retrieve the keyword stored in this result.
   const char *getKeyword() const {
-    assert(Kind == RK_Keyword && "Not a keyword result");
+    assert(Kind == CXCompletionResult_Keyword && "Not a keyword result");
     return Keyword;
   }
 
   /// Create a new code-completion string that describes how to insert
   /// this result into a program.
   ///
   /// \param S The semantic analysis that created the result.
   ///
   /// \param Allocator The allocator that will be used to allocate the
   /// string itself.
   CodeCompletionString *CreateCodeCompletionString(Sema &S,
                                          const CodeCompletionContext &CCContext,
                                            CodeCompletionAllocator &Allocator,
                                            CodeCompletionTUInfo &CCTUInfo,
                                            bool IncludeBriefComments);
   CodeCompletionString *CreateCodeCompletionString(ASTContext &Ctx,
                                                    Preprocessor &PP,
                                          const CodeCompletionContext &CCContext,
                                            CodeCompletionAllocator &Allocator,
                                            CodeCompletionTUInfo &CCTUInfo,
                                            bool IncludeBriefComments);
   /// Creates a new code-completion string for the macro result. Similar to the
   /// above overloads, except this only requires preprocessor information.
-  /// The result kind must be `RK_Macro`.
+  /// The result kind must be `CXCompletionResult_Macro`.
   CodeCompletionString *
   CreateCodeCompletionStringForMacro(Preprocessor &PP,
                                      CodeCompletionAllocator &Allocator,
                                      CodeCompletionTUInfo &CCTUInfo);
 
   CodeCompletionString *createCodeCompletionStringForDecl(
       Preprocessor &PP, ASTContext &Ctx, CodeCompletionBuilder &Result,
       bool IncludeBriefComments, const CodeCompletionContext &CCContext,
public:
   /// Retrieve the allocator that will be used to allocate
   /// code completion strings.
   virtual CodeCompletionAllocator &getAllocator() = 0;
 
   virtual CodeCompletionTUInfo &getCodeCompletionTUInfo() = 0;
 };
 
 /// Get the documentation comment used to produce
-/// CodeCompletionString::BriefComment for RK_Declaration.
+/// CodeCompletionString::BriefComment for CXCompletionResult_Declaration.
 const RawComment *getCompletionComment(const ASTContext &Ctx,
                                        const NamedDecl *Decl);
 
 /// Get the documentation comment used to produce
-/// CodeCompletionString::BriefComment for RK_Pattern.
+/// CodeCompletionString::BriefComment for CXCompletionResult_Pattern.
 const RawComment *getPatternCompletionComment(const ASTContext &Ctx,
                                               const NamedDecl *Decl);
 
 /// Get the documentation comment used to produce
 /// CodeCompletionString::BriefComment for OverloadCandidate.
 const RawComment *
 getParameterComment(const ASTContext &Ctx,
                     const CodeCompleteConsumer::OverloadCandidate &Result,

clang/lib/Frontend/ASTUnit.cpp

TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
                                        CCTUInfo, Results);
 
   // Translate global code completions into cached completions.
   llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
   CodeCompletionContext CCContext(CodeCompletionContext::CCC_TopLevel);
 
   for (auto &R : Results) {
     switch (R.Kind) {
-    case Result::RK_Declaration: {
+    case CXCompletionResult_Declaration: {
       bool IsNestedNameSpecifier = false;
       CachedCodeCompletionResult CachedResult;
       CachedResult.Completion = R.CreateCodeCompletionString(
           *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
           IncludeBriefCommentsInCodeCompletion);
       CachedResult.ShowInContexts = getDeclShowContexts(
           R.Declaration, Ctx->getLangOpts(), IsNestedNameSpecifier);
       CachedResult.Priority = R.Priority;
case CXCompletionResult_Declaration: {
           CachedResult.TypeClass = STC_Void;
           CachedResult.Type = 0;
           CachedCompletionResults.push_back(CachedResult);
         }
       }
       break;
     }
 
-    case Result::RK_Keyword:
-    case Result::RK_Pattern:
+    case CXCompletionResult_Keyword:
+    case CXCompletionResult_Pattern:
       // Ignore keywords and patterns; we don't care, since they are so
       // easily regenerated.
       break;
 
-    case Result::RK_Macro: {
+    case CXCompletionResult_Macro: {
       CachedCodeCompletionResult CachedResult;
       CachedResult.Completion = R.CreateCodeCompletionString(
           *TheSema, CCContext, *CachedCompletionAllocator, CCTUInfo,
           IncludeBriefCommentsInCodeCompletion);
       CachedResult.ShowInContexts
         = (1LL << CodeCompletionContext::CCC_TopLevel)
         | (1LL << CodeCompletionContext::CCC_ObjCInterface)
         | (1LL << CodeCompletionContext::CCC_ObjCImplementation)
static void CalculateHiddenNames(const CodeCompletionContext &Context,
   case CodeCompletionContext::CCC_IncludedFile:
   case CodeCompletionContext::CCC_Attribute:
   case CodeCompletionContext::CCC_NewName:
     // We're looking for nothing, or we're looking for names that cannot
     // be hidden.
     return;
   }
 
-  using Result = CodeCompletionResult;
   for (unsigned I = 0; I != NumResults; ++I) {
-    if (Results[I].Kind != Result::RK_Declaration)
+    if (Results[I].Kind != CXCompletionResult_Declaration)
       continue;
 
     unsigned IDNS
       = Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
 
     bool Hiding = false;
     if (OnlyTagNames)
       Hiding = (IDNS & Decl::IDNS_Tag);

clang/lib/Sema/CodeCompleteConsumer.cpp

 // Code completion consumer implementation
 //===----------------------------------------------------------------------===//
 
 CodeCompleteConsumer::~CodeCompleteConsumer() = default;
 
 bool PrintingCodeCompleteConsumer::isResultFilteredOut(
     StringRef Filter, CodeCompletionResult Result) {
   switch (Result.Kind) {
-  case CodeCompletionResult::RK_Declaration:
+  case CXCompletionResult_Declaration:
     return !(Result.Declaration->getIdentifier() &&
              Result.Declaration->getIdentifier()->getName().startswith(Filter));
-  case CodeCompletionResult::RK_Keyword:
+  case CXCompletionResult_Keyword:
     return !StringRef(Result.Keyword).startswith(Filter);
-  case CodeCompletionResult::RK_Macro:
+  case CXCompletionResult_Macro:
     return !Result.Macro->getName().startswith(Filter);
-  case CodeCompletionResult::RK_Pattern:
+  case CXCompletionResult_Pattern:
     return !(Result.Pattern->getTypedText() &&
              StringRef(Result.Pattern->getTypedText()).startswith(Filter));
   }
   llvm_unreachable("Unknown code completion result Kind.");
 }
 
 void PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(
     Sema &SemaRef, CodeCompletionContext Context, CodeCompletionResult *Results,
     unsigned NumResults) {
   std::stable_sort(Results, Results + NumResults);
 
   if (!Context.getPreferredType().isNull())
     OS << "PREFERRED-TYPE: " << Context.getPreferredType() << '\n';
 
   StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
   // Print the completions.
   for (unsigned I = 0; I != NumResults; ++I) {
     if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
       continue;
     OS << "COMPLETION: ";
     switch (Results[I].Kind) {
-    case CodeCompletionResult::RK_Declaration:
+    case CXCompletionResult_Declaration:
       OS << *Results[I].Declaration;
       {
         std::vector<std::string> Tags;
         if (Results[I].Hidden)
           Tags.push_back("Hidden");
         if (Results[I].InBaseClass)
           Tags.push_back("InBase");
         if (Results[I].Availability ==
             CXAvailabilityKind::CXAvailability_NotAccessible)
           Tags.push_back("Inaccessible");
         if (!Tags.empty())
           OS << " (" << llvm::join(Tags, ",") << ")";
       }
       if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
               SemaRef, Context, getAllocator(), CCTUInfo,
               includeBriefComments())) {
         OS << " : " << CCS->getAsString();
         if (const char *BriefComment = CCS->getBriefComment())
           OS << " : " << BriefComment;
       }
       break;
 
-    case CodeCompletionResult::RK_Keyword:
+    case CXCompletionResult_Keyword:
       OS << Results[I].Keyword;
       break;
 
-    case CodeCompletionResult::RK_Macro:
+    case CXCompletionResult_Macro:
       OS << Results[I].Macro->getName();
       if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
               SemaRef, Context, getAllocator(), CCTUInfo,
               includeBriefComments())) {
         OS << " : " << CCS->getAsString();
       }
       break;
 
-    case CodeCompletionResult::RK_Pattern:
+    case CXCompletionResult_Pattern:
       OS << "Pattern : " << Results[I].Pattern->getAsString();
       break;
     }
     for (const FixItHint &FixIt : Results[I].FixIts) {
       const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
       const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
 
       SourceManager &SM = SemaRef.SourceMgr;
static AvailabilityResult getDeclAvailability(const Decl *D) {
   AvailabilityResult AR = D->getAvailability();
   if (isa<EnumConstantDecl>(D))
     AR = std::max(AR, cast<Decl>(D->getDeclContext())->getAvailability());
   return AR;
 }
 
 void CodeCompletionResult::computeCursorKindAndAvailability(bool Accessible) {
   switch (Kind) {
-  case RK_Pattern:
+  case CXCompletionResult_Pattern:
     if (!Declaration) {
       // Do nothing: Patterns can come with cursor kinds!
       break;
     }
     LLVM_FALLTHROUGH;
 
-  case RK_Declaration: {
+  case CXCompletionResult_Declaration: {
     // Set the availability based on attributes.
     switch (getDeclAvailability(Declaration)) {
     case AR_Available:
     case AR_NotYetIntroduced:
       Availability = CXAvailability_Available;
       break;
 
     case AR_Deprecated:
if (CursorKind == CXCursor_UnexposedDecl) {
       else if (isa<ObjCProtocolDecl>(Declaration))
         CursorKind = CXCursor_ObjCProtocolDecl;
       else
         CursorKind = CXCursor_NotImplemented;
     }
     break;
   }
 
-  case RK_Macro:
-  case RK_Keyword:
+  case CXCompletionResult_Macro:
+  case CXCompletionResult_Keyword:
     llvm_unreachable("Macro and keyword kinds are handled by the constructors");
   }
 
   if (!Accessible)
     Availability = CXAvailability_NotAccessible;
 }
 
 /// Retrieve the name that should be used to order a result.
 ///
 /// If the name needs to be constructed as a string, that string will be
 /// saved into Saved and the returned StringRef will refer to it.
 StringRef CodeCompletionResult::getOrderedName(std::string &Saved) const {
   switch (Kind) {
-  case RK_Keyword:
+  case CXCompletionResult_Keyword:
     return Keyword;
-  case RK_Pattern:
+  case CXCompletionResult_Pattern:
     return Pattern->getTypedText();
-  case RK_Macro:
+  case CXCompletionResult_Macro:
     return Macro->getName();
-  case RK_Declaration:
+  case CXCompletionResult_Declaration:
     // Handle declarations below.
     break;
   }
 
   DeclarationName Name = Declaration->getDeclName();
 
   // If the name is a simple identifier (by far the common case), or a
   // zero-argument selector, just return a reference to that identifier.

clang/lib/Sema/SemaCodeComplete.cpp

static bool isConstructor(const Decl *ND) {
   if (const auto *Tmpl = dyn_cast<FunctionTemplateDecl>(ND))
     ND = Tmpl->getTemplatedDecl();
   return isa<CXXConstructorDecl>(ND);
 }
 
 void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
   assert(!ShadowMaps.empty() && "Must enter into a results scope");
 
-  if (R.Kind != Result::RK_Declaration) {
+  if (R.Kind != CXCompletionResult_Declaration) {
     // For non-declaration results, just add the result.
     Results.push_back(R);
     return;
   }
 
   // Look through using declarations.
   if (const UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
     CodeCompletionResult Result(Using->getTargetDecl(),
static OverloadCompare compareOverloads(const CXXMethodDecl &Candidate,
   if (CandidateSuperset == IncumbentSuperset)
     return OverloadCompare::BothViable;
   return IncumbentSuperset ? OverloadCompare::Dominates
                            : OverloadCompare::Dominated;
 }
 
 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
                               NamedDecl *Hiding, bool InBaseClass = false) {
-  if (R.Kind != Result::RK_Declaration) {
+  if (R.Kind != CXCompletionResult_Declaration) {
     // For non-declaration results, just add the result.
     Results.push_back(R);
     return;
   }
 
   // Look through using declarations.
   if (const auto *Using = dyn_cast<UsingShadowDecl>(R.Declaration)) {
     CodeCompletionResult Result(Using->getTargetDecl(),
void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
   // Insert this result into the set of results.
   Results.push_back(R);
 
   if (!AsNestedNameSpecifier)
     MaybeAddConstructorResults(R);
 }
 
 void ResultBuilder::AddResult(Result R) {
-  assert(R.Kind != Result::RK_Declaration &&
+  assert(R.Kind != CXCompletionResult_Declaration &&
          "Declaration results need more context");
   Results.push_back(R);
 }
 
 /// Enter into a new scope.
 void ResultBuilder::EnterNewScope() { ShadowMaps.emplace_back(); }
 
 /// Exit from the current scope.
if (SemaRef.getLangOpts().CPlusPlus) {
 
       if (Results.includeCodePatterns()) {
         // Explicit template instantiation
         Builder.AddTypedTextChunk("template");
         Builder.AddChunk(CodeCompletionString::CK_HorizontalSpace);
         Builder.AddPlaceholderChunk("declaration");
         Results.AddResult(Result(Builder.TakeString()));
       } else {
-        Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
+        Results.AddResult(Result("template", CXCompletionResult_Keyword));
       }
     }
 
     if (SemaRef.getLangOpts().ObjC)
       AddObjCTopLevelResults(Results, true);
 
     AddTypedefResult(Results);
     LLVM_FALLTHROUGH;
case Sema::PCC_MemberTemplate:
     if (SemaRef.getLangOpts().CPlusPlus && Results.includeCodePatterns()) {
       // template < parameters >
       Builder.AddTypedTextChunk("template");
       Builder.AddChunk(CodeCompletionString::CK_LeftAngle);
       Builder.AddPlaceholderChunk("parameters");
       Builder.AddChunk(CodeCompletionString::CK_RightAngle);
       Results.AddResult(Result(Builder.TakeString()));
     } else {
-      Results.AddResult(Result("template", CodeCompletionResult::RK_Keyword));
+      Results.AddResult(Result("template", CXCompletionResult_Keyword));
     }
 
     AddStorageSpecifiers(CCC, SemaRef.getLangOpts(), Results);
     AddFunctionSpecifiers(CCC, SemaRef.getLangOpts(), Results);
     break;
 
   case Sema::PCC_ObjCInterface:
     AddObjCInterfaceResults(SemaRef.getLangOpts(), Results, true);
CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
     bool IncludeBriefComments) {
   return CreateCodeCompletionString(S.Context, S.PP, CCContext, Allocator,
                                     CCTUInfo, IncludeBriefComments);
 }
 
 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionStringForMacro(
     Preprocessor &PP, CodeCompletionAllocator &Allocator,
     CodeCompletionTUInfo &CCTUInfo) {
-  assert(Kind == RK_Macro);
+  assert(Kind == CXCompletionResult_Macro);
   CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
   const MacroInfo *MI = PP.getMacroInfo(Macro);
   Result.AddTypedTextChunk(Result.getAllocator().CopyString(Macro->getName()));
 
   if (!MI || !MI->isFunctionLike())
     return Result.TakeString();
 
   // Format a function-like macro with placeholders for the arguments.

 ///
 /// \returns Either a new, heap-allocated code completion string describing
 /// how to use this result, or NULL to indicate that the string or name of the
 /// result is all that is needed.
 CodeCompletionString *CodeCompletionResult::CreateCodeCompletionString(
     ASTContext &Ctx, Preprocessor &PP, const CodeCompletionContext &CCContext,
     CodeCompletionAllocator &Allocator, CodeCompletionTUInfo &CCTUInfo,
     bool IncludeBriefComments) {
-  if (Kind == RK_Macro)
+  if (Kind == CXCompletionResult_Macro)
     return CreateCodeCompletionStringForMacro(PP, Allocator, CCTUInfo);
 
   CodeCompletionBuilder Result(Allocator, CCTUInfo, Priority, Availability);
 
   PrintingPolicy Policy = getCompletionPrintingPolicy(Ctx, PP);
-  if (Kind == RK_Pattern) {
+  if (Kind == CXCompletionResult_Pattern) {
     Pattern->Priority = Priority;
     Pattern->Availability = Availability;
 
     if (Declaration) {
       Result.addParentContext(Declaration->getDeclContext());
       Pattern->ParentName = Result.getParentName();
       if (const RawComment *RC =
               getPatternCompletionComment(Ctx, Declaration)) {
         Result.addBriefComment(RC->getBriefText(Ctx));
         Pattern->BriefComment = Result.getBriefComment();
       }
     }
 
     return Pattern;
   }
 
-  if (Kind == RK_Keyword) {
+  if (Kind == CXCompletionResult_Keyword) {
     Result.AddTypedTextChunk(Keyword);
     return Result.TakeString();
   }
-  assert(Kind == RK_Declaration && "Missed a result kind?");
+  assert(Kind == CXCompletionResult_Declaration && "Missed a result kind?");
   return createCodeCompletionStringForDecl(
       PP, Ctx, Result, IncludeBriefComments, CCContext, Policy);
 }
 
 static void printOverrideString(const CodeCompletionString &CCS,
                                 std::string &BeforeName,
                                 std::string &NameAndSignature) {
   bool SeenTypedChunk = false;
static QualType getPreferredArgumentTypeForMessageSend(ResultBuilder &Results,
   typedef CodeCompletionResult Result;
   ASTContext &Context = Results.getSema().Context;
 
   QualType PreferredType;
   unsigned BestPriority = CCP_Unlikely * 2;
   Result *ResultsData = Results.data();
   for (unsigned I = 0, N = Results.size(); I != N; ++I) {
     Result &R = ResultsData[I];
-    if (R.Kind == Result::RK_Declaration &&
+    if (R.Kind == CXCompletionResult_Declaration &&
         isa<ObjCMethodDecl>(R.Declaration)) {
       if (R.Priority <= BestPriority) {
         const ObjCMethodDecl *Method = cast<ObjCMethodDecl>(R.Declaration);
         if (NumSelIdents <= Method->param_size()) {
           QualType MyPreferredType =
               Method->parameters()[NumSelIdents - 1]->getType();
           if (R.Priority < BestPriority || PreferredType.isNull()) {
             BestPriority = R.Priority;
for (ObjCIvarDecl *Ivar = Class->all_declared_ivar_begin(); Ivar;
            NameWithPrefix == Ivar->getName() ||
            NameWithSuffix == Ivar->getName())) {
         SawSimilarlyNamedIvar = true;
 
         // Reduce the priority of this result by one, to give it a slight
         // advantage over other results whose names don't match so closely.
         if (Results.size() &&
             Results.data()[Results.size() - 1].Kind ==
-                CodeCompletionResult::RK_Declaration &&
+                CXCompletionResult_Declaration &&
             Results.data()[Results.size() - 1].Declaration == Ivar)
           Results.data()[Results.size() - 1].Priority--;
       }
     }
   }
 
   if (!SawSimilarlyNamedIvar) {
     // Create ivar result _propName, that the user can use to synthesize

clang/test/Index/arc-complete.m

 typedef const void *CFTypeRef;
 
 void test(id x) {
   (__bridge CFTypeRef)x;
 }
 
 
 
 // RUN: c-index-test -code-completion-at=%s:4:4 %s -fobjc-arc -fobjc-nonfragile-abi | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: macro definition:{TypedText __autoreleasing} (70)
-// CHECK-CC1: NotImplemented:{TypedText __bridge}{HorizontalSpace  }{Placeholder type}{RightParen )}{Placeholder expression} (40)
-// CHECK-CC1: NotImplemented:{TypedText __bridge_retained}{HorizontalSpace  }{Placeholder CF type}{RightParen )}{Placeholder expression} (40)
-// CHECK-CC1: NotImplemented:{TypedText __bridge_transfer}{HorizontalSpace  }{Placeholder Objective-C type}{RightParen )}{Placeholder expression} (40)
+// CHECK-CC1: Pattern:{TypedText __bridge}{HorizontalSpace  }{Placeholder type}{RightParen )}{Placeholder expression} (40)
+// CHECK-CC1: Pattern:{TypedText __bridge_retained}{HorizontalSpace  }{Placeholder CF type}{RightParen )}{Placeholder expression} (40)
+// CHECK-CC1: Pattern:{TypedText __bridge_transfer}{HorizontalSpace  }{Placeholder Objective-C type}{RightParen )}{Placeholder expression} (40)
 // CHECK-CC1: macro definition:{TypedText __strong} (70)
 // CHECK-CC1: macro definition:{TypedText __unsafe_unretained} (70)
 // CHECK-CC1: macro definition:{TypedText __weak} (70)

clang/test/Index/code-completion.cpp

 // CHECK-OVERLOAD-NEXT: Enum tag
 // CHECK-OVERLOAD-NEXT: Union tag
 // CHECK-OVERLOAD-NEXT: Struct tag
 // CHECK-OVERLOAD-NEXT: Class name
 // CHECK-OVERLOAD-NEXT: Nested name specifier
 // CHECK-OVERLOAD-NEXT: Objective-C interface
 
 // RUN: c-index-test -code-completion-at=%s:37:10 %s | FileCheck -check-prefix=CHECK-EXPR %s
-// CHECK-EXPR: NotImplemented:{TypedText int} (50)
-// CHECK-EXPR: NotImplemented:{TypedText long} (50)
+// CHECK-EXPR: Keyword:{TypedText int} (50)
+// CHECK-EXPR: Keyword:{TypedText long} (50)
 // CHECK-EXPR: FieldDecl:{ResultType double}{TypedText member} (17)
 // CHECK-EXPR: FieldDecl:{ResultType int}{Text X::}{TypedText member} (9)
 // CHECK-EXPR: FieldDecl:{ResultType float}{Text Y::}{TypedText member} (18)
 // CHECK-EXPR: CXXMethod:{ResultType void}{TypedText memfunc}{LeftParen (}{Optional {Placeholder int i = 17}}{RightParen )} (37)
 // CHECK-EXPR: Namespace:{TypedText N}{Text ::} (75)
 // CHECK-EXPR: Completion contexts:
 // CHECK-EXPR-NEXT: Any type
 // CHECK-EXPR-NEXT: Any value
 // CHECK-EXPR-NEXT: Enum tag
 // CHECK-EXPR-NEXT: Union tag
 // CHECK-EXPR-NEXT: Struct tag
 // CHECK-EXPR-NEXT: Class name
 // CHECK-EXPR-NEXT: Nested name specifier
 // CHECK-EXPR-NEXT: Objective-C interface
 
 // CHECK-TEMPLATE-ALIAS: AliasTemplateDecl:{TypedText Bar}{LeftAngle <}{Placeholder typename T}{RightAngle >} (50)

clang/test/Index/complete-at-directives.m

 // CHECK-CC2: {TypedText required}
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:6:2 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: {TypedText dynamic}{HorizontalSpace  }{Placeholder property}
 // CHECK-CC3: {TypedText end}
 // CHECK-CC3: {TypedText synthesize}{HorizontalSpace  }{Placeholder property}
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:2:1 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{TypedText @class}{HorizontalSpace  }{Placeholder name}
-// CHECK-CC4: NotImplemented:{TypedText @compatibility_alias}{HorizontalSpace  }{Placeholder alias}{HorizontalSpace  }{Placeholder class}
-// CHECK-CC4: NotImplemented:{TypedText @implementation}{HorizontalSpace  }{Placeholder class}
-// CHECK-CC4: NotImplemented:{TypedText @interface}{HorizontalSpace  }{Placeholder class}
-// CHECK-CC4: NotImplemented:{TypedText @protocol}{HorizontalSpace  }{Placeholder protocol}
-// CHECK-CC4: NotImplemented:{TypedText _Bool}
+// CHECK-CC4: Pattern:{TypedText @class}{HorizontalSpace  }{Placeholder name}
+// CHECK-CC4: Pattern:{TypedText @compatibility_alias}{HorizontalSpace  }{Placeholder alias}{HorizontalSpace  }{Placeholder class}
+// CHECK-CC4: Pattern:{TypedText @implementation}{HorizontalSpace  }{Placeholder class}
+// CHECK-CC4: Pattern:{TypedText @interface}{HorizontalSpace  }{Placeholder class}
+// CHECK-CC4: Pattern:{TypedText @protocol}{HorizontalSpace  }{Placeholder protocol}
+// CHECK-CC4: Keyword:{TypedText _Bool}
 // CHECK-CC4: TypedefDecl:{TypedText Class}
 // CHECK-CC4: TypedefDecl:{TypedText id}
 // CHECK-CC4: TypedefDecl:{TypedText SEL}
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:3:1 %s | FileCheck -check-prefix=CHECK-CC5 %s
 // CHECK-CC5: {TypedText @end}
 // CHECK-CC5: {TypedText @optional}
 // CHECK-CC5: {TypedText @property}
 // CHECK-CC5: {TypedText @required}
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:2:23 %s | FileCheck -check-prefix=CHECK-CC6 %s
-// CHECK-CC6: NotImplemented:{TypedText package}
-// CHECK-CC6: NotImplemented:{TypedText private}
-// CHECK-CC6: NotImplemented:{TypedText protected}
-// CHECK-CC6: NotImplemented:{TypedText public}
+// CHECK-CC6: Keyword:{TypedText package}
+// CHECK-CC6: Keyword:{TypedText private}
+// CHECK-CC6: Keyword:{TypedText protected}
+// CHECK-CC6: Keyword:{TypedText public}
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:2:22 %s | FileCheck -check-prefix=CHECK-CC7 %s
-// CHECK-CC7: NotImplemented:{TypedText @package}
-// CHECK-CC7: NotImplemented:{TypedText @private}
-// CHECK-CC7: NotImplemented:{TypedText @protected}
-// CHECK-CC7: NotImplemented:{TypedText @public}
-// CHECK-CC7: NotImplemented:{TypedText _Bool}
+// CHECK-CC7: Keyword:{TypedText @package}
+// CHECK-CC7: Keyword:{TypedText @private}
+// CHECK-CC7: Keyword:{TypedText @protected}
+// CHECK-CC7: Keyword:{TypedText @public}
+// CHECK-CC7: Keyword:{TypedText _Bool}

clang/test/Index/complete-at-exprstmt.m

 // CHECK-CC1: {TypedText synchronized}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}
 // CHECK-CC1: {TypedText throw}{HorizontalSpace  }{Placeholder expression}
 // CHECK-CC1: {TypedText try}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @catch}{LeftParen (}{Placeholder parameter}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @finally}{LeftBrace {}{Placeholder statements}{RightBrace }}
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:9:19 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: {TypedText encode}{LeftParen (}{Placeholder type-name}{RightParen )}
 // CHECK-CC2: {TypedText protocol}{LeftParen (}{Placeholder protocol-name}{RightParen )}
 // CHECK-CC2: {TypedText selector}{LeftParen (}{Placeholder selector}{RightParen )}
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:9:3 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: NotImplemented:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
-// CHECK-CC3: NotImplemented:{ResultType Protocol *}{TypedText @protocol}{LeftParen (}{Placeholder protocol-name}{RightParen )}
-// CHECK-CC3: NotImplemented:{ResultType SEL}{TypedText @selector}{LeftParen (}{Placeholder selector}{RightParen )}
-// CHECK-CC3: NotImplemented:{TypedText @synchronized}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}
-// CHECK-CC3: NotImplemented:{TypedText @throw}{HorizontalSpace  }{Placeholder expression}
-// CHECK-CC3: NotImplemented:{TypedText @try}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @catch}{LeftParen (}{Placeholder parameter}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @finally}{LeftBrace {}{Placeholder statements}{RightBrace }}
-// CHECK-CC3: NotImplemented:{ResultType SEL}{TypedText _cmd}
+// CHECK-CC3: Pattern:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
+// CHECK-CC3: Pattern:{ResultType Protocol *}{TypedText @protocol}{LeftParen (}{Placeholder protocol-name}{RightParen )}
+// CHECK-CC3: Pattern:{ResultType SEL}{TypedText @selector}{LeftParen (}{Placeholder selector}{RightParen )}
+// CHECK-CC3: Pattern:{TypedText @synchronized}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}
+// CHECK-CC3: Pattern:{TypedText @throw}{HorizontalSpace  }{Placeholder expression}
+// CHECK-CC3: Pattern:{TypedText @try}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @catch}{LeftParen (}{Placeholder parameter}{RightParen )}{LeftBrace {}{Placeholder statements}{RightBrace }}{Text @finally}{LeftBrace {}{Placeholder statements}{RightBrace }}
+// CHECK-CC3: Declaration:{ResultType SEL}{TypedText _cmd}
 // CHECK-CC3: ParmDecl:{ResultType int}{TypedText arg}
 // CHECK-CC3: TypedefDecl:{TypedText Class}
 // CHECK-CC3: TypedefDecl:{TypedText id}
 // CHECK-CC3: ObjCIvarDecl:{ResultType int}{TypedText ivar}
 // CHECK-CC3: ObjCInterfaceDecl:{TypedText MyClass}
 // CHECK-CC3: TypedefDecl:{TypedText SEL}
-// CHECK-CC3: NotImplemented:{ResultType MyClass *}{TypedText self}
+// CHECK-CC3: Declaration:{ResultType MyClass *}{TypedText self}
 // RUN: c-index-test -code-completion-at=%s:19:13 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{TypedText add:to:} (40)
-// CHECK-CC4: NotImplemented:{TypedText add:to:plus:} (40)
-// CHECK-CC4: NotImplemented:{TypedText myMethod:} (40)
+// CHECK-CC4: Pattern:{TypedText add:to:} (40)
+// CHECK-CC4: Pattern:{TypedText add:to:plus:} (40)
+// CHECK-CC4: Pattern:{TypedText myMethod:} (40)
 // RUN: c-index-test -code-completion-at=%s:19:17 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: NotImplemented:{Informative add:}{TypedText to:} (40)
-// CHECK-CC5: NotImplemented:{Informative add:}{TypedText to:plus:} (40)
+// CHECK-CC5: Pattern:{Informative add:}{TypedText to:} (40)
+// CHECK-CC5: Pattern:{Informative add:}{TypedText to:plus:} (40)
 

clang/test/Index/complete-declarators.cpp

 
 struct Z {
   int member;
   friend int N::X::f(N::X);
 };
 
 // RUN: c-index-test -code-completion-at=%s:8:5 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:8:5 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: NotImplemented:{TypedText const} (40)
+// CHECK-CC1: Keyword:{TypedText const} (40)
 // CHECK-CC1: Namespace:{TypedText N}{Text ::} (75)
-// CHECK-CC1: NotImplemented:{TypedText operator} (40)
-// CHECK-CC1: NotImplemented:{TypedText volatile} (40)
+// CHECK-CC1: Keyword:{TypedText operator} (40)
+// CHECK-CC1: Keyword:{TypedText volatile} (40)
 // RUN: c-index-test -code-completion-at=%s:8:11 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:8:11 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: NotImplemented:{TypedText const} (40)
+// CHECK-CC2: Keyword:{TypedText const} (40)
 // CHECK-CC2-NOT: Namespace:{TypedText N}{Text ::} (75)
-// CHECK-CC2-NOT: NotImplemented:{TypedText operator} (40)
-// CHECK-CC2: NotImplemented:{TypedText volatile} (40)
+// CHECK-CC2-NOT: Keyword:{TypedText operator} (40)
+// CHECK-CC2: Keyword:{TypedText volatile} (40)
 // RUN: c-index-test -code-completion-at=%s:13:7 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:13:7 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: NotImplemented:{TypedText const} (40)
+// CHECK-CC3: Keyword:{TypedText const} (40)
 // CHECK-CC3-NOT: Namespace:{TypedText N}{Text ::} (75)
-// CHECK-CC3: NotImplemented:{TypedText operator} (40)
-// CHECK-CC3: NotImplemented:{TypedText volatile} (40)
+// CHECK-CC3: Keyword:{TypedText operator} (40)
+// CHECK-CC3: Keyword:{TypedText volatile} (40)
 // RUN: c-index-test -code-completion-at=%s:14:14 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:14:14 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{TypedText const} (40)
+// CHECK-CC4: Keyword:{TypedText const} (40)
 // CHECK-CC4: Namespace:{TypedText N}{Text ::} (75)
-// CHECK-CC4: NotImplemented:{TypedText operator} (40)
-// CHECK-CC4: NotImplemented:{TypedText volatile} (40)
+// CHECK-CC4: Keyword:{TypedText operator} (40)
+// CHECK-CC4: Keyword:{TypedText volatile} (40)
 // CHECK-CC4: StructDecl:{TypedText Y}{Text ::} (75)
 // CHECK-CC4: StructDecl:{TypedText Z}{Text ::} (75)
 

clang/test/Index/complete-declarators.m

- (int)method:(id)param1 {
   }
 
   static P *p = 0;
 }
 - (boid)method2 {}
 @end
 
 // RUN: c-index-test -code-completion-at=%s:7:4 %s | FileCheck -check-prefix=CHECK-CC0 %s
-// CHECK-CC0: NotImplemented:{TypedText IBAction}{RightParen )}{Placeholder selector}{Colon :}{LeftParen (}{Text id}{RightParen )}{Text sender} (40)
+// CHECK-CC0: Pattern:{TypedText IBAction}{RightParen )}{Placeholder selector}{Colon :}{LeftParen (}{Text id}{RightParen )}{Text sender} (40)
 // CHECK-CC0: macro definition:{TypedText IBAction} (70)
 // CHECK-CC0: macro definition:{TypedText IBOutlet} (70)
 // CHECK-CC0: macro definition:{TypedText IBOutletCollection}{LeftParen (}{Placeholder ClassName}{RightParen )} (70)
 // CHECK-CC0: TypedefDecl:{TypedText id} (50)
-// CHECK-CC0: NotImplemented:{TypedText in} (40)
-// CHECK-CC0: NotImplemented:{TypedText inout} (40)
-// CHECK-CC0: NotImplemented:{TypedText instancetype} (40)
-// CHECK-CC0: NotImplemented:{TypedText int} (50)
-// CHECK-CC0: NotImplemented:{TypedText long} (50)
+// CHECK-CC0: Keyword:{TypedText in} (40)
+// CHECK-CC0: Keyword:{TypedText inout} (40)
+// CHECK-CC0: Keyword:{TypedText instancetype} (40)
+// CHECK-CC0: Keyword:{TypedText int} (50)
+// CHECK-CC0: Keyword:{TypedText long} (50)
 // RUN: c-index-test -code-completion-at=%s:7:19 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1-NOT: NotImplemented:{TypedText extern} (40)
-// CHECK-CC1: NotImplemented:{TypedText param1} (40)
+// CHECK-CC1-NOT: Keyword:{TypedText extern} (40)
+// CHECK-CC1: Pattern:{TypedText param1} (40)
 // RUN: c-index-test -code-completion-at=%s:9:15 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: c-index-test -code-completion-at=%s:15:10 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: c-index-test -code-completion-at=%s:16:9 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: NotImplemented:{TypedText const} (40)
+// CHECK-CC2: Keyword:{TypedText const} (40)
 // CHECK-CC2-NOT: int
-// CHECK-CC2: NotImplemented:{TypedText restrict} (40)
-// CHECK-CC2: NotImplemented:{TypedText volatile} (40)
+// CHECK-CC2: Keyword:{TypedText restrict} (40)
+// CHECK-CC2: Keyword:{TypedText volatile} (40)
 // RUN: c-index-test -code-completion-at=%s:15:15 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: ParmDecl:{ResultType id}{TypedText param1} (34)
 // CHECK-CC3-NOT: VarDecl:{ResultType int}{TypedText q2}
 // CHECK-CC3-NOT: VarDecl:{ResultType id}{TypedText q}
-// CHECK-CC3: NotImplemented:{ResultType A *}{TypedText self} (34)
-// CHECK-CC3: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC3: Declaration:{ResultType A *}{TypedText self} (34)
+// CHECK-CC3: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: c-index-test -code-completion-at=%s:15:15 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: ParmDecl:{ResultType id}{TypedText param1} (34)
 // CHECK-CC4-NOT: VarDecl:{ResultType int}{TypedText q2}
-// CHECK-CC4: NotImplemented:{ResultType A *}{TypedText self} (34)
-// CHECK-CC4: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC4: Declaration:{ResultType A *}{TypedText self} (34)
+// CHECK-CC4: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: c-index-test -code-completion-at=%s:23:10 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: NotImplemented:{TypedText _Bool} (50)
-// CHECK-CC5: NotImplemented:{TypedText _Complex} (50)
-// CHECK-CC5: NotImplemented:{TypedText _Imaginary} (50)
+// CHECK-CC5: Keyword:{TypedText _Bool} (50)
+// CHECK-CC5: Keyword:{TypedText _Complex} (50)
+// CHECK-CC5: Keyword:{TypedText _Imaginary} (50)
 // CHECK-CC5: ObjCInterfaceDecl:{TypedText A} (50)
-// CHECK-CC5: NotImplemented:{TypedText char} (50)
+// CHECK-CC5: Keyword:{TypedText char} (50)
 // CHECK-CC5: TypedefDecl:{TypedText Class} (50)
-// CHECK-CC5: NotImplemented:{TypedText const} (50)
-// CHECK-CC5: NotImplemented:{TypedText double} (50)
-// CHECK-CC5: NotImplemented:{TypedText enum} (50)
-// CHECK-CC5: NotImplemented:{TypedText float} (50)
+// CHECK-CC5: Keyword:{TypedText const} (50)
+// CHECK-CC5: Keyword:{TypedText double} (50)
+// CHECK-CC5: Keyword:{TypedText enum} (50)
+// CHECK-CC5: Keyword:{TypedText float} (50)
 // CHECK-CC5: TypedefDecl:{TypedText id} (50)
-// CHECK-CC5: NotImplemented:{TypedText int} (50)
-// CHECK-CC5: NotImplemented:{TypedText long} (50)
-// CHECK-CC5: NotImplemented:{TypedText restrict} (50)
+// CHECK-CC5: Keyword:{TypedText int} (50)
+// CHECK-CC5: Keyword:{TypedText long} (50)
+// CHECK-CC5: Keyword:{TypedText restrict} (50)
 // CHECK-CC5: TypedefDecl:{TypedText SEL} (50)
-// CHECK-CC5: NotImplemented:{TypedText short} (50)
-// CHECK-CC5: NotImplemented:{TypedText signed} (50)
-// CHECK-CC5: NotImplemented:{TypedText struct} (50)
-// CHECK-CC5: NotImplemented:{TypedText typeof}{HorizontalSpace  }{Placeholder expression} (40)
-// CHECK-CC5: NotImplemented:{TypedText typeof}{LeftParen (}{Placeholder type}{RightParen )} (40)
-// CHECK-CC5: NotImplemented:{TypedText union} (50)
-// CHECK-CC5: NotImplemented:{TypedText unsigned} (50)
-// CHECK-CC5: NotImplemented:{TypedText void} (50)
-// CHECK-CC5: NotImplemented:{TypedText volatile} (50)
+// CHECK-CC5: Keyword:{TypedText short} (50)
+// CHECK-CC5: Keyword:{TypedText signed} (50)
+// CHECK-CC5: Keyword:{TypedText struct} (50)
+// CHECK-CC5: Pattern:{TypedText typeof}{HorizontalSpace  }{Placeholder expression} (40)
+// CHECK-CC5: Pattern:{TypedText typeof}{LeftParen (}{Placeholder type}{RightParen )} (40)
+// CHECK-CC5: Keyword:{TypedText union} (50)
+// CHECK-CC5: Keyword:{TypedText unsigned} (50)
+// CHECK-CC5: Keyword:{TypedText void} (50)
+// CHECK-CC5: Keyword:{TypedText volatile} (50)
 
 // Check that there are no duplicate entries if we code-complete after an @implementation
 // RUN: c-index-test -code-completion-at=%s:27:1 %s | FileCheck -check-prefix=CHECK-CC6 %s
 // CHECK-CC6: ObjCInterfaceDecl:{TypedText A}
 // CHECK-CC6-NOT: ObjCInterfaceDecl:{TypedText A}

clang/test/Index/complete-exprs.c

 
 typedef int type;
 void f5(float f) {
   (type)f;
 }
 
 // RUN: c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: NotImplemented:{TypedText __PRETTY_FUNCTION__} (65)
+// CHECK-CC1: Keyword:{TypedText __PRETTY_FUNCTION__} (65)
 // CHECK-CC1: macro definition:{TypedText __VERSION__} (70)
 // CHECK-CC1: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (12) (unavailable)
-// CHECK-CC1-NOT: NotImplemented:{TypedText float} (65)
+// CHECK-CC1-NOT: Keyword:{TypedText float} (65)
 // CHECK-CC1: ParmDecl:{ResultType int}{TypedText j} (8)
-// CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC1: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:14 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:7:14 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 
 // RUN: c-index-test -code-completion-at=%s:7:18 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:22 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: c-index-test -code-completion-at=%s:7:2 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: macro definition:{TypedText __VERSION__} (70)
 // CHECK-CC2: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (50)
-// CHECK-CC2: NotImplemented:{TypedText float} (50)
+// CHECK-CC2: Keyword:{TypedText float} (50)
 // CHECK-CC2: ParmDecl:{ResultType int}{TypedText j} (34)
-// CHECK-CC2: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC2: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: c-index-test -code-completion-at=%s:11:16 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: FunctionDecl:{ResultType int}{TypedText f}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC4: VarDecl:{ResultType struct X}{TypedText f1} (50) (deprecated)
 
 // RUN: c-index-test -code-completion-at=%s:19:3 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC6 %s
 // CHECK-CC6: FunctionDecl:{ResultType void}{TypedText f3}{LeftParen (}{Placeholder const char *, ...}{Text , NULL}{RightParen )} (50)
-// CHECK-CC6: NotImplemented:{TypedText void} (50)
-// CHECK-CC6: NotImplemented:{TypedText volatile} (50)
+// CHECK-CC6: Keyword:{TypedText void} (50)
+// CHECK-CC6: Keyword:{TypedText volatile} (50)
 
 // RUN: c-index-test -code-completion-at=%s:24:4 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC7 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:24:4 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC7 %s
 // CHECK-CC7: ParmDecl:{ResultType float}{TypedText f} (34)
 // CHECK-CC7: VarDecl:{ResultType struct X}{TypedText f1} (50) (deprecated)
 // CHECK-CC7: FunctionDecl:{ResultType void}{TypedText f2}{LeftParen (}{RightParen )} (50)
 // CHECK-CC7: FunctionDecl:{ResultType void}{TypedText f3}{LeftParen (}{Placeholder const char *, ...}{Text , NULL}{RightParen )} (50)
 // CHECK-CC7: FunctionDecl:{ResultType void}{TypedText f4}{LeftParen (}{Placeholder const char *str}{RightParen )} (50)
 // CHECK-CC7: FunctionDecl:{ResultType void}{TypedText f5}{LeftParen (}{Placeholder float f}{RightParen )} (50)
 // CHECK-CC7: TypedefDecl:{TypedText type} (50)

clang/test/Index/complete-exprs.cpp

class C {
     int f(int param) {
       return member;
     }
   };
 }
 
 // RUN: c-index-test -code-completion-at=%s:20:2 %s -std=c++0x | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:20:2 -std=c++0x %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText alignof}{LeftParen (}{Placeholder type}{RightParen )} (40)
-// CHECK-CC1: NotImplemented:{ResultType bool}{TypedText noexcept}{LeftParen (}{Placeholder expression}{RightParen )} (40)
-// CHECK-CC1: NotImplemented:{ResultType std::nullptr_t}{TypedText nullptr} (40)
-// CHECK-CC1: NotImplemented:{TypedText operator} (40)
+// CHECK-CC1: Pattern:{ResultType size_t}{TypedText alignof}{LeftParen (}{Placeholder type}{RightParen )} (40)
+// CHECK-CC1: Pattern:{ResultType bool}{TypedText noexcept}{LeftParen (}{Placeholder expression}{RightParen )} (40)
+// CHECK-CC1: Pattern:{ResultType std::nullptr_t}{TypedText nullptr} (40)
+// CHECK-CC1: Keyword:{TypedText operator} (40)
 // CHECK-CC1-NOT: push_back
 // CHECK-CC1: ClassDecl:{TypedText string} (50)
 // CHECK-CC1: CXXConstructor:{TypedText string}{LeftParen (}{RightParen )} (50)
 // CHECK-CC1: CXXConstructor:{TypedText string}{LeftParen (}{Placeholder const char *}{RightParen )} (50)
 // CHECK-CC1: CXXConstructor:{TypedText string}{LeftParen (}{Placeholder const char *}{Comma , }{Placeholder int n}{RightParen )} (50)
 // CHECK-CC1: ClassTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >} (50)
 // CHECK-CC1: CXXConstructor:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >}{LeftParen (}{Placeholder const T &}{Comma , }{Placeholder unsigned int n}{RightParen )} (50)
 // CHECK-CC1: FunctionTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >}{LeftParen (}{Placeholder InputIterator first}{Comma , }{Placeholder InputIterator last}{RightParen )} (50)
 
 // RUN: c-index-test -code-completion-at=%s:19:1 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:19:1 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: ClassDecl:{TypedText string} (50)
 // CHECK-CC2-NOT: CXXConstructor
 // CHECK-CC2: ClassTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >} (50)
 
 // RUN: c-index-test -code-completion-at=%s:26:15 %s | FileCheck -check-prefix=CHECK-CC3 %s
-// CHECK-CC3: NotImplemented:{TypedText float} (50)
+// CHECK-CC3: Keyword:{TypedText float} (50)
 // CHECK-CC3: FunctionDecl:{ResultType int}{TypedText foo}{LeftParen (}{RightParen )} (50)
 // CHECK-CC3: FunctionDecl:{ResultType void}{TypedText g}{LeftParen (}{RightParen )} (50)
 // CHECK-CC3: ClassTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >} (50)
 // CHECK-CC3: CXXConstructor:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >}{LeftParen (}{Placeholder const T &}{Comma , }{Placeholder unsigned int n}{RightParen )} (50)
 // CHECK-CC3: FunctionTemplate:{TypedText vector}{LeftAngle <}{Placeholder typename T}{RightAngle >}{LeftParen (}{Placeholder InputIterator first}{Comma , }{Placeholder InputIterator last}{RightParen )} (50)
 
 // RUN: c-index-test -code-completion-at=%s:34:1 %s -std=c++0x | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{ResultType const X *}{TypedText this} (40)
+// CHECK-CC4: Pattern:{ResultType const X *}{TypedText this} (40)
 
 // RUN: c-index-test -code-completion-at=%s:43:14 %s | FileCheck -check-prefix=CHECK-CC5 %s
 // CHECK-CC5: FieldDecl:{ResultType int}{TypedText member} (8)
 // CHECK-CC5: ParmDecl:{ResultType int}{TypedText param} (8)
 // CHECK-CC5: StructDecl:{TypedText X} (50)
 // CHECK-CC5: VarDecl:{ResultType int}{TypedText x} (12)

clang/test/Index/complete-exprs.m

- (int)method:(id)param1 {
   void foo(bool (^block)(id x, A* y));
   for(BOOL B = YES; ; ) { }
   @[ global ];
   @{ global : global };
 }
 @end
 
 // RUN: c-index-test -code-completion-at=%s:13:2 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: NotImplemented:{ResultType NSString *}{TypedText @"}{Placeholder string}{Text "} (40)
-// CHECK-CC1: NotImplemented:{ResultType id}{TypedText @(}{Placeholder expression}{RightParen )} (40)
-// CHECK-CC1: NotImplemented:{ResultType NSArray *}{TypedText @[}{Placeholder objects, ...}{RightBracket ]} (40)
-// CHECK-CC1: NotImplemented:{ResultType NSDictionary *}{TypedText @{}{Placeholder key}{Colon :}{HorizontalSpace  }{Placeholder object, ...}{RightBrace }} (40)
-// CHECK-CC1: NotImplemented:{ResultType SEL}{TypedText _cmd} (80)
+// CHECK-CC1: Pattern:{ResultType NSString *}{TypedText @"}{Placeholder string}{Text "} (40)
+// CHECK-CC1: Pattern:{ResultType id}{TypedText @(}{Placeholder expression}{RightParen )} (40)
+// CHECK-CC1: Pattern:{ResultType NSArray *}{TypedText @[}{Placeholder objects, ...}{RightBracket ]} (40)
+// CHECK-CC1: Pattern:{ResultType NSDictionary *}{TypedText @{}{Placeholder key}{Colon :}{HorizontalSpace  }{Placeholder object, ...}{RightBrace }} (40)
+// CHECK-CC1: Declaration:{ResultType SEL}{TypedText _cmd} (80)
 // CHECK-CC1: TypedefDecl:{TypedText BOOL} (50)
 // CHECK-CC1: macro definition:{TypedText bool} (51)
 // CHECK-CC1: macro definition:{TypedText NO} (65)
-// CHECK-CC1: NotImplemented:{ResultType A *}{TypedText self} (34)
+// CHECK-CC1: Declaration:{ResultType A *}{TypedText self} (34)
 // CHECK-CC1: macro definition:{TypedText YES} (65)
 // RUN: c-index-test -code-completion-at=%s:14:7 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:14:7 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: TypedefDecl:{TypedText BOOL} (50)
-// CHECK-CC2: NotImplemented:{TypedText char} (50)
-// CHECK-CC2: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC2: Keyword:{TypedText char} (50)
+// CHECK-CC2: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // RUN: c-index-test -code-completion-at=%s:15:1 -fobjc-arc -fobjc-nonfragile-abi  %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:15:1 -fobjc-arc -fobjc-nonfragile-abi %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: FunctionDecl:{ResultType void}{TypedText foo}{LeftParen (}{Placeholder ^bool(id x, A *y)block}{RightParen )} (34)
 // CHECK-CC3: VarDecl:{ResultType id}{TypedText global} (50)
 // CHECK-CC3: ParmDecl:{ResultType id}{TypedText param1} (34)
 
 // RUN: c-index-test -code-completion-at=%s:15:5 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // RUN: c-index-test -code-completion-at=%s:16:5 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // RUN: c-index-test -code-completion-at=%s:16:14 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{ResultType NSArray *}{TypedText @[}{Placeholder objects, ...}{RightBracket ]} (40)
-// CHECK-CC4: NotImplemented:{ResultType NSDictionary *}{TypedText @{}{Placeholder key}{Colon :}{HorizontalSpace  }{Placeholder object, ...}{RightBrace }} (40)
-// CHECK-CC4: NotImplemented:{ResultType SEL}{TypedText _cmd} (80)
+// CHECK-CC4: Pattern:{ResultType NSArray *}{TypedText @[}{Placeholder objects, ...}{RightBracket ]} (40)
+// CHECK-CC4: Pattern:{ResultType NSDictionary *}{TypedText @{}{Placeholder key}{Colon :}{HorizontalSpace  }{Placeholder object, ...}{RightBrace }} (40)
+// CHECK-CC4: Declaration:{ResultType SEL}{TypedText _cmd} (80)
 // CHECK-CC4: macro definition:{TypedText bool} (51)
 // CHECK-CC4: macro definition:{TypedText NO} (65)
-// CHECK-CC4: NotImplemented:{ResultType A *}{TypedText self} (34)
+// CHECK-CC4: Declaration:{ResultType A *}{TypedText self} (34)
 // CHECK-CC4: macro definition:{TypedText YES} (65)

clang/test/Index/complete-lambdas.cpp

void f(int zed) {
     }();
   }
 };
 
 
 // RUN: c-index-test -code-completion-at=%s:12:8 -std=c++11 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: VarDecl:{ResultType int}{TypedText inner_local} (34)
 // CHECK-CC1-NEXT: VarDecl:{ResultType int}{TypedText local} (34)
-// CHECK-CC1-NEXT: NotImplemented:{ResultType X *}{TypedText this} (40)
+// CHECK-CC1-NEXT: Pattern:{ResultType X *}{TypedText this} (40)
 // CHECK-CC1-NEXT: ParmDecl:{ResultType int}{TypedText zed} (34)
 
 // RUN: c-index-test -code-completion-at=%s:12:15 -std=c++11 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: VarDecl:{ResultType int}{TypedText inner_local} (34)
-// CHECK-CC2-NEXT: NotImplemented:{ResultType X *}{TypedText this} (40)
+// CHECK-CC2-NEXT: Pattern:{ResultType X *}{TypedText this} (40)
 // CHECK-CC2-NEXT: ParmDecl:{ResultType int}{TypedText zed} (34)
 
 // RUN: c-index-test -code-completion-at=%s:12:21 -std=c++11 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: VarDecl:{ResultType int}{TypedText inner_local} (34)
 // CHECK-CC3-NEXT: ParmDecl:{ResultType int}{TypedText zed} (34)
 
 // RUN: c-index-test -code-completion-at=%s:12:8 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: TypedefDecl:{TypedText Class} (50)
 // CHECK-CC4: TypedefDecl:{TypedText id} (50)
 // CHECK-CC4: VarDecl:{ResultType int}{TypedText inner_local} (34)
 // CHECK-CC4: VarDecl:{ResultType int}{TypedText local} (34)
-// CHECK-CC4: NotImplemented:{ResultType X *}{TypedText this} (40)
+// CHECK-CC4: Pattern:{ResultType X *}{TypedText this} (40)
 // CHECK-CC4: ParmDecl:{ResultType int}{TypedText zed} (34)
 
 // RUN: c-index-test -code-completion-at=%s:12:15 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: c-index-test -code-completion-at=%s:12:21 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC3 %s

clang/test/Index/complete-lambdas.mm

 // RUN: c-index-test -code-completion-at=%s:16:4 -std=c++11 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: ObjCInterfaceDecl:{TypedText A} (50)
 // CHECK-CC3: ParmDecl:{ResultType A *}{TypedText a} (34)
 // CHECK-CC3: ObjCInterfaceDecl:{TypedText B} (50)
 // CHECK-CC3: TypedefDecl:{TypedText Class} (50)
 
 
 // RUN: c-index-test -code-completion-at=%s:16:21 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC4 %s
-// CHECK-CC4: NotImplemented:{ResultType B *}{TypedText self} (34)
-// CHECK-CC4: NotImplemented:{ResultType A *}{TypedText super} (40)
+// CHECK-CC4: Declaration:{ResultType B *}{TypedText self} (34)
+// CHECK-CC4: Pattern:{ResultType A *}{TypedText super} (40)
 
 // RUN: c-index-test -code-completion-at=%s:18:10 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC1 %s
 
 // RUN: c-index-test -code-completion-at=%s:19:8 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: NotImplemented:{ResultType SEL}{TypedText _cmd} (34)
-// CHECK-CC5-NEXT: NotImplemented:{ResultType B *}{TypedText self} (34)
+// CHECK-CC5: Declaration:{ResultType SEL}{TypedText _cmd} (34)
+// CHECK-CC5-NEXT: Declaration:{ResultType B *}{TypedText self} (34)
 
 // RUN: c-index-test -code-completion-at=%s:20:11 -x objective-c++ -std=c++11 %s | FileCheck -check-prefix=CHECK-CC6 %s
 // CHECK-CC6: ObjCInstanceMethodDecl:{ResultType id}{TypedText instanceMethod:}{Placeholder (int)}{HorizontalSpace  }{TypedText withOther:}{Placeholder (int)} (37)
 // CHECK-CC6-NEXT: ObjCInstanceMethodDecl:{ResultType id}{TypedText someMethod:}{Placeholder (A *)} (32)
 

clang/test/Index/complete-memfunc-cvquals.cpp

 // CHECK-IMPLICIT-CONST: theend
 
 // RUN: c-index-test -code-completion-at=%s:37:1 %s | FileCheck -check-prefix=CHECK-IMPLICIT-VOLATILE %s
 // CHECK-IMPLICIT-VOLATILE: CXXMethod:{ResultType void}{TypedText babble}{LeftParen (}{RightParen )}{Informative  const volatile} (35)
 // CHECK-IMPLICIT-VOLATILE-NOT: baz
 // CHECK-IMPLICIT-VOLATILE: CXXMethod:{ResultType void}{TypedText bingo}{LeftParen (}{RightParen )}{Informative  volatile} (34)
 
 // RUN: c-index-test -code-completion-at=%s:4:17 %s | FileCheck -check-prefix=CHECK-CVQUAL-AFTER %s
-// CHECK-CVQUAL-AFTER: NotImplemented:{TypedText const} (40)
-// CHECK-CVQUAL-AFTER: NotImplemented:{TypedText volatile} (40)
+// CHECK-CVQUAL-AFTER: Keyword:{TypedText const} (40)
+// CHECK-CVQUAL-AFTER: Keyword:{TypedText volatile} (40)
 
 // RUN: c-index-test -code-completion-at=%s:4:23 %s | FileCheck -check-prefix=CHECK-CVQUAL-AFTER2 %s
-// CHECK-CVQUAL-AFTER2-NOT: NotImplemented:{TypedText const} (40)
-// CHECK-CVQUAL-AFTER2: NotImplemented:{TypedText volatile} (40)
+// CHECK-CVQUAL-AFTER2-NOT: Keyword:{TypedText const} (40)
+// CHECK-CVQUAL-AFTER2: Keyword:{TypedText volatile} (40)

clang/test/Index/complete-method-decls.m

 // CHECK-CC7: ObjCInstanceMethodDecl:{LeftParen (}{Text id}{RightParen )}{TypedText abc}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Text return}{HorizontalSpace  }{Placeholder expression}{SemiColon ;}{VerticalSpace  }{RightBrace }} (42)
 // CHECK-CC7: ObjCInstanceMethodDecl:{LeftParen (}{Text id}{RightParen )}{TypedText categoryFunction:}{LeftParen (}{Text int}{RightParen )}{Text x}{HorizontalSpace  }{LeftBrace {}{VerticalSpace
 // CHECK-CC7: ObjCInstanceMethodDecl:{LeftParen (}{Text id}{RightParen )}{TypedText getSelf}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Text return}{HorizontalSpace  }{Placeholder expression}{SemiColon ;}{VerticalSpace  }{RightBrace }} (42)
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:52:21 %s | FileCheck -check-prefix=CHECK-CC8 %s
 // CHECK-CC8: ObjCInstanceMethodDecl:{ResultType id}{Informative first:}{TypedText second2:}{Text (float)y2}{HorizontalSpace  }{TypedText third:}{Text (double)z} (35)
 // CHECK-CC8: ObjCInstanceMethodDecl:{ResultType void *}{Informative first:}{TypedText second3:}{Text (float)y3}{HorizontalSpace  }{TypedText third:}{Text (double)z} (35)
 // CHECK-CC8: ObjCInstanceMethodDecl:{ResultType int}{Informative first:}{TypedText second:}{Text (float)y}{HorizontalSpace  }{TypedText third:}{Text (double)z} (8)
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:52:19 %s | FileCheck -check-prefix=CHECK-CC9 %s
-// CHECK-CC9: NotImplemented:{TypedText x} (40)
-// CHECK-CC9: NotImplemented:{TypedText xx} (40)
-// CHECK-CC9: NotImplemented:{TypedText xxx} (40)
+// CHECK-CC9: Pattern:{TypedText x} (40)
+// CHECK-CC9: Pattern:{TypedText xx} (40)
+// CHECK-CC9: Pattern:{TypedText xxx} (40)
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:52:36 %s | FileCheck -check-prefix=CHECK-CCA %s
-// CHECK-CCA: NotImplemented:{TypedText y2} (40)
+// CHECK-CCA: Pattern:{TypedText y2} (40)
 // RUN: c-index-test -code-completion-at=%s:56:3 %s | FileCheck -check-prefix=CHECK-CCB %s
 // CHECK-CCB: ObjCInstanceMethodDecl:{LeftParen (}{Text int}{RightParen )}{TypedText first:}{LeftParen (}{Text int}{RightParen )}{Text x}{HorizontalSpace  }{TypedText second2:}{LeftParen (}{Text float}{RightParen )}{Text y}{HorizontalSpace  }{TypedText third:}{LeftParen (}{Text double}{RightParen )}{Text z} (40)
 // RUN: c-index-test -code-completion-at=%s:56:8 %s | FileCheck -check-prefix=CHECK-CCC %s
 // CHECK-CCC: ObjCInstanceMethodDecl:{TypedText first:}{LeftParen (}{Text int}{RightParen )}{Text x}{HorizontalSpace  }{TypedText second2:}{LeftParen (}{Text float}{RightParen )}{Text y}{HorizontalSpace  }{TypedText third:}{LeftParen (}{Text double}{RightParen )}{Text z} (40)
 // RUN: c-index-test -code-completion-at=%s:56:21 %s | FileCheck -check-prefix=CHECK-CCD %s
 // CHECK-CCD: ObjCInstanceMethodDecl:{ResultType id}{Informative first:}{TypedText second2:}{Text (float)y2}{HorizontalSpace  }{TypedText third:}{Text (double)z} (35)
 // CHECK-CCD: ObjCInstanceMethodDecl:{ResultType int}{Informative first:}{TypedText second2:}{Text (float)y}{HorizontalSpace  }{TypedText third:}{Text (double)z} (8)
 // CHECK-CCD: ObjCInstanceMethodDecl:{ResultType void *}{Informative first:}{TypedText second3:}{Text (float)y3}{HorizontalSpace  }{TypedText third:}{Text (double)z} (35)
 // CHECK-CCD: ObjCInstanceMethodDecl:{ResultType int}{Informative first:}{TypedText second:}{Text (float)y}{HorizontalSpace  }{TypedText third:}{Text (double)z} (8)
 // RUN: c-index-test -code-completion-at=%s:56:38 %s | FileCheck -check-prefix=CHECK-CCE %s
 // CHECK-CCE: ObjCInstanceMethodDecl:{ResultType id}{Informative first:}{Informative second2:}{TypedText third:}{Text (double)z} (35)
 // CHECK-CCE: ObjCInstanceMethodDecl:{ResultType int}{Informative first:}{Informative second2:}{TypedText third:}{Text (double)z} (8)
 // RUN: c-index-test -code-completion-at=%s:60:4 %s | FileCheck -check-prefix=CHECK-CCF %s
 // CHECK-CCF: ObjCInterfaceDecl:{TypedText A} (50)
 // CHECK-CCF: ObjCInterfaceDecl:{TypedText B} (50)
-// CHECK-CCF: NotImplemented:{TypedText bycopy} (40)
-// CHECK-CCF: NotImplemented:{TypedText byref} (40)
-// CHECK-CCF: NotImplemented:{TypedText in} (40)
-// CHECK-CCF: NotImplemented:{TypedText inout} (40)
-// CHECK-CCF: NotImplemented:{TypedText nonnull} (40)
-// CHECK-CCF: NotImplemented:{TypedText nullable} (40)
-// CHECK-CCF: NotImplemented:{TypedText oneway} (40)
-// CHECK-CCF: NotImplemented:{TypedText out} (40)
-// CHECK-CCF: NotImplemented:{TypedText unsigned} (50)
-// CHECK-CCF: NotImplemented:{TypedText void} (50)
-// CHECK-CCF: NotImplemented:{TypedText volatile} (50)
+// CHECK-CCF: Keyword:{TypedText bycopy} (40)
+// CHECK-CCF: Keyword:{TypedText byref} (40)
+// CHECK-CCF: Keyword:{TypedText in} (40)
+// CHECK-CCF: Keyword:{TypedText inout} (40)
+// CHECK-CCF: Keyword:{TypedText nonnull} (40)
+// CHECK-CCF: Keyword:{TypedText nullable} (40)
+// CHECK-CCF: Keyword:{TypedText oneway} (40)
+// CHECK-CCF: Keyword:{TypedText out} (40)
+// CHECK-CCF: Keyword:{TypedText unsigned} (50)
+// CHECK-CCF: Keyword:{TypedText void} (50)
+// CHECK-CCF: Keyword:{TypedText volatile} (50)
 // RUN: c-index-test -code-completion-at=%s:60:11 %s | FileCheck -check-prefix=CHECK-CCG %s
 // CHECK-CCG: ObjCInterfaceDecl:{TypedText A} (50)
 // CHECK-CCG: ObjCInterfaceDecl:{TypedText B} (50)
-// CHECK-CCG-NOT: NotImplemented:{TypedText bycopy} (40)
-// CHECK-CCG-NOT: NotImplemented:{TypedText byref} (40)
-// CHECK-CCG: NotImplemented:{TypedText in} (40)
-// CHECK-CCG: NotImplemented:{TypedText inout} (40)
-// CHECK-CCG-NOT: NotImplemented:{TypedText oneway} (40)
-// CHECK-CCG: NotImplemented:{TypedText out} (40)
-// CHECK-CCG: NotImplemented:{TypedText unsigned} (50)
-// CHECK-CCG: NotImplemented:{TypedText void} (50)
-// CHECK-CCG: NotImplemented:{TypedText volatile} (50)
+// CHECK-CCG-NOT: Keyword:{TypedText bycopy} (40)
+// CHECK-CCG-NOT: Keyword:{TypedText byref} (40)
+// CHECK-CCG: Keyword:{TypedText in} (40)
+// CHECK-CCG: Keyword:{TypedText inout} (40)
+// CHECK-CCG-NOT: Keyword:{TypedText oneway} (40)
+// CHECK-CCG: Keyword:{TypedText out} (40)
+// CHECK-CCG: Keyword:{TypedText unsigned} (50)
+// CHECK-CCG: Keyword:{TypedText void} (50)
+// CHECK-CCG: Keyword:{TypedText volatile} (50)
 // RUN: c-index-test -code-completion-at=%s:60:24 %s | FileCheck -check-prefix=CHECK-CCF %s
 // RUN: c-index-test -code-completion-at=%s:60:27 %s | FileCheck -check-prefix=CHECK-CCH %s
 // CHECK-CCH: ObjCInterfaceDecl:{TypedText A} (50)
 // CHECK-CCH: ObjCInterfaceDecl:{TypedText B} (50)
-// CHECK-CCH: NotImplemented:{TypedText bycopy} (40)
-// CHECK-CCH: NotImplemented:{TypedText byref} (40)
-// CHECK-CCH-NOT: NotImplemented:{TypedText in} (40)
-// CHECK-CCH: NotImplemented:{TypedText inout} (40)
-// CHECK-CCH: NotImplemented:{TypedText oneway} (40)
-// CHECK-CCH: NotImplemented:{TypedText out} (40)
-// CHECK-CCH: NotImplemented:{TypedText unsigned} (50)
-// CHECK-CCH: NotImplemented:{TypedText void} (50)
-// CHECK-CCH: NotImplemented:{TypedText volatile} (50)
+// CHECK-CCH: Keyword:{TypedText bycopy} (40)
+// CHECK-CCH: Keyword:{TypedText byref} (40)
+// CHECK-CCH-NOT: Keyword:{TypedText in} (40)
+// CHECK-CCH: Keyword:{TypedText inout} (40)
+// CHECK-CCH: Keyword:{TypedText oneway} (40)
+// CHECK-CCH: Keyword:{TypedText out} (40)
+// CHECK-CCH: Keyword:{TypedText unsigned} (50)
+// CHECK-CCH: Keyword:{TypedText void} (50)
+// CHECK-CCH: Keyword:{TypedText volatile} (50)
 
 // IBAction completion
 // RUN: c-index-test -code-completion-at=%s:5:4 %s | FileCheck -check-prefix=CHECK-IBACTION %s
-// CHECK-IBACTION: NotImplemented:{TypedText IBAction}{RightParen )}{Placeholder selector}{Colon :}{LeftParen (}{Text id}{RightParen )}{Text sender} (40)
+// CHECK-IBACTION: Pattern:{TypedText IBAction}{RightParen )}{Placeholder selector}{Colon :}{LeftParen (}{Text id}{RightParen )}{Text sender} (40)
 
 // <rdar://problem/8939352>
 // RUN: c-index-test -code-completion-at=%s:68:9 %s | FileCheck -check-prefix=CHECK-8939352 %s
 // CHECK-8939352: ObjCInstanceMethodDecl:{TypedText method:}{LeftParen (}{Text int}{RightParen )}{Text x}{HorizontalSpace  }{TypedText :}{LeftParen (}{Text int}{RightParen )}{Text y} (40)
 
 
 // RUN: c-index-test -code-completion-at=%s:72:2 %s | FileCheck -check-prefix=CHECK-ONEWAY %s
 // CHECK-ONEWAY: ObjCInstanceMethodDecl:{LeftParen (}{Text oneway }{Text void}{RightParen )}{TypedText method:}{LeftParen (}{Text in }{Text id}{RightParen )}{Text x} (40)

 
 @implementation CompleteWithoutLeadingPrefix
 
 
 
 @end
 
 // RUN: c-index-test -code-completion-at=%s:250:1 %s | FileCheck -check-prefix=CHECK-COMP-NO-PREFIX %s
-// CHECK-COMP-NO-PREFIX: NotImplemented:{TypedText @end} (40)
+// CHECK-COMP-NO-PREFIX: Keyword:{TypedText @end} (40)
 // CHECK-COMP-NO-PREFIX: ObjCClassMethodDecl:{Text +}{HorizontalSpace  }{LeftParen (}{Text int}{RightParen )}{TypedText aClassMethod:}{LeftParen (}{Text int}{RightParen )}{Text x} (40)
 // CHECK-COMP-NO-PREFIX: ObjCInstanceMethodDecl:{Text -}{HorizontalSpace  }{LeftParen (}{Text void}{RightParen )}{TypedText aMethod} (40)
 // CHECK-COMP-NO-PREFIX: ObjCInterfaceDecl:{TypedText I1}
 // CHECK-COMP-NO-PREFIX: ObjCInstanceMethodDecl:{Text -}{HorizontalSpace  }{LeftParen (}{Text int}{RightParen )}{TypedText p} (40)
 // CHECK-COMP-NO-PREFIX: ObjCInstanceMethodDecl:{Text -}{HorizontalSpace  }{LeftParen (}{Text void}{RightParen )}{TypedText setP:}{LeftParen (}{Text int}{RightParen )}{Text p} (40)
 
 @interface NoNameSelectors
 - (void):(int)a;

clang/test/Index/complete-modules.m

 // Note: the run lines follow their respective tests, since line/column
 // matter in this test.
 
 @import LibA.Extensions;
 
 // RUN: rm -rf %t
 // RUN: c-index-test -code-completion-at=%s:4:9 -fmodules-cache-path=%t -fmodules -F %S/Inputs/Frameworks -I %S/Inputs/Headers %s | FileCheck -check-prefix=CHECK-TOP-LEVEL %s
 // RUN: c-index-test -code-completion-at=%s:4:9 -fmodules-cache-path=%t -fmodules -gmodules -F %S/Inputs/Frameworks -I %S/Inputs/Headers %s | FileCheck -check-prefix=CHECK-TOP-LEVEL %s
 // CHECK-TOP-LEVEL: ModuleImport:{TypedText Framework} (50)
 // CHECK-TOP-LEVEL: ModuleImport:{TypedText LibA} (50)
 // CHECK-TOP-LEVEL: ModuleImport:{TypedText nested} (50)
 
 // RUN: c-index-test -code-completion-at=%s:4:14 -fmodules-cache-path=%t -fmodules -F %S/Inputs/Frameworks -I %S/Inputs/Headers %s | FileCheck -check-prefix=CHECK-LIBA %s
 // CHECK-LIBA: ModuleImport:{TypedText Extensions} (50)
 
 // RUN: c-index-test -code-completion-at=%s:4:1 -fmodules-cache-path=%t -fmodules -F %S/Inputs/Frameworks -I %S/Inputs/Headers %s | FileCheck -check-prefix=CHECK-TOP %s
-// CHECK-TOP: NotImplemented:{TypedText @import}{HorizontalSpace  }{Placeholder module} (40)
+// CHECK-TOP: Pattern:{TypedText @import}{HorizontalSpace  }{Placeholder module} (40)
 

clang/test/Index/complete-preprocessor.m

 // The line and column layout of this test is significant. Run lines
 // are at the end.
 
 #if 1
 #endif
 
 #define FOO(a, b) a##b
 #define BAR
 #ifdef FOO
 #endif
 #if defined(FOO)
 #endif
 
 FOO(in,t) value;
 
 // RUN: c-index-test -code-completion-at=%s:4:3 %s | FileCheck -check-prefix=CHECK-CC1 %s
-// CHECK-CC1: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText error}{HorizontalSpace  }{Placeholder message} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText if}{HorizontalSpace  }{Placeholder condition} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText ifdef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText ifndef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText include}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText include}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText include_next}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText include_next}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText line}{HorizontalSpace  }{Placeholder number} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText line}{HorizontalSpace  }{Placeholder number}{HorizontalSpace  }{Text "}{Placeholder filename}{Text "} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText pragma}{HorizontalSpace  }{Placeholder arguments} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText undef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC1-NEXT: NotImplemented:{TypedText warning}{HorizontalSpace  }{Placeholder message} (40)
+// CHECK-CC1: Pattern:{TypedText define}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText error}{HorizontalSpace  }{Placeholder message} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText if}{HorizontalSpace  }{Placeholder condition} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText ifdef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText ifndef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText import}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText import}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText include}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText include}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText include_next}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText include_next}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText line}{HorizontalSpace  }{Placeholder number} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText line}{HorizontalSpace  }{Placeholder number}{HorizontalSpace  }{Text "}{Placeholder filename}{Text "} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText pragma}{HorizontalSpace  }{Placeholder arguments} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText undef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC1-NEXT: Pattern:{TypedText warning}{HorizontalSpace  }{Placeholder message} (40)
 // RUN: c-index-test -code-completion-at=%s:5:2 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText elif}{HorizontalSpace  }{Placeholder condition} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText elifdef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText elifndef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText else} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText endif} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText error}{HorizontalSpace  }{Placeholder message} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText if}{HorizontalSpace  }{Placeholder condition} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText ifdef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText ifndef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText import}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText include}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText include}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText include_next}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText include_next}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText line}{HorizontalSpace  }{Placeholder number} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText line}{HorizontalSpace  }{Placeholder number}{HorizontalSpace  }{Text "}{Placeholder filename}{Text "} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText pragma}{HorizontalSpace  }{Placeholder arguments} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText undef}{HorizontalSpace  }{Placeholder macro} (40)
-// CHECK-CC2-NEXT: NotImplemented:{TypedText warning}{HorizontalSpace  }{Placeholder message} (40)
+// CHECK-CC2: Pattern:{TypedText define}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText define}{HorizontalSpace  }{Placeholder macro}{LeftParen (}{Placeholder args}{RightParen )} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText elif}{HorizontalSpace  }{Placeholder condition} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText elifdef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText elifndef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText else} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText endif} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText error}{HorizontalSpace  }{Placeholder message} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText if}{HorizontalSpace  }{Placeholder condition} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText ifdef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText ifndef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText import}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText import}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText include}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText include}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText include_next}{HorizontalSpace  }{Text "}{Placeholder header}{Text "} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText include_next}{HorizontalSpace  }{Text <}{Placeholder header}{Text >} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText line}{HorizontalSpace  }{Placeholder number} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText line}{HorizontalSpace  }{Placeholder number}{HorizontalSpace  }{Text "}{Placeholder filename}{Text "} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText pragma}{HorizontalSpace  }{Placeholder arguments} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText undef}{HorizontalSpace  }{Placeholder macro} (40)
+// CHECK-CC2-NEXT: Pattern:{TypedText warning}{HorizontalSpace  }{Placeholder message} (40)
 // RUN: c-index-test -code-completion-at=%s:9:8 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: macro definition:{TypedText BAR} (40)
 // CHECK-CC3: macro definition:{TypedText FOO} (40)
 // RUN: c-index-test -code-completion-at=%s:11:13 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: c-index-test -code-completion-at=%s:11:14 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: c-index-test -code-completion-at=%s:11:5 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: macro definition:{TypedText BAR} (70)
 // CHECK-CC4: macro definition:{TypedText FOO}{LeftParen (}{Placeholder a}{Comma , }{Placeholder b}{RightParen )} (70)
 // RUN: c-index-test -code-completion-at=%s:14:5 %s | FileCheck -check-prefix=CHECK-CC5 %s
-// CHECK-CC5: NotImplemented:{TypedText const} (50)
-// CHECK-CC5: NotImplemented:{TypedText double} (50)
-// CHECK-CC5: NotImplemented:{TypedText enum} (50)
-// CHECK-CC5: NotImplemented:{TypedText extern} (40)
-// CHECK-CC5: NotImplemented:{TypedText float} (50)
+// CHECK-CC5: Keyword:{TypedText const} (50)
+// CHECK-CC5: Keyword:{TypedText double} (50)
+// CHECK-CC5: Keyword:{TypedText enum} (50)
+// CHECK-CC5: Keyword:{TypedText extern} (40)
+// CHECK-CC5: Keyword:{TypedText float} (50)
 // CHECK-CC5: macro definition:{TypedText FOO}{LeftParen (}{Placeholder a}{Comma , }{Placeholder b}{RightParen )} (70)
 // CHECK-CC5: TypedefDecl:{TypedText id} (50)
-// CHECK-CC5: NotImplemented:{TypedText inline} (40)
-// CHECK-CC5: NotImplemented:{TypedText int} (50)
-// CHECK-CC5: NotImplemented:{TypedText long} (50)
+// CHECK-CC5: Keyword:{TypedText inline} (40)
+// CHECK-CC5: Keyword:{TypedText int} (50)
+// CHECK-CC5: Keyword:{TypedText long} (50)
 
 // Same tests as above, but with completion caching.
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:4:2 %s | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:5:2 %s | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:9:8 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:11:5 %s | FileCheck -check-prefix=CHECK-CC4 %s
 // RUN: env CINDEXTEST_EDITING=1 CINDEXTEST_COMPLETION_CACHING=1 c-index-test -code-completion-at=%s:14:5 %s | FileCheck -check-prefix=CHECK-CC5 %s

clang/test/Index/complete-recovery.m

- (void)method:(int)x {
   blah ? blech : [a2 method:1];
   (a * a2)([a2 method:1]);
   B *a = [a2 method:1];
 }
 @end
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:9:20 %s 2>%t | FileCheck -check-prefix=CHECK-CC1 %s
 // RUN: not grep error %t
-// CHECK-CC1: NotImplemented:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
-// CHECK-CC1-NOT: NotImplemented:{TypedText _Bool}
+// CHECK-CC1: Pattern:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
+// CHECK-CC1-NOT: Keyword:{TypedText _Bool}
 // CHECK-CC1: VarDecl:{ResultType A *}{TypedText a}
-// CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )}
+// CHECK-CC1: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )}
 
 // Test case for fix committed in r145441.
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:9:20 %s -fms-compatibility | FileCheck -check-prefix=CHECK-CC1 %s
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:10:25 %s | FileCheck -check-prefix=CHECK-CC2 %s
-// CHECK-CC2: NotImplemented:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
-// CHECK-CC2: NotImplemented:{TypedText _Bool}
+// CHECK-CC2: Pattern:{ResultType char[]}{TypedText @encode}{LeftParen (}{Placeholder type-name}{RightParen )}
+// CHECK-CC2: Keyword:{TypedText _Bool}
 // CHECK-CC2: VarDecl:{ResultType A *}{TypedText a}
-// CHECK-CC2: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )}
+// CHECK-CC2: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )}
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:12:11 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: ObjCInstanceMethodDecl:{ResultType void}{TypedText method:}{Placeholder (int)} (32)
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:13:22 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:14:16 %s | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:15:14 %s | FileCheck -check-prefix=CHECK-CC3 %s

clang/test/Index/complete-stmt.c

 // Note: the run lines follow their respective tests, since line/column
 // matter in this test.
 
 typedef int Integer;
 void f(int x) {
   if (x) {
   } 
 }
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:7:4 %s | FileCheck -check-prefix=CHECK-IF-ELSE %s
-// CHECK-IF-ELSE: NotImplemented:{TypedText else}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Placeholder statements}{VerticalSpace  }{RightBrace }} (40)
-// CHECK-IF-ELSE: NotImplemented:{TypedText else if}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Placeholder statements}{VerticalSpace  }{RightBrace }} (40)
+// CHECK-IF-ELSE: Pattern:{TypedText else}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Placeholder statements}{VerticalSpace  }{RightBrace }} (40)
+// CHECK-IF-ELSE: Pattern:{TypedText else if}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )}{HorizontalSpace  }{LeftBrace {}{VerticalSpace  }{Placeholder statements}{VerticalSpace  }{RightBrace }} (40)
 
 // RUN: c-index-test -code-completion-at=%s:7:4 %s | FileCheck -check-prefix=CHECK-IF-ELSE-SIMPLE %s
-// CHECK-IF-ELSE-SIMPLE: NotImplemented:{TypedText else} (40)
-// CHECK-IF-ELSE-SIMPLE: NotImplemented:{TypedText else if}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )} (40)
+// CHECK-IF-ELSE-SIMPLE: Pattern:{TypedText else} (40)
+// CHECK-IF-ELSE-SIMPLE: Pattern:{TypedText else if}{HorizontalSpace  }{LeftParen (}{Placeholder expression}{RightParen )} (40)
 
 // RUN: c-index-test -code-completion-at=%s:6:1 %s | FileCheck -check-prefix=CHECK-STMT %s
-// CHECK-STMT: NotImplemented:{TypedText _Nonnull} (50)
-// CHECK-STMT: NotImplemented:{TypedText _Nullable} (50)
-// CHECK-STMT: NotImplemented:{TypedText char} (50)
-// CHECK-STMT: NotImplemented:{TypedText const} (50)
-// CHECK-STMT: NotImplemented:{TypedText double} (50)
-// CHECK-STMT: NotImplemented:{TypedText enum} (50)
+// CHECK-STMT: Keyword:{TypedText _Nonnull} (50)
+// CHECK-STMT: Keyword:{TypedText _Nullable} (50)
+// CHECK-STMT: Keyword:{TypedText char} (50)
+// CHECK-STMT: Keyword:{TypedText const} (50)
+// CHECK-STMT: Keyword:{TypedText double} (50)
+// CHECK-STMT: Keyword:{TypedText enum} (50)
 // CHECK-STMT: FunctionDecl:{ResultType void}{TypedText f}{LeftParen (}{Placeholder int x}{RightParen )} (50)
 // CHECK-STMT: TypedefDecl:{TypedText Integer} (50)
 // CHECK-STMT: ParmDecl:{ResultType int}{TypedText x} (34)

clang/test/Index/complete-super.cpp

 // CHECK-BAR-UNQUAL: CXXMethod:{Text A::}{TypedText bar}{LeftParen (}{Placeholder real}{RightParen )} (20)
 // CHECK-BAR-UNQUAL: CXXMethod:{ResultType void}{TypedText bar}{LeftParen (}{Placeholder float real}{RightParen )} (34)
 // CHECK-BAR-UNQUAL: CXXMethod:{ResultType void}{Text A::}{TypedText bar}{LeftParen (}{Placeholder double x}{RightParen )} (36)
 
 // RUN: c-index-test -code-completion-at=%s:16:6 %s | FileCheck -check-prefix=CHECK-FOO-QUAL %s
 // CHECK-FOO-QUAL: CXXMethod:{TypedText foo}{LeftParen (}{Placeholder a}{Comma , }{Placeholder b}{RightParen )} (20)
 
 // RUN: c-index-test -code-completion-at=%s:5:1 %s | FileCheck -check-prefix=CHECK-ACCESS %s
-// CHECK-ACCESS: NotImplemented:{TypedText private} (40)
-// CHECK-ACCESS: NotImplemented:{TypedText protected} (40)
-// CHECK-ACCESS: NotImplemented:{TypedText public} (40)
+// CHECK-ACCESS: Pattern:{TypedText private} (40)
+// CHECK-ACCESS: Pattern:{TypedText protected} (40)
+// CHECK-ACCESS: Pattern:{TypedText public} (40)
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:5:1 %s | FileCheck -check-prefix=CHECK-ACCESS-PATTERN %s
-// CHECK-ACCESS-PATTERN: NotImplemented:{TypedText private}{Colon :} (40)
-// CHECK-ACCESS-PATTERN: NotImplemented:{TypedText protected}{Colon :} (40)
-// CHECK-ACCESS-PATTERN: NotImplemented:{TypedText public}{Colon :} (40)
+// CHECK-ACCESS-PATTERN: Pattern:{TypedText private}{Colon :} (40)
+// CHECK-ACCESS-PATTERN: Pattern:{TypedText protected}{Colon :} (40)
+// CHECK-ACCESS-PATTERN: Pattern:{TypedText public}{Colon :} (40)
 
 // RUN: env CINDEXTEST_CODE_COMPLETE_PATTERNS=1 c-index-test -code-completion-at=%s:10:12 %s | FileCheck -check-prefix=CHECK-INHERITANCE-PATTERN %s
-// CHECK-INHERITANCE-PATTERN: NotImplemented:{TypedText private} (40)
-// CHECK-INHERITANCE-PATTERN: NotImplemented:{TypedText protected} (40)
-// CHECK-INHERITANCE-PATTERN: NotImplemented:{TypedText public} (40)
+// CHECK-INHERITANCE-PATTERN: Pattern:{TypedText private} (40)
+// CHECK-INHERITANCE-PATTERN: Pattern:{TypedText protected} (40)
+// CHECK-INHERITANCE-PATTERN: Pattern:{TypedText public} (40)

clang/test/Index/complete-synthesized.m

- (short)method3 {
   return prop3;
 }
 @end
 
 // RUN: c-index-test -code-completion-at=%s:24:1 -target x86_64-apple-macosx10.7 -fobjc-nonfragile-abi %s | FileCheck %s
 // RUN: c-index-test -code-completion-at=%s:30:2 -target x86_64-apple-macosx10.7 -fobjc-nonfragile-abi %s | FileCheck %s
 // RUN: c-index-test -code-completion-at=%s:34:2 -target x86_64-apple-macosx10.7 -fobjc-nonfragile-abi %s | FileCheck %s
 
-// CHECK: NotImplemented:{TypedText _Bool} (50)
+// CHECK: Keyword:{TypedText _Bool} (50)
 // CHECK: ObjCIvarDecl:{ResultType float}{TypedText _prop2} (35)
 // CHECK-NOT: prop2
 // CHECK-NOT: prop3
 // CHECK: ObjCIvarDecl:{ResultType double}{TypedText _prop4} (35)

clang/test/Index/complete-type-factors.m

 // CHECK-CC1: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (12)
 // CHECK-CC1: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (25)
 // CHECK-CC1: EnumConstantDecl:{ResultType enum Color}{TypedText Green} (32)
 // CHECK-CC1: EnumConstantDecl:{ResultType enum Priority}{TypedText High} (32)
 // CHECK-CC1: ParmDecl:{ResultType int}{TypedText integer} (8)
 // CHECK-CC1: EnumConstantDecl:{ResultType enum Priority}{TypedText Low} (32)
 // CHECK-CC1: ParmDecl:{ResultType enum Priority}{TypedText priority} (17)
 // CHECK-CC1: EnumConstantDecl:{ResultType enum Color}{TypedText Red} (32)
-// CHECK-CC1: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC1: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // CHECK-CC1: FunctionDecl:{ResultType enum Priority}{TypedText test1}{LeftParen (}{Placeholder enum Priority priority}{Comma , }{Placeholder enum Color color}{Comma , }{Placeholder int integer}{RightParen )} (25)
 // RUN: c-index-test -code-completion-at=%s:17:18 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: EnumConstantDecl:{ResultType enum Color}{TypedText Blue} (16)
 // CHECK-CC2: ParmDecl:{ResultType enum Color}{TypedText color} (8)
 // CHECK-CC2: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (25)
 // CHECK-CC2: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC2: EnumConstantDecl:{ResultType enum Color}{TypedText Green} (16)
 // CHECK-CC2: EnumConstantDecl:{ResultType enum Priority}{TypedText High} (65)
 // CHECK-CC2: VarDecl:{ResultType int}{TypedText i} (17)
 // CHECK-CC2: ParmDecl:{ResultType int}{TypedText integer} (17)
 // CHECK-CC2: EnumConstantDecl:{ResultType enum Priority}{TypedText Low} (65)
 // CHECK-CC2: ParmDecl:{ResultType enum Priority}{TypedText priority} (34)
 // CHECK-CC2: EnumConstantDecl:{ResultType enum Color}{TypedText Red} (16)
-// CHECK-CC2: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC2: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // CHECK-CC2: FunctionDecl:{ResultType enum Priority}{TypedText test1}{LeftParen (}{Placeholder enum Priority priority}{Comma , }{Placeholder enum Color color}{Comma , }{Placeholder int integer}{RightParen )} (50)
 // RUN: c-index-test -code-completion-at=%s:18:10 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC3 %s
 // CHECK-CC3: EnumConstantDecl:{ResultType enum Color}{TypedText Blue} (65)
 // CHECK-CC3: VarDecl:{ResultType enum Color}{TypedText c} (34)
 // CHECK-CC3: ParmDecl:{ResultType enum Color}{TypedText color} (34)
 // CHECK-CC3: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (25)
 // CHECK-CC3: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (12)
 // CHECK-CC3: FunctionDecl:{ResultType void}{TypedText func3}{LeftParen (}{Placeholder float}{RightParen )} (50)
 // CHECK-CC3: EnumConstantDecl:{ResultType enum Color}{TypedText Green} (65)
 // CHECK-CC3: EnumConstantDecl:{ResultType enum Priority}{TypedText High} (16)
 // CHECK-CC3: VarDecl:{ResultType int}{TypedText i} (17)
 // CHECK-CC3: ParmDecl:{ResultType int}{TypedText integer} (17)
 // CHECK-CC3: EnumConstantDecl:{ResultType enum Priority}{TypedText Low} (16)
 // CHECK-CC3: ParmDecl:{ResultType enum Priority}{TypedText priority} (8)
 // CHECK-CC3: EnumConstantDecl:{ResultType enum Color}{TypedText Red} (65)
-// CHECK-CC3: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC3: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // CHECK-CC3: FunctionDecl:{ResultType enum Priority}{TypedText test1}{LeftParen (}{Placeholder enum Priority priority}{Comma , }{Placeholder enum Color color}{Comma , }{Placeholder int integer}{RightParen )} (12)
 // RUN: c-index-test -code-completion-at=%s:19:9 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC4 %s
 // CHECK-CC4: EnumConstantDecl:{ResultType enum Color}{TypedText Blue} (65)
 // CHECK-CC4: VarDecl:{ResultType enum Color}{TypedText c} (34)
 // CHECK-CC4: ParmDecl:{ResultType enum Color}{TypedText color} (34)
 // CHECK-CC4: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (50)
 // CHECK-CC4: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC4: FunctionDecl:{ResultType void}{TypedText func3}{LeftParen (}{Placeholder float}{RightParen )} (50)
 // CHECK-CC4: EnumConstantDecl:{ResultType enum Color}{TypedText Green} (65)
 // CHECK-CC4: EnumConstantDecl:{ResultType enum Priority}{TypedText High} (65)
 // CHECK-CC4: VarDecl:{ResultType int}{TypedText i} (34)
 // CHECK-CC4: ParmDecl:{ResultType int}{TypedText integer} (34)
 // CHECK-CC4: EnumConstantDecl:{ResultType enum Priority}{TypedText Low} (65)
 // CHECK-CC4: ParmDecl:{ResultType enum Priority}{TypedText priority} (34)
 // CHECK-CC4: EnumConstantDecl:{ResultType enum Color}{TypedText Red} (65)
-// CHECK-CC4: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC4: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // CHECK-CC4: FunctionDecl:{ResultType enum Priority}{TypedText test1}{LeftParen (}{Placeholder enum Priority priority}{Comma , }{Placeholder enum Color color}{Comma , }{Placeholder int integer}{RightParen )} (50)
 // RUN: c-index-test -code-completion-at=%s:21:9 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC4 %s
 // RUN: c-index-test -code-completion-at=%s:22:7 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC6 %s
 // CHECK-CC6: VarDecl:{ResultType void (^)(enum Color, int)}{TypedText block} (34)
 // CHECK-CC6: EnumConstantDecl:{ResultType enum Color}{TypedText Blue} (16)
 // CHECK-CC6: VarDecl:{ResultType enum Color}{TypedText c} (8)
 // CHECK-CC6: ParmDecl:{ResultType enum Color}{TypedText color} (8)
 // CHECK-CC6: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (25)
 // CHECK-CC6: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC6: FunctionDecl:{ResultType void}{TypedText func3}{LeftParen (}{Placeholder float}{RightParen )} (50)
 // CHECK-CC6: EnumConstantDecl:{ResultType enum Color}{TypedText Green} (16)
 // CHECK-CC6: EnumConstantDecl:{ResultType enum Priority}{TypedText High} (65)
 // CHECK-CC6: VarDecl:{ResultType int}{TypedText i} (17)
 // CHECK-CC6: ParmDecl:{ResultType int}{TypedText integer} (17)
 // CHECK-CC6: EnumConstantDecl:{ResultType enum Priority}{TypedText Low} (65)
 // CHECK-CC6: ParmDecl:{ResultType enum Priority}{TypedText priority} (34)
 // CHECK-CC6: EnumConstantDecl:{ResultType enum Color}{TypedText Red} (16)
-// CHECK-CC6: NotImplemented:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
+// CHECK-CC6: Pattern:{ResultType size_t}{TypedText sizeof}{LeftParen (}{Placeholder expression-or-type}{RightParen )} (40)
 // CHECK-CC6: FunctionDecl:{ResultType enum Priority}{TypedText test1}{LeftParen (}{Placeholder enum Priority priority}{Comma , }{Placeholder enum Color color}{Comma , }{Placeholder int integer}{RightParen )} (50)
 // RUN: c-index-test -code-completion-at=%s:31:13 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC7 %s
 // RUN: c-index-test -code-completion-at=%s:32:13 -Xclang -code-completion-patterns %s | FileCheck -check-prefix=CHECK-CC7 %s
 // CHECK-CC7: ParmDecl:{ResultType A *}{TypedText a} (34)
 // CHECK-CC7: EnumConstantDecl:{ResultType enum Color}{TypedText Blue} (16)
 // CHECK-CC7: FunctionDecl:{ResultType int}{TypedText func1}{LeftParen (}{Placeholder enum Color}{RightParen )} (25)
 // CHECK-CC7: FunctionDecl:{ResultType enum Priority}{TypedText func2}{LeftParen (}{Placeholder int}{RightParen )} (50)
 // CHECK-CC7: FunctionDecl:{ResultType void}{TypedText func3}{LeftParen (}{Placeholder float}{RightParen )} (50)

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

static void print_token_range(CXTranslationUnit translation_unit,
   fprintf(file, "}");
 }
 
 static void print_completion_result(CXTranslationUnit translation_unit,
                                     CXCodeCompleteResults *completion_results,
                                     unsigned index,
                                     FILE *file) {
   CXCompletionResult *completion_result = completion_results->Results + index;
-  CXString ks = clang_getCursorKindSpelling(completion_result->CursorKind);
+  CXString ks =
+      completion_result->CursorKind == CXCursor_NotImplemented
+          ? clang_getCompletionResultKindSpelling(completion_result->ResultKind)
+          : clang_getCursorKindSpelling(completion_result->CursorKind);
   unsigned annotationCount;
   enum CXCursorKind ParentKind;
   CXString ParentName;
   CXString BriefComment;
   CXString Annotation;
   const char *BriefCommentCString;
   unsigned i;
   

clang/tools/libclang/CIndex.cpp

printTemplateArgumentList(
         OS, ClassSpec->getTemplateArgs().asArray(), Policy,
         ClassSpec->getSpecializedTemplate()->getTemplateParameters());
     return cxstring::createDup(OS.str());
   }
 
   return clang_getCursorSpelling(C);
 }
 
+CXString
+clang_getCompletionResultKindSpelling(enum CXCompletionResultKind Kind) {
+  switch (Kind) {
+  case CXCompletionResult_Declaration:
+    return cxstring::createRef("Declaration");
+  case CXCompletionResult_Keyword:
+    return cxstring::createRef("Keyword");
+  case CXCompletionResult_Macro:
+    return cxstring::createRef("Macro");
+  case CXCompletionResult_Pattern:
+    return cxstring::createRef("Pattern");
+  }
+
+  llvm_unreachable("Unhandled CXCompletionResultKind");
+}
+
 CXString clang_getCursorKindSpelling(enum CXCursorKind Kind) {
   switch (Kind) {
   case CXCursor_FunctionDecl:
     return cxstring::createRef("FunctionDecl");
   case CXCursor_TypedefDecl:
     return cxstring::createRef("TypedefDecl");
   case CXCursor_EnumDecl:
     return cxstring::createRef("EnumDecl");

clang/tools/libclang/CIndexCodeCompletion.cpp

void ProcessCodeCompleteResults(Sema &S,
         AllocatedResults.FixItsVector.reserve(NumResults);
       for (unsigned I = 0; I != NumResults; ++I) {
         CodeCompletionString *StoredCompletion
           = Results[I].CreateCodeCompletionString(S, Context, getAllocator(),
                                                   getCodeCompletionTUInfo(),
                                                   includeBriefComments());
         
         CXCompletionResult R;
+        R.ResultKind = Results[I].Kind;
         R.CursorKind = Results[I].CursorKind;
         R.CompletionString = StoredCompletion;
         StoredResults.push_back(R);
         if (includeFixIts())
           AllocatedResults.FixItsVector.emplace_back(std::move(Results[I].FixIts));
       }
 
       enum CodeCompletionContext::Kind contextKind = Context.getKind();
void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
       StoredResults.reserve(StoredResults.size() + NumCandidates);
       for (unsigned I = 0; I != NumCandidates; ++I) {
         CodeCompletionString *StoredCompletion =
             Candidates[I].CreateSignatureString(CurrentArg, S, getAllocator(),
                                                 getCodeCompletionTUInfo(),
                                                 includeBriefComments(), Braced);
 
         CXCompletionResult R;
+        R.ResultKind = CXCompletionResult_Declaration;
         R.CursorKind = CXCursor_OverloadCandidate;
         R.CompletionString = StoredCompletion;
         StoredResults.push_back(R);
       }
     }
 
     CodeCompletionAllocator &getAllocator() override {
       return *AllocatedResults.CodeCompletionAllocator;

clang/tools/libclang/libclang.map

 # If you add a symbol to this file, make sure to add it with the correct
 # version.  For example, if the LLVM main branch is LLVM 14.0.0, add new
 # symbols with the version LLVM_14.
 # On platforms where versions scripts are not used, this file will be used to
 # generate a list of exports for libclang.so
 
+LLVM_15 {
+  global:
+    clang_getCompletionResultKindSpelling;
+}
 LLVM_13 {
   global:
     clang_BlockCommandComment_getArgText;
     clang_BlockCommandComment_getCommandName;
     clang_BlockCommandComment_getNumArgs;
     clang_BlockCommandComment_getParagraph;
     clang_CXCursorSet_contains;
     clang_CXCursorSet_insert;

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

public:
   }
 
   /// \name Code-completion filtering
   /// Check if the result should be filtered out.
   bool isResultFilteredOut(StringRef Filter,
                            CodeCompletionResult Result) override {
     // This code is mostly copied from CodeCompleteConsumer.
     switch (Result.Kind) {
-    case CodeCompletionResult::RK_Declaration:
+    case CXCompletionResult_Declaration:
       return !(
           Result.Declaration->getIdentifier() &&
           Result.Declaration->getIdentifier()->getName().startswith(Filter));
-    case CodeCompletionResult::RK_Keyword:
+    case CXCompletionResult_Keyword:
       return !StringRef(Result.Keyword).startswith(Filter);
-    case CodeCompletionResult::RK_Macro:
+    case CXCompletionResult_Macro:
       return !Result.Macro->getName().startswith(Filter);
-    case CodeCompletionResult::RK_Pattern:
+    case CXCompletionResult_Pattern:
       return !StringRef(Result.Pattern->getAsString()).startswith(Filter);
     }
     // If we trigger this assert or the above switch yields a warning, then
     // CodeCompletionResult has been enhanced with more kinds of completion
     // results. Expand the switch above in this case.
     assert(false && "Unknown completion result type?");
     // If we reach this, then we should just ignore whatever kind of unknown
     // result we got back. We probably can't turn it into any kind of useful
private:
   /// \return Returns llvm::None if no completion should be provided for the
   ///         given CodeCompletionResult.
   llvm::Optional<CompletionWithPriority>
   getCompletionForResult(const CodeCompletionResult &R) const {
     std::string ToInsert;
     std::string Description;
     // Handle the different completion kinds that come from the Sema.
     switch (R.Kind) {
-    case CodeCompletionResult::RK_Declaration: {
+    case CXCompletionResult_Declaration: {
       const NamedDecl *D = R.Declaration;
       ToInsert = R.Declaration->getNameAsString();
       // If we have a function decl that has no arguments we want to
       // complete the empty parantheses for the user. If the function has
       // arguments, we at least complete the opening bracket.
       if (const FunctionDecl *F = dyn_cast<FunctionDecl>(D)) {
         if (F->getNumParams() == 0)
           ToInsert += "()";
case CXCompletionResult_Declaration: {
       } else if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) {
         // If we try to complete a namespace, then we can directly append
         // the '::'.
         if (!N->isAnonymousNamespace())
           ToInsert += "::";
       }
       break;
     }
-    case CodeCompletionResult::RK_Keyword:
+    case CXCompletionResult_Keyword:
       ToInsert = R.Keyword;
       break;
-    case CodeCompletionResult::RK_Macro:
+    case CXCompletionResult_Macro:
       ToInsert = R.Macro->getName().str();
       break;
-    case CodeCompletionResult::RK_Pattern:
+    case CXCompletionResult_Pattern:
       ToInsert = R.Pattern->getTypedText();
       break;
     }
     // We also filter some internal lldb identifiers here. The user
     // shouldn't see these.
     if (llvm::StringRef(ToInsert).startswith("$__lldb_"))
       return llvm::None;
     if (ToInsert.empty())