[Sema] Expose current scope in qualified-id code completion.

[hokein]

This is not needed now, we decide to keep lookup logic in Sema instead of clangd side.

include/clang/Sema/CodeCompleteConsumer.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Allocator.h"
 #include <string>
 #include <utility>
 
 namespace clang {
 
 class Decl;
+class Scope;
 
 /// \brief Default priority values for code-completion results based
 /// on their kind.
 enum {
   /// \brief Priority for the next initialization in a constructor initializer
   /// list.
   CCP_NextInitializer = 7,
   /// \brief Priority for an enumeration constant inside a switch whose
enum Kind {
     CCC_ObjCInterfaceName,
     /// \brief Code completion where an Objective-C category name is expected.
     CCC_ObjCCategoryName,
     /// \brief An unknown context, in which we are recovering from a parsing
     /// error and don't know which completions we should give.
     CCC_Recovery
   };
 
+  struct QualifiedCompletionContext {
+    /// \brief The scope specifier that comes before the completion token e.g.
+    /// "a::b::"
+    CXXScopeSpec ScopeSpecifier;
+    /// \brief The closest scope where the qualified code completion occurs.
+    Scope *ClosestScope;
+  };
+
 private:
   enum Kind Kind;
 
   /// \brief The type that would prefer to see at this point (e.g., the type
   /// of an initializer or function parameter).
   QualType PreferredType;
 
   /// \brief The type of the base object in a member access expression.
   QualType BaseType;
 
   /// \brief The identifiers for Objective-C selector parts.
   ArrayRef<IdentifierInfo *> SelIdents;
 
-  /// \brief The scope specifier that comes before the completion token e.g.
-  /// "a::b::"
-  llvm::Optional<CXXScopeSpec> ScopeSpecifier;
+  /// \brief The context for qualified-id completion, containing information
+  /// about the scope specifier.
+  llvm::Optional<QualifiedCompletionContext> QualifiedCC;
 
 public:
   /// \brief Construct a new code-completion context of the given kind.
   CodeCompletionContext(enum Kind Kind) : Kind(Kind), SelIdents(None) { }
 
   /// \brief Construct a new code-completion context of the given kind.
   CodeCompletionContext(enum Kind Kind, QualType T,
                         ArrayRef<IdentifierInfo *> SelIdents = None)
public:
 
   /// \brief Retrieve the Objective-C selector identifiers.
   ArrayRef<IdentifierInfo *> getSelIdents() const { return SelIdents; }
 
   /// \brief Determines whether we want C++ constructors as results within this
   /// context.
   bool wantConstructorResults() const;
 
-  /// \brief Sets the scope specifier that comes before the completion token.
-  /// This is expected to be set in code completions on qualfied specifiers
+  /// \brief Sets the qualified context.
+  /// This is expected to be set in code completions on qualified specifiers
   /// (e.g. "a::b::").
-  void setCXXScopeSpecifier(CXXScopeSpec SS) {
-    this->ScopeSpecifier = std::move(SS);
+  void setQualifiedCompletionContext(QualifiedCompletionContext QCC) {
+    this->QualifiedCC = std::move(QCC);
   }
 
-  llvm::Optional<const CXXScopeSpec *> getCXXScopeSpecifier() {
-    if (ScopeSpecifier)
-      return ScopeSpecifier.getPointer();
+  llvm::Optional<const QualifiedCompletionContext *>
+  getQualifiedCompletionContext() const {
+    if (QualifiedCC)
+      return QualifiedCC.getPointer();
     return llvm::None;
   }
 };
 
 /// \brief A "string" used to describe how code completion can
 /// be performed for an entity.
 ///
 /// A code completion string typically shows how a particular entity can be

lib/Sema/SemaCodeComplete.cpp

if (SS.isEmpty() || !CodeCompleter)
     return;
 
   // We want to keep the scope specifier even if it's invalid (e.g. the scope
   // "a::b::" is not corresponding to any context/namespace in the AST), since
   // it can be useful for global code completion which have information about
   // contexts/symbols that are not in the AST.
   if (SS.isInvalid()) {
     CodeCompletionContext CC(CodeCompletionContext::CCC_Name);
-    CC.setCXXScopeSpecifier(SS);
+    CC.setQualifiedCompletionContext({SS, S});
     HandleCodeCompleteResults(this, CodeCompleter, CC, nullptr, 0);
     return;
   }
   // Always pretend to enter a context to ensure that a dependent type
   // resolves to a dependent record.
   DeclContext *Ctx = computeDeclContext(SS, /*EnteringContext=*/true);
   if (!Ctx)
     return;
if (CodeCompleter->includeNamespaceLevelDecls() ||
     CodeCompletionDeclConsumer Consumer(Results, CurContext);
     LookupVisibleDecls(Ctx, LookupOrdinaryName, Consumer,
                        /*IncludeGlobalScope=*/true,
                        /*IncludeDependentBases=*/true,
                        CodeCompleter->loadExternal());
   }
 
   auto CC = Results.getCompletionContext();
-  CC.setCXXScopeSpecifier(SS);
+  CC.setQualifiedCompletionContext({SS, S});
 
   HandleCodeCompleteResults(this, CodeCompleter, CC, Results.data(),
                             Results.size());
 }
 
 void Sema::CodeCompleteUsing(Scope *S) {
   if (!CodeCompleter)
     return;