Merge pull request #33475 from rintaro/ide-completion-inactiveifconfig-rdar67027408

[CodeCompletion] Parse #if block containing CC token as active

Author: rintaro

include/swift/AST/NameLookup.h

@@ -741,8 +741,6 @@ class ASTScope {
     return Mem;
   }
 
-  static bool areInactiveIfConfigClausesSupported();
-
 private:
   static ast_scope::ASTSourceFileScope *createScopeTree(SourceFile *);
 

lib/AST/ASTScopeCreation.cpp

@@ -479,23 +479,6 @@ class ScopeCreator final {
   }
 
 public:
-  /// When ASTScopes are enabled for code completion,
-  /// IfConfigs will pose a challenge because we may need to field lookups into
-  /// the inactive clauses, but the AST contains redundancy: the active clause's
-  /// elements are present in the members or elements of an IterableTypeDecl or
-  /// BraceStmt alongside of the IfConfigDecl. In addition there are two more
-  /// complications:
-  ///
-  /// 1. The active clause's elements may be nested inside an init self
-  /// rebinding decl (as in StringObject.self).
-  ///
-  /// 2. The active clause may be before or after the inactive ones
-  ///
-  /// So, when encountering an IfConfigDecl, we will expand  the inactive
-  /// elements. Also, always sort members or elements so that the child scopes
-  /// are in source order (Just one of several reasons we need to sort.)
-  ///
-  static const bool includeInactiveIfConfigClauses = false;
 
 private:
   static std::vector<ASTNode> expandIfConfigClauses(ArrayRef<ASTNode> input) {
@@ -526,9 +509,6 @@ class ScopeCreator final {
               if (isa<IfConfigDecl>(d))
                 expandIfConfigClausesInto(expansion, {d}, true);
           }
-        } else if (includeInactiveIfConfigClauses) {
-          expandIfConfigClausesInto(expansion, clause.Elements,
-                                    /*isInAnActiveNode=*/false);
         }
       }
     }
@@ -762,10 +742,6 @@ void ASTScope::
   impl->buildEnoughOfTreeForTopLevelExpressionsButDontRequestGenericsOrExtendedNominals();
 }
 
