[CodeComplete] Expose InBaseClass signal in code completion results.

[ioeric]

Summary

No new tests as the existing tests for result priority should give us
coverage. Also as the new flag is trivial enough, I'm reluctant to plumb the
flag to c-index-test output.

[ilya-biryukov]

LG, but could we add a test for the new flag it by printing it in PrintingCodeCompleteConsumer::ProcessCodeCompleteResults() and adding corresponding tests to clang/test/CodeCompletion?

Similar to how it's done for the Hidden flag in the results

[ioeric]

• Add tests for the new flag.

[ioeric]

In D53635#1273904, @ilya-biryukov wrote:

LG, but could we add a test for the new flag it by printing it in PrintingCodeCompleteConsumer::ProcessCodeCompleteResults() and adding corresponding tests to clang/test/CodeCompletion?

Similar to how it's done for the Hidden flag in the results

Done. That was way easy (comparing to c-index-test). Thanks for the pointers!

[ilya-biryukov]

LGTM with a NIT

lib/Sema/CodeCompleteConsumer.cpp

557 ↗

(On Diff #170838)

NIT: Maybe add a space between the items, i.e. join with ", " as a separator?

[ilya-biryukov]

And another NIT :-)

lib/Sema/CodeCompleteConsumer.cpp

548 ↗

