Merge pull request #11057 from benlangmuir/cc-enum-leading-dot-4

[code-completion] Add leading-dot completion for enums

Author: benlangmuir

include/swift/IDE/CodeCompletion.h

@@ -800,6 +800,10 @@ class CodeCompletionContext {
   CompletionKind CodeCompletionKind = CompletionKind::None;
   bool HasExpectedTypeRelation = false;
 
+  /// Whether there may be members that can use implicit member syntax,
+  /// e.g. `x = .foo`.
+  bool MayUseImplicitMemberExpr = false;
+
   CodeCompletionContext(CodeCompletionCache &Cache)
       : Cache(Cache) {}
 

lib/IDE/CodeCompletion.cpp

@@ -1574,6 +1574,7 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
   OwnedResolver TypeResolver;
   const DeclContext *CurrDeclContext;
   ClangImporter *Importer;
+  CodeCompletionContext *CompletionContext;
 
   enum class LookupKind {
     ValueExpr,
@@ -1719,11 +1720,13 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 public:
   CompletionLookup(CodeCompletionResultSink &Sink,
                    ASTContext &Ctx,
-                   const DeclContext *CurrDeclContext)
+                   const DeclContext *CurrDeclContext,
+                   CodeCompletionContext *CompletionContext = nullptr)
       : Sink(Sink), Ctx(Ctx),
         TypeResolver(createLazyResolver(Ctx)), CurrDeclContext(CurrDeclContext),
         Importer(static_cast<ClangImporter *>(CurrDeclContext->getASTContext().
-          getClangModuleLoader())) {
+          getClangModuleLoader())),
+        CompletionContext(CompletionContext) {
 
     // Determine if we are doing code completion inside a static method.
     if (CurrDeclContext) {
@@ -3650,6 +3653,19 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       }
     }
 
+    if (CompletionContext) {
+      // FIXME: this is an awful simplification that says all and only enums can
+      // use implicit member syntax (leading dot). Computing the accurate answer
+      // using lookup (e.g. getUnresolvedMemberCompletions) is too expensive,
+      // and for some clients this approximation is good enough.
+      CompletionContext->MayUseImplicitMemberExpr =
+          std::any_of(ExpectedTypes.begin(), ExpectedTypes.end(), [](Type T) {
+            if (auto *NTD = T->getAnyNominal())
+              return isa<EnumDecl>(NTD);
+            return false;
+          });
+    }
+
     if (LiteralCompletions)
       addValueLiteralCompletions();
 
@@ -5106,7 +5122,7 @@ void CodeCompletionCallbacksImpl::doneParsing() {
     return;
 
   CompletionLookup Lookup(CompletionContext.getResultSink(), P.Context,
-                          CurDeclContext);
+                          CurDeclContext, &CompletionContext);
   if (ExprType) {
     Lookup.setIsStaticMetatype(ParsedExpr->isStaticallyDerivedMetatype());
   }

test/SourceKit/CodeComplete/complete_inner.swift