-bool ASTScope::areInactiveIfConfigClausesSupported() {
-  return ScopeCreator::includeInactiveIfConfigClauses;
-}
-
 void ASTScope::expandFunctionBody(AbstractFunctionDecl *AFD) {
   auto *const SF = AFD->getParentSourceFile();
   SF->getScope().expandFunctionBodyImpl(AFD);
@@ -2083,10 +2059,8 @@ class LocalizableDeclContextCollector : public ASTWalker {
     //    catchForDebugging(D, "DictionaryBridging.swift", 694);
     if (const auto *dc = dyn_cast<DeclContext>(D))
       record(dc);
-    if (auto *icd = dyn_cast<IfConfigDecl>(D)) {
-      walkToClauses(icd);
+    if (isa<IfConfigDecl>(D))
       return false;
-    }
     if (auto *pd = dyn_cast<ParamDecl>(D))
       record(pd->getDefaultArgumentInitContext());
     else if (auto *pbd = dyn_cast<PatternBindingDecl>(D))
@@ -2104,18 +2078,6 @@ class LocalizableDeclContextCollector : public ASTWalker {
   }
 
 private:
-  void walkToClauses(IfConfigDecl *icd) {
-    for (auto &clause : icd->getClauses()) {
-      // Generate scopes for any closures in the condition
-      if (ScopeCreator::includeInactiveIfConfigClauses && clause.isActive) {
-        if (clause.Cond)
-          clause.Cond->walk(*this);
-        for (auto n : clause.Elements)
-          n.walk(*this);
-      }
-    }
-  }
-
   void recordInitializers(PatternBindingDecl *pbd) {
     for (auto idx : range(pbd->getNumPatternEntries()))
       record(pbd->getInitContext(idx));

lib/IDE/CompletionInstance.cpp

@@ -85,8 +85,6 @@ template <typename Range> Decl *getElementAt(const Range &Decls, unsigned N) {
 /// Find the equivalent \c DeclContext with \p DC from \p SF AST.
 /// This assumes the AST which contains \p DC has exact the same structure with
 /// \p SF.
-/// FIXME: This doesn't support IfConfigDecl blocks. If \p DC is in an inactive
-///        config block, this function returns \c false.
 static DeclContext *getEquivalentDeclContextFromSourceFile(DeclContext *DC,
                                                            SourceFile *SF) {
   PrettyStackTraceDeclContext trace("getting equivalent decl context for", DC);
@@ -129,7 +127,6 @@ static DeclContext *getEquivalentDeclContextFromSourceFile(DeclContext *DC,
     }
 
     // Not found in the decl context tree.
-    // FIXME: Probably DC is in an inactive #if block.
     if (N == ~0U) {
       return nullptr;
     }

lib/Parse/ParseIfConfig.cpp

@@ -603,17 +603,42 @@ static Expr *findAnyLikelySimulatorEnvironmentTest(Expr *Condition) {
 /// Delegate callback function to parse elements in the blocks.
 ParserResult<IfConfigDecl> Parser::parseIfConfig(
     llvm::function_ref<void(SmallVectorImpl<ASTNode> &, bool)> parseElements) {
+  assert(Tok.is(tok::pound_if));
   SyntaxParsingContext IfConfigCtx(SyntaxContext, SyntaxKind::IfConfigDecl);
 
   SmallVector<IfConfigClause, 4> Clauses;
   Parser::StructureMarkerRAII ParsingDecl(
       *this, Tok.getLoc(), Parser::StructureMarkerKind::IfConfig);
 
+  // Find the region containing code completion token.
+  SourceLoc codeCompletionClauseLoc;
+  if (SourceMgr.hasCodeCompletionBuffer() &&
+      SourceMgr.getCodeCompletionBufferID() == L->getBufferID() &&
+      SourceMgr.isBeforeInBuffer(Tok.getLoc(),
+                                 SourceMgr.getCodeCompletionLoc())) {
+    llvm::SaveAndRestore<Optional<llvm::MD5>> H(CurrentTokenHash, None);
+    BacktrackingScope backtrack(*this);
+    do {
+      auto startLoc = Tok.getLoc();
+      consumeToken();
+      skipUntilConditionalBlockClose();
+      auto endLoc = PreviousLoc;
+      if (SourceMgr.rangeContainsTokenLoc(SourceRange(startLoc, endLoc),
+                                          SourceMgr.getCodeCompletionLoc())){
+        codeCompletionClauseLoc = startLoc;
+        break;
+      }
+    } while (Tok.isNot(tok::pound_endif, tok::eof));
+  }
+
   bool shouldEvaluate =
       // Don't evaluate if it's in '-parse' mode, etc.
       shouldEvaluatePoundIfDecls() &&
       // If it's in inactive #if ... #endif block, there's no point to do it.
-      !getScopeInfo().isInactiveConfigBlock();
+      !getScopeInfo().isInactiveConfigBlock() &&
+      // If this directive contains code completion location, 'isActive' is
+      // determined solely by which block has the completion token.
+      !codeCompletionClauseLoc.isValid();
 
   bool foundActive = false;
   bool isVersionCondition = false;
@@ -658,6 +683,10 @@ ParserResult<IfConfigDecl> Parser::parseIfConfig(
       }
     }
 
+    // Treat the region containing code completion token as "active".
+    if (codeCompletionClauseLoc.isValid() && !foundActive)
+      isActive = (ClauseLoc == codeCompletionClauseLoc);
+
     foundActive |= isActive;
 
     if (!Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) {

lib/Parse/Parser.cpp

@@ -695,8 +695,9 @@ void Parser::skipSingle() {
 void Parser::skipUntil(tok T1, tok T2) {
   // tok::NUM_TOKENS is a sentinel that means "don't skip".
   if (T1 == tok::NUM_TOKENS && T2 == tok::NUM_TOKENS) return;
-  
-  while (Tok.isNot(T1, T2, tok::eof, tok::pound_endif, tok::code_complete))
+
+  while (Tok.isNot(T1, T2, tok::eof, tok::pound_endif, tok::pound_else,
+                   tok::pound_elseif))
     skipSingle();
 }
 

test/IDE/complete_in_ifconfig.swift

@@ -0,0 +1,75 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+struct MyStruct {
+    init() {}
+    var value: Int
+}
+
+// MEMBER_MyStruct: Begin completions, 2 items
+// MEMBER_MyStruct-DAG: Keyword[self]/CurrNominal:          self[#MyStruct#];
+// MEMBER_MyStruct-DAG: Decl[InstanceVar]/CurrNominal:      value[#Int#];
+// MEMBER_MyStruct: End completions
+
+#if true
+let toplevelActive = MyStruct()
+_ = toplevelActive.#^MEMBER_TOPLEVEL_ACTIVE?check=MEMBER_MyStruct^#
+#else
+let toplevelInactive = MyStruct()
+_ = toplevelInactive.#^MEMBER_TOPLEVEL_INACTIVE?check=MEMBER_MyStruct^#
+#endif
+
+func foo() {
+#if true
+  let infuncActive = MyStruct()
+  _ = infuncActive.#^MEMBER_INFUNC_ACTIVE?check=MEMBER_MyStruct^#
+#else
+  let infuncInactive = MyStruct()
+  _ = infuncInactive.#^MEMBER_INFUNC_INACTIVE?check=MEMBER_MyStruct^#
+#endif
+}
+
+protocol TestP {
+  func foo()
+  func bar()
+}
+struct TestStruct: TestP {
+#if true
+  func foo() {}
+  func #^OVERRIDE_ACTIVE^#
+// OVERRIDE_ACTIVE: Begin completions, 1 items
+// OVERRIDE_ACTIVE-DAG: Decl[InstanceMethod]/Super:         bar() {|};
+// OVERRIDE_ACTIVE: End completions
+#else
+  func bar() {}
+  func #^OVERRIDE_INACTIVE^#
+// OVERRIDE_INACTIVE: Begin completions, 1 items
+// OVERRIDE_INACTIVE-DAG: Decl[InstanceMethod]/Super:         foo() {|};
+// OVERRIDE_INACTIVE: End completions
+#endif
+}
+
+struct TestStruct2 {
+#if true
+  func activeFunc() {}
+  func test() {
+    self.#^SELF_ACTIVE^#
+  }
+// SELF_ACTIVE: Begin completions, 3 items
+// SELF_ACTIVE-DAG: Keyword[self]/CurrNominal:          self[#TestStruct2#];
+// SELF_ACTIVE-DAG: Decl[InstanceMethod]/CurrNominal:   activeFunc()[#Void#];
+// SELF_ACTIVE-DAG: Decl[InstanceMethod]/CurrNominal:   test()[#Void#];
+// SELF_ACTIVE: End completions
+#else
+  func inactiveFunc() {}
+  func test() {
+    self.#^SELF_INACTIVE^#
+  }
+// SELF_INACTIVE: Begin completions, 3 items
+// SELF_INACTIVE-DAG: Keyword[self]/CurrNominal:          self[#TestStruct2#];
+// SELF_INACTIVE-DAG: Decl[InstanceMethod]/CurrNominal:   inactiveFunc()[#Void#];
+// SELF_INACTIVE-DAG: Decl[InstanceMethod]/CurrNominal:   test()[#Void#];
+// SELF_INACTIVE: End completions
+#endif
+}
+

test/SourceKit/CodeComplete/complete_sequence_in_ifconfig.swift

@@ -0,0 +1,54 @@
+struct MyStruct {
+    init() {}
+    var value: Int = 1
+}
+
+func foo(arg: MyStruct) {
+  #if true
+  _ = arg./*8:11*/
+  #else
+  _ = arg./*10:11*/
+  #endif
+}
+
+struct TestStruct {
+  #if true
+  func testActive(arg: MyStruct) {
+    _ = arg./*17:13*/
+  }
+  #else
+  func testInactive(arg: MyStruct) {
+    _ = arg./*21:13*/
+  }
+  #endif
+}
+
+// Test that (1) fast completion happens even in inactive #if blocks, and
+// (2) #if in toplevel decls invalidate cached ASTContext
+
+// RUN: %sourcekitd-test \
+// RUN:   -req=complete -pos=8:11 %s -- %s -parse-as-library == \
+// RUN:   -req=complete -pos=10:11 %s -- %s -parse-as-library == \
+// RUN:   -req=complete -pos=17:13 %s -- %s -parse-as-library == \
+// RUN:   -req=complete -pos=21:13 %s -- %s -parse-as-library \
+// RUN:   | %FileCheck %s --check-prefix=RESULT
+
+// RESULT-LABEL: key.results: [
+// RESULT-DAG: key.description: "value"
+// RESULT: ]
+// RESULT-NOT: key.reusingastcontext: 1
+
+// RESULT-LABEL: key.results: [
+// RESULT-DAG: key.description: "value"
+// RESULT: ]
+// RESULT: key.reusingastcontext: 1
+
+// RESULT-LABEL: key.results: [
+// RESULT-DAG: key.description: "value"
+// RESULT: ]
+// RESULT: key.reusingastcontext: 1
+
+// RESULT-LABEL: key.results: [
+// RESULT-DAG: key.description: "value"
+// RESULT: ]
+// RESULT-NOT: key.reusingastcontext: 1