(On Diff #170838)

NIT: maybe move Tags into the corresponding case handler?

Would require putting a set of braces around it, but that shouldn't make the code less readable.

[ioeric]

• move tags into case.

[ioeric]

• Rebase

lib/Sema/CodeCompleteConsumer.cpp

557 ↗

(On Diff #170838)

Considering we put everything in one line, I think it's reasonable to drop the spaces to keep the output compact. These tags are more expected to be read by tests than human after all.

[ilya-biryukov]

lib/Sema/CodeCompleteConsumer.cpp

557 ↗

(On Diff #170838)

I would argue this output is also read by humans, therefore we should add a space.
We do "grep" the results with FileCheck in tests and technically it does not matter if we have a space or not. But the users still look at the output when (1) something goes wrong or (2) they read through the test cases.

cfe/trunk/include/clang/Sema/CodeCompleteConsumer.h

public:
   /// replacing '.' with '->'.
   /// In 'vec_ptr->^', one of the completions is 'release', it requires
   /// replacing '->' with '.'.
   std::vector<FixItHint> FixIts;
 
   /// Whether this result is hidden by another name.
   bool Hidden : 1;
 
+  /// Whether this is a class member from base class.
+  bool InBaseClass : 1;
+
   /// Whether this result was found via lookup into a base class.
   bool QualifierIsInformative : 1;
 
   /// Whether this declaration is the beginning of a
   /// nested-name-specifier and, therefore, should be followed by '::'.
   bool StartsNestedNameSpecifier : 1;
 
   /// Whether all parameters (of a function, Objective-C
public:
 
   /// 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),
-        FixIts(std::move(FixIts)), Hidden(false),
+        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),
-        CursorKind(CXCursor_NotImplemented), Hidden(false),
+        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),
-        CursorKind(CXCursor_MacroDefinition), Hidden(false),
+        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)
+  CodeCompletionResult(
+      CodeCompletionString *Pattern, unsigned Priority = CCP_CodePattern,
       : Declaration(D), Pattern(Pattern), Priority(Priority), Kind(RK_Pattern),
         CursorKind(CursorKind), Availability(Availability), Hidden(false),
-        QualifierIsInformative(false), StartsNestedNameSpecifier(false),
-        AllParametersAreInformative(false), DeclaringEntity(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),
-        Hidden(false), QualifierIsInformative(false),
+        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.
   const NamedDecl *getDeclaration() const {

cfe/trunk/lib/Sema/CodeCompleteConsumer.cpp

PrintingCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &SemaRef,
   // Print the results.
   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:
       OS << *Results[I].Declaration;
+      {
+        std::vector<std::string> Tags;
         if (Results[I].Hidden)
-        OS << " (Hidden)";
-      if (CodeCompletionString *CCS
-            = Results[I].CreateCodeCompletionString(SemaRef, Context,
-                                                    getAllocator(),
-                                                    CCTUInfo,
-                                                    includeBriefComments())) {
+          Tags.push_back("Hidden");
+        if (Results[I].InBaseClass)
+          Tags.push_back("InBase");
+        if (!Tags.empty())
+          OS << " (" << llvm::join(Tags, ",") << ")";
+      }
+      if (CodeCompletionString *CCS = Results[I].CreateCodeCompletionString(
+              SemaRef, Context, getAllocator(), CCTUInfo,
         OS << " : " << CCS->getAsString();
         if (const char *BriefComment = CCS->getBriefComment())
           OS << " : " << BriefComment;
       }
       for (const FixItHint &FixIt : Results[I].FixIts) {
         const SourceLocation BLoc = FixIt.RemoveRange.getBegin();
         const SourceLocation ELoc = FixIt.RemoveRange.getEnd();
 

cfe/trunk/lib/Sema/SemaCodeComplete.cpp

void ResultBuilder::MaybeAddResult(Result R, DeclContext *CurContext) {
   // map.
   SMap[R.Declaration->getDeclName()].Add(R.Declaration, Results.size());
   Results.push_back(R);
 
   if (!AsNestedNameSpecifier)
     MaybeAddConstructorResults(R);
 }
 
+static void setInBaseClass(ResultBuilder::Result &R) {
+  R.Priority += CCD_InBaseClass;
+  R.InBaseClass = true;
+}
+
 void ResultBuilder::AddResult(Result R, DeclContext *CurContext,
                               NamedDecl *Hiding, bool InBaseClass = false) {
   if (R.Kind != Result::RK_Declaration) {
     // For non-declaration results, just add the result.
     Results.push_back(R);
     return;
   }
 
else if (const TagDecl *Tag = dyn_cast<TagDecl>(Ctx))
       R.Qualifier = NestedNameSpecifier::Create(SemaRef.Context, nullptr, false,
                             SemaRef.Context.getTypeDeclType(Tag).getTypePtr());
     else
       R.QualifierIsInformative = false;
   }
 
   // Adjust the priority if this result comes from a base class.
   if (InBaseClass)
-    R.Priority += CCD_InBaseClass;
+    setInBaseClass(R);
 
   AdjustResultPriorityForDecl(R);
 
   if (HasObjectTypeQualifiers)
     if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(R.Declaration))
       if (Method->isInstance()) {
         Qualifiers MethodQuals
                         = Qualifiers::fromCVRMask(Method->getTypeQualifiers());
if (M->isInstanceMethod() == WantInstanceMethods ||
 
       if (!Selectors.insert(M->getSelector()).second)
         continue;
 
       Result R = Result(M, Results.getBasePriority(M), nullptr);
       R.StartParameter = SelIdents.size();
       R.AllParametersAreInformative = (WantKind != MK_Any);
       if (!InOriginalClass)
-        R.Priority += CCD_InBaseClass;
+        setInBaseClass(R);
       Results.MaybeAddResult(R, CurContext);
     }
   }
 
   // Visit the protocols of protocols.
   if (ObjCProtocolDecl *Protocol = dyn_cast<ObjCProtocolDecl>(Container)) {
     if (Protocol->hasDefinition()) {
       const ObjCList<ObjCProtocolDecl> &Protocols
if (IsInImplementation && Results.includeCodePatterns()) {
       } else
         Builder.AddPlaceholderChunk("statements");
 
       Builder.AddChunk(CodeCompletionString::CK_VerticalSpace);
       Builder.AddChunk(CodeCompletionString::CK_RightBrace);
     }
 
     unsigned Priority = CCP_CodePattern;
+    auto R = Result(Builder.TakeString(), Method, Priority);
     if (!M->second.getInt())
-      Priority += CCD_InBaseClass;
-
-    Results.AddResult(Result(Builder.TakeString(), Method, Priority));
+      setInBaseClass(R);
+    Results.AddResult(std::move(R));
   }
 
   // Add Key-Value-Coding and Key-Value-Observing accessor methods for all of
   // the properties in this class and its categories.
   if (Context.getLangOpts().ObjC2) {
     SmallVector<ObjCContainerDecl *, 4> Containers;
     Containers.push_back(SearchDecl);
 

cfe/trunk/test/CodeCompletion/member-access.cpp

 
 struct Bar {
   void foo(bool param) {
     Foo::foo(  );// unresolved member expression with an implicit base
   }
 };
 
   // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:31:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 --implicit-check-not="Derived : Derived(" %s
-  // CHECK-CC1: Base1 : Base1::
-  // CHECK-CC1: member1 : [#int#][#Base1::#]member1
-  // CHECK-CC1: member1 : [#int#][#Base2::#]member1
-  // CHECK-CC1: member2 : [#float#][#Base1::#]member2
-  // CHECK-CC1: member3
+  // CHECK-CC1: Base1 (InBase) : Base1::
+  // CHECK-CC1: member1 (InBase) : [#int#][#Base1::#]member1
+  // CHECK-CC1: member1 (InBase) : [#int#][#Base2::#]member1
+  // CHECK-CC1: member2 (InBase) : [#float#][#Base1::#]member2
+  // CHECK-CC1: member3 (InBase)
   // CHECK-CC1: member4
-  // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#float#>)
-  // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
-  // CHECK-CC1: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>)
-  // CHECK-CC1: memfun2 : [#void#][#Base3::#]memfun2(<#int#>)
+  // CHECK-CC1: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>)
+  // CHECK-CC1: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
+  // CHECK-CC1: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>)
+  // CHECK-CC1: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>)
   // CHECK-CC1: memfun3 : [#int#]memfun3(<#int#>)
 
 // Make sure this doesn't crash
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:38:7 %s -verify
 
 // Make sure this also doesn't crash
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:49:14 %s
 
public:
   void overload1(const S &);
 };
 
 template<typename T, typename S>
 void completeDependentMembers(TemplateClass<T, S> &object,
                               TemplateClass<int, S> *object2) {
   object.field;
   object2->field;
-// CHECK-CC2: baseTemplateField : [#T#][#BaseTemplate<T>::#]baseTemplateField
-// CHECK-CC2: baseTemplateFunction : [#T#][#BaseTemplate<T>::#]baseTemplateFunction()
+// CHECK-CC2: baseTemplateField (InBase) : [#T#][#BaseTemplate<T>::#]baseTemplateField
+// CHECK-CC2: baseTemplateFunction (InBase) : [#T#][#BaseTemplate<T>::#]baseTemplateFunction()
 // CHECK-CC2: field : [#T#]field
 // CHECK-CC2: function : [#T#]function()
-// CHECK-CC2: member1 : [#int#][#Base1::#]member1
-// CHECK-CC2: member2 : [#float#][#Base1::#]member2
+// CHECK-CC2: member1 (InBase) : [#int#][#Base1::#]member1
+// CHECK-CC2: member2 (InBase) : [#float#][#Base1::#]member2
 // CHECK-CC2: overload1 : [#void#]overload1(<#const T &#>)
 // CHECK-CC2: overload1 : [#void#]overload1(<#const S &#>)
 
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:94:10 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:95:12 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
 }
 
 
 void completeDependentSpecializedMembers(TemplateClass<int, double> &object,
                                          TemplateClass<int, double> *object2) {
   object.field;
   object2->field;
-// CHECK-CC3: baseTemplateField : [#int#][#BaseTemplate<int>::#]baseTemplateField
-// CHECK-CC3: baseTemplateFunction : [#int#][#BaseTemplate<int>::#]baseTemplateFunction()
+// CHECK-CC3: baseTemplateField (InBase) : [#int#][#BaseTemplate<int>::#]baseTemplateField
+// CHECK-CC3: baseTemplateFunction (InBase) : [#int#][#BaseTemplate<int>::#]baseTemplateFunction()
 // CHECK-CC3: field : [#int#]field
 // CHECK-CC3: function : [#int#]function()
-// CHECK-CC3: member1 : [#int#][#Base1::#]member1
-// CHECK-CC3: member2 : [#float#][#Base1::#]member2
+// CHECK-CC3: member1 (InBase) : [#int#][#Base1::#]member1
+// CHECK-CC3: member2 (InBase) : [#float#][#Base1::#]member2
 // CHECK-CC3: overload1 : [#void#]overload1(<#const int &#>)
 // CHECK-CC3: overload1 : [#void#]overload1(<#const double &#>)
 
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:112:10 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:113:12 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
 }
 
 template <typename T>
void test2(const Proxy2 &p) {
   p->
 }
 
 void test3(const Proxy2 &p) {
   p.
 }
 
 // RUN: %clang_cc1 -fsyntax-only -code-completion-with-fixits -code-completion-at=%s:177:6 %s -o - | FileCheck -check-prefix=CHECK-CC8 --implicit-check-not="Derived : Derived(" %s
-// CHECK-CC8: Base1 : Base1::
-// CHECK-CC8: member1 : [#int#][#Base1::#]member1
-// CHECK-CC8: member1 : [#int#][#Base2::#]member1
-// CHECK-CC8: member2 : [#float#][#Base1::#]member2
-// CHECK-CC8: member3 : [#double#][#Base2::#]member3
+// CHECK-CC8: Base1 (InBase) : Base1::
+// CHECK-CC8: member1 (InBase) : [#int#][#Base1::#]member1
+// CHECK-CC8: member1 (InBase) : [#int#][#Base2::#]member1
+// CHECK-CC8: member2 (InBase) : [#float#][#Base1::#]member2
+// CHECK-CC8: member3 (InBase) : [#double#][#Base2::#]member3
 // CHECK-CC8: member4 : [#int#]member4
 // CHECK-CC8: member5 : [#int#]member5 (requires fix-it: {177:4-177:6} to ".")
-// CHECK-CC8: memfun1 : [#void#][#Base3::#]memfun1(<#float#>)
-// CHECK-CC8: memfun1 : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
-// CHECK-CC8: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>)
-// CHECK-CC8: memfun2 : [#void#][#Base3::#]memfun2(<#int#>)
+// CHECK-CC8: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>)
+// CHECK-CC8: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
+// CHECK-CC8: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>)
+// CHECK-CC8: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>)
 // CHECK-CC8: memfun3 : [#int#]memfun3(<#int#>)
 // CHECK-CC8: operator-> : [#Derived *#]operator->()[# const#] (requires fix-it: {177:4-177:6} to ".")
 
 // RUN: %clang_cc1 -fsyntax-only -code-completion-with-fixits -code-completion-at=%s:181:6 %s -o - | FileCheck -check-prefix=CHECK-CC9 --implicit-check-not="Derived : Derived(" %s
-// CHECK-CC9: Base1 : Base1::
-// CHECK-CC9: member1 : [#int#][#Base1::#]member1 (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: member1 : [#int#][#Base2::#]member1 (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: member2 : [#float#][#Base1::#]member2 (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: member3 : [#double#][#Base2::#]member3 (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: Base1 (InBase) : Base1::
+// CHECK-CC9: member1 (InBase) : [#int#][#Base1::#]member1 (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: member1 (InBase) : [#int#][#Base2::#]member1 (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: member2 (InBase) : [#float#][#Base1::#]member2 (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: member3 (InBase) : [#double#][#Base2::#]member3 (requires fix-it: {181:4-181:5} to "->")
 // CHECK-CC9: member4 : [#int#]member4 (requires fix-it: {181:4-181:5} to "->")
 // CHECK-CC9: member5 : [#int#]member5
-// CHECK-CC9: memfun1 : [#void#][#Base3::#]memfun1(<#float#>) (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: memfun1 : [#void#][#Base3::#]memfun1(<#double#>)[# const#] (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>) (requires fix-it: {181:4-181:5} to "->")
-// CHECK-CC9: memfun2 : [#void#][#Base3::#]memfun2(<#int#>) (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>) (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#] (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>) (requires fix-it: {181:4-181:5} to "->")
+// CHECK-CC9: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>) (requires fix-it: {181:4-181:5} to "->")
 // CHECK-CC9: memfun3 : [#int#]memfun3(<#int#>) (requires fix-it: {181:4-181:5} to "->")
 // CHECK-CC9: operator-> : [#Derived *#]operator->()[# const#]

cfe/trunk/test/CodeCompletion/objc-message.mm

 void func(const RetainPtr<id <FooTestProtocol>>& ptr)
 {
   [ptr instanceMethod1];
 }
 
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -code-completion-at=%s:33:8 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
 // CHECK-CC1: categoryInstanceMethod : [#id#]categoryInstanceMethod
 // CHECK-CC1: instanceMethod1 : [#id#]instanceMethod1
-// CHECK-CC1: protocolInstanceMethod : [#id#]protocolInstanceMethod
+// CHECK-CC1: protocolInstanceMethod (InBase) : [#id#]protocolInstanceMethod
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -code-completion-at=%s:38:8 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
 // CHECK-CC2: protocolInstanceMethod : [#id#]protocolInstanceMethod