@@ -144,3 +144,28 @@ func test006() {
 // KEYWORD_0-NOT: for_
 // KEYWORD_0-NOT: fortest
 // KEYWORD_0-NOT: for.
+
+enum E0 {
+  case case0
+}
+
+// RUN: %complete-test %s -group=none -no-inner-results -no-inner-operators -tok=LEADING_DOT_0 | %FileCheck %s -check-prefix=LEADING_NODOT_E0
+// RUN: %complete-test %s -group=none -no-inner-results -inner-operators -tok=LEADING_DOT_0 | %FileCheck %s -check-prefix=LEADING_DOT_E0
+func test007() {
+  var e: E0
+  e = #^LEADING_DOT_0^#
+}
+// LEADING_NODOT_E0-NOT: .
+// LEADING_DOT_E0: .
+
+struct WithLeading {
+  static var foo: WithLeading = WithLeading()
+}
+
+// RUN: %complete-test %s -group=none -no-inner-results -inner-operators -tok=LEADING_DOT_1 | %FileCheck %s -check-prefix=LEADING_DOT_S
+func test009() {
+  var e: WithLeading
+  e = #^LEADING_DOT_1^#
+}
+// FIXME: should have leading dot.
+// LEADING_DOT_S-NOT: .

tools/SourceKit/lib/SwiftLang/SwiftCompletion.cpp

@@ -729,6 +729,10 @@ bool CodeCompletion::SessionCache::getCompletionHasExpectedTypes() {
   llvm::sys::ScopedLock L(mtx);
   return completionHasExpectedTypes;
 }
+bool CodeCompletion::SessionCache::getCompletionMayUseImplicitMemberExpr() {
+  llvm::sys::ScopedLock L(mtx);
+  return completionMayUseImplicitMemberExpr;
+}
 const CodeCompletion::FilterRules &
 CodeCompletion::SessionCache::getFilterRules() {
   llvm::sys::ScopedLock L(mtx);
@@ -1038,6 +1042,12 @@ static void transformAndForwardResults(
   if (!hasEarlyInnerResults) {
     organizer.addCompletionsWithFilter(session->getSortedCompletions(),
                                        filterText, rules, exactMatch);
+    // Add leading dot?
+    if (options.addInnerOperators && !rules.hideFilterName(".") &&
+        session->getCompletionMayUseImplicitMemberExpr()) {
+      organizer.addCompletionsWithFilter(
+          buildDot(), filterText, CodeCompletion::FilterRules(), exactMatch);
+    }
   }
 
   if (hasEarlyInnerResults &&
@@ -1164,12 +1174,15 @@ void SwiftLangSupport::codeCompleteOpen(
 
   CompletionKind completionKind = CompletionKind::None;
   bool hasExpectedTypes = false;
+  bool mayUseImplicitMemberExpr = false;
 
   SwiftCodeCompletionConsumer swiftConsumer(
       [&](MutableArrayRef<CodeCompletionResult *> results,
           SwiftCompletionInfo &info) {
-        completionKind = info.completionContext->CodeCompletionKind;
-        hasExpectedTypes = info.completionContext->HasExpectedTypeRelation;
+        auto &completionCtx = *info.completionContext;
+        completionKind = completionCtx.CodeCompletionKind;
+        hasExpectedTypes = completionCtx.HasExpectedTypeRelation;
+        mayUseImplicitMemberExpr = completionCtx.MayUseImplicitMemberExpr;
         completions =
             extendCompletions(results, sink, info, nameToPopularity, CCOpts);
       });
@@ -1203,7 +1216,8 @@ void SwiftLangSupport::codeCompleteOpen(
   std::vector<std::string> argsCopy(extendedArgs.begin(), extendedArgs.end());
   SessionCacheRef session{new SessionCache(
       std::move(sink), std::move(bufferCopy), std::move(argsCopy),
-      completionKind, hasExpectedTypes, std::move(filterRules))};
+      completionKind, hasExpectedTypes, mayUseImplicitMemberExpr,
+      std::move(filterRules))};
   session->setSortedCompletions(std::move(completions));
 
   if (!CCSessions.set(name, offset, session)) {

tools/SourceKit/lib/SwiftLang/SwiftLangSupport.h

@@ -141,17 +141,20 @@ class SessionCache : public ThreadSafeRefCountedBase<SessionCache> {
   std::vector<Completion *> sortedCompletions;
   CompletionKind completionKind;
   bool completionHasExpectedTypes;
+  bool completionMayUseImplicitMemberExpr;
   FilterRules filterRules;
   llvm::sys::Mutex mtx;
 
 public:
   SessionCache(CompletionSink &&sink,
                std::unique_ptr<llvm::MemoryBuffer> &&buffer,
                std::vector<std::string> &&args, CompletionKind completionKind,
-               bool hasExpectedTypes, FilterRules filterRules)
+               bool hasExpectedTypes, bool mayUseImplicitMemberExpr,
+               FilterRules filterRules)
       : buffer(std::move(buffer)), args(std::move(args)), sink(std::move(sink)),
         completionKind(completionKind),
         completionHasExpectedTypes(hasExpectedTypes),
+        completionMayUseImplicitMemberExpr(mayUseImplicitMemberExpr),
         filterRules(std::move(filterRules)) {}
   void setSortedCompletions(std::vector<Completion *> &&completions);
   ArrayRef<Completion *> getSortedCompletions();
@@ -160,6 +163,7 @@ class SessionCache : public ThreadSafeRefCountedBase<SessionCache> {
   const FilterRules &getFilterRules();
   CompletionKind getCompletionKind();
   bool getCompletionHasExpectedTypes();
+  bool getCompletionMayUseImplicitMemberExpr();
 };
 typedef RefPtr<SessionCache> SessionCacheRef;