[WIP][Sema][CodeCompletion] Add base type for double colon member completion results

Frontend/ASTUnit.cpp

static void CalculateHiddenNames(const CodeCompletionContext &Context,
   case CodeCompletionContext::CCC_ObjCImplementation:
   case CodeCompletionContext::CCC_ObjCIvarList:
   case CodeCompletionContext::CCC_ClassStructUnion:
   case CodeCompletionContext::CCC_Statement:
   case CodeCompletionContext::CCC_Expression:
   case CodeCompletionContext::CCC_ObjCMessageReceiver:
   case CodeCompletionContext::CCC_DotMemberAccess:
   case CodeCompletionContext::CCC_ArrowMemberAccess:
+  case CodeCompletionContext::CCC_ClassOrStructScope:
   case CodeCompletionContext::CCC_ObjCPropertyAccess:
   case CodeCompletionContext::CCC_Namespace:
   case CodeCompletionContext::CCC_Type:
   case CodeCompletionContext::CCC_Name:
   case CodeCompletionContext::CCC_PotentiallyQualifiedName:
   case CodeCompletionContext::CCC_ParenthesizedExpression:
   case CodeCompletionContext::CCC_ObjCInterfaceName:
     break;

Sema/CodeCompleteConsumer.cpp

 
 bool CodeCompletionContext::wantConstructorResults() const {
   switch (CCKind) {
   case CCC_Recovery:
   case CCC_Statement:
   case CCC_Expression:
   case CCC_ObjCMessageReceiver:
   case CCC_ParenthesizedExpression:
+  case CCC_ClassOrStructScope:
     return true;
 
   case CCC_TopLevel:
   case CCC_ObjCInterface:
   case CCC_ObjCImplementation:
   case CCC_ObjCIvarList:
   case CCC_ClassStructUnion:
   case CCC_DotMemberAccess:
StringRef clang::getCompletionKindString(CodeCompletionContext::Kind Kind) {
   case CCKind::CCC_ObjCInterfaceName:
     return "ObjCInterfaceName";
   case CCKind::CCC_ObjCCategoryName:
     return "ObjCCategoryName";
   case CCKind::CCC_IncludedFile:
     return "IncludedFile";
   case CCKind::CCC_Recovery:
     return "Recovery";
+  case CCKind::CCC_ClassOrStructScope:
+    return "ClassOrStructScope";
   }
   llvm_unreachable("Invalid CodeCompletionContext::Kind!");
 }
 
 //===----------------------------------------------------------------------===//
 // Code completion string implementation
 //===----------------------------------------------------------------------===//
 

Sema/SemaCodeComplete.cpp

void Sema::CodeCompleteQualifiedId(Scope *S, CXXScopeSpec &SS,
   if (!Ctx)
     return;
 
   // Try to instantiate any non-dependent declaration contexts before
   // we look in them.
   if (!isDependentScopeSpecifier(SS) && RequireCompleteDeclContext(SS, Ctx))
     return;
 
+  CodeCompletionContext CCContext = [&]() {
+    if (SS.getScopeRep() &&
+        (SS.getScopeRep()->getKind() == NestedNameSpecifier::TypeSpec ||
+         SS.getScopeRep()->getKind() ==
+             NestedNameSpecifier::TypeSpecWithTemplate) &&
+        SS.getScopeRep()->getAsType()) {
+      QualType BaseType = QualType(SS.getScopeRep()->getAsType(), 0);
+      return CodeCompletionContext(
+          CodeCompletionContext::CCC_ClassOrStructScope, BaseType);
+    }
+
+    return CodeCompletionContext(CodeCompletionContext::CCC_Name);
+  }();
+
   ResultBuilder Results(*this, CodeCompleter->getAllocator(),
-                        CodeCompleter->getCodeCompletionTUInfo(),
-                        CodeCompletionContext::CCC_Name);
+                        CodeCompleter->getCodeCompletionTUInfo(), CCContext);
   Results.EnterNewScope();
 
   // The "template" keyword can follow "::" in the grammar, but only
   // put it into the grammar if the nested-name-specifier is dependent.
   NestedNameSpecifier *NNS = SS.getScopeRep();
   if (!Results.empty() && NNS->isDependent())
     Results.AddResult("template");
 

clang/Sema/CodeCompleteConsumer.h

enum Kind {
     /// Code completion occurred on the right-hand side of a member
     /// access expression using the arrow operator.
     ///
     /// The results of this completion are the members of the type being
     /// accessed. The type itself is available via
     /// \c CodeCompletionContext::getType().
     CCC_ArrowMemberAccess,
 
+    /// Code completion occurred on the right-hand side of a class or struct
+    /// name followed by double colon.
+    ///
+    /// The results of this completion are the members of the type being
+    /// accessed. The type itself is available via
+    /// \c CodeCompletionContext::getType().
+    CCC_ClassOrStructScope,
+
     /// Code completion occurred on the right-hand side of an Objective-C
     /// property access expression.
     ///
     /// The results of this completion are the members of the type being
     /// accessed. The type itself is available via
     /// \c CodeCompletionContext::getType().
     CCC_ObjCPropertyAccess,
 
public:
   CodeCompletionContext(Kind CCKind) : CCKind(CCKind), SelIdents(None) {}
 
   /// Construct a new code-completion context of the given kind.
   CodeCompletionContext(Kind CCKind, QualType T,
                         ArrayRef<IdentifierInfo *> SelIdents = None)
       : CCKind(CCKind), SelIdents(SelIdents) {
     if (CCKind == CCC_DotMemberAccess || CCKind == CCC_ArrowMemberAccess ||
         CCKind == CCC_ObjCPropertyAccess || CCKind == CCC_ObjCClassMessage ||
-        CCKind == CCC_ObjCInstanceMessage)
+        CCKind == CCC_ObjCInstanceMessage || CCKind == CCC_ClassOrStructScope)
       BaseType = T;
     else
       PreferredType = T;
   }
 
   /// Retrieve the kind of code-completion context.
   Kind getKind() const { return CCKind; }
 

libclang/CIndexCodeCompletion.cpp

switch (kind) {
     }
     case CodeCompletionContext::CCC_Other:
     case CodeCompletionContext::CCC_ObjCInterface:
     case CodeCompletionContext::CCC_ObjCImplementation:
     case CodeCompletionContext::CCC_Name:
     case CodeCompletionContext::CCC_MacroName:
     case CodeCompletionContext::CCC_PreprocessorExpression:
     case CodeCompletionContext::CCC_PreprocessorDirective:
-    case CodeCompletionContext::CCC_TypeQualifiers: {
+    case CodeCompletionContext::CCC_TypeQualifiers:
+    case CodeCompletionContext::CCC_ClassOrStructScope: {
       //Only Clang results should be accepted, so we'll set all of the other
       //context bits to 0 (i.e. the empty set)
       contexts = CXCompletionContext_Unexposed;
       break;
     }
     case CodeCompletionContext::CCC_Recovery: {
       //We don't know what the current context is, so we'll return unknown
       //This is the equivalent of setting all of the other context bits