[code-completion] Add type context for single-expression closures

benlangmuir · benlangmuir · commit b817cbb9bcbe · 2019-03-18T17:04:33.000-07:00
When completing in the only expression of closure, use the return type
of the closure as the type context for the code-completion. However,
since code-completion may be on an incomplete input, we only use the
return type to improve the quality of the result, not to mark it
invalid, since (a) we may add another statement afterwards, or (b) if
the context type is Void it doesn't need to match the value.
diff --git a/include/swift/Parse/CodeCompletionCallbacks.h b/include/swift/Parse/CodeCompletionCallbacks.h
@@ -123,7 +123,7 @@ class CodeCompletionCallbacks {
   virtual void completeDotExpr(Expr *E, SourceLoc DotLoc) {};
 
   /// Complete the beginning of a statement or expression.
-  virtual void completeStmtOrExpr() {};
+  virtual void completeStmtOrExpr(CodeCompletionExpr *E) {};
 
   /// Complete the beginning of expr-postfix -- no tokens provided
   /// by user.
diff --git a/lib/IDE/CodeCompletion.cpp b/lib/IDE/CodeCompletion.cpp
diff --git a/lib/IDE/CodeCompletionResultBuilder.h b/lib/IDE/CodeCompletionResultBuilder.h
@@ -31,6 +31,8 @@ class ModuleDecl;
 
 namespace ide {
 
+struct ExpectedTypeContext;
+
 class CodeCompletionResultBuilder {
   CodeCompletionResultSink &Sink;
   CodeCompletionResult::ResultKind Kind;
@@ -43,7 +45,7 @@ class CodeCompletionResultBuilder {
   SmallVector<CodeCompletionString::Chunk, 4> Chunks;
   llvm::PointerUnion<const ModuleDecl *, const clang::Module *>
       CurrentModule;
-  ArrayRef<Type> ExpectedDeclTypes;
+  const ExpectedTypeContext &declTypeContext;
   CodeCompletionResult::ExpectedTypeRelation ExpectedTypeRelation =
       CodeCompletionResult::Unrelated;
   bool Cancelled = false;
@@ -78,9 +80,9 @@ class CodeCompletionResultBuilder {
   CodeCompletionResultBuilder(CodeCompletionResultSink &Sink,
                               CodeCompletionResult::ResultKind Kind,
                               SemanticContextKind SemanticContext,
-                              ArrayRef<Type> ExpectedDeclTypes)
+                              const ExpectedTypeContext &declTypeContext)
       : Sink(Sink), Kind(Kind), SemanticContext(SemanticContext),
-        ExpectedDeclTypes(ExpectedDeclTypes) {}
+        declTypeContext(declTypeContext) {}
 
   ~CodeCompletionResultBuilder() {
     finishResult();
diff --git a/lib/IDE/ExprContextAnalysis.cpp b/lib/IDE/ExprContextAnalysis.cpp
@@ -510,6 +510,7 @@ class ExprContextAnalyzer {
   SmallVectorImpl<Type> &PossibleTypes;
   SmallVectorImpl<StringRef> &PossibleNames;
   SmallVectorImpl<FunctionTypeAndDecl> &PossibleCallees;
+  bool &singleExpressionBody;
 
   void recordPossibleType(Type ty) {
     if (!ty || ty->is<ErrorType>())
@@ -616,6 +617,13 @@ class ExprContextAnalyzer {
       }
       break;
     }
+    case ExprKind::Closure: {
+      auto *CE = cast<ClosureExpr>(Parent);
+      assert(isSingleExpressionBodyForCodeCompletion(CE->getBody()));
+      singleExpressionBody = true;
+      recordPossibleType(getReturnTypeFromContext(CE));
+      break;
+    }
     default:
       llvm_unreachable("Unhandled expression kind.");
     }
@@ -705,14 +713,28 @@ class ExprContextAnalyzer {
     }
   }
 
+  static bool isSingleExpressionBodyForCodeCompletion(BraceStmt *body) {
+    switch (body->getNumElements()) {
+    case 0:
+      // Nothing in the body except the code-completion token.
+      return true;
+    case 1:
+      return body->getElements()[0].is<Expr *>();
+    default:
+      return false;
+    }
+  }
+
 public:
   ExprContextAnalyzer(DeclContext *DC, Expr *ParsedExpr,
                       SmallVectorImpl<Type> &PossibleTypes,
                       SmallVectorImpl<StringRef> &PossibleNames,
-                      SmallVectorImpl<FunctionTypeAndDecl> &PossibleCallees)
+                      SmallVectorImpl<FunctionTypeAndDecl> &PossibleCallees,
+                      bool &singleExpressionBody)
       : DC(DC), ParsedExpr(ParsedExpr), SM(DC->getASTContext().SourceMgr),
         Context(DC->getASTContext()), PossibleTypes(PossibleTypes),
-        PossibleNames(PossibleNames), PossibleCallees(PossibleCallees) {}
+        PossibleNames(PossibleNames), PossibleCallees(PossibleCallees),
+        singleExpressionBody(singleExpressionBody) {}
 
   void Analyze() {
     // We cannot analyze without target.
@@ -735,6 +757,15 @@ class ExprContextAnalyzer {
                  (!isa<CallExpr>(ParentE) && !isa<SubscriptExpr>(ParentE) &&
                   !isa<BinaryExpr>(ParentE) && !isa<TupleShuffleExpr>(ParentE));
         }
+        case ExprKind::Closure: {
+          // Note: we cannot use hasSingleExpressionBody, because we explicitly
+          // do not use the single-expression-body when there is code-completion
+          // in the expression in order to avoid a base expression affecting
+          // the type. However, now that we've typechecked, we will take the
+          // context type into account.
+          return isSingleExpressionBodyForCodeCompletion(
+              cast<ClosureExpr>(E)->getBody());
+        }
         default:
           return false;
         }
@@ -793,6 +824,6 @@ class ExprContextAnalyzer {
 
 ExprContextInfo::ExprContextInfo(DeclContext *DC, Expr *TargetExpr) {
   ExprContextAnalyzer Analyzer(DC, TargetExpr, PossibleTypes, PossibleNames,
-                               PossibleCallees);
+                               PossibleCallees, singleExpressionBody);
   Analyzer.Analyze();
 }
diff --git a/lib/IDE/ExprContextAnalysis.h b/lib/IDE/ExprContextAnalysis.h
@@ -50,13 +50,21 @@ class ExprContextInfo {
   SmallVector<Type, 2> PossibleTypes;
   SmallVector<StringRef, 2> PossibleNames;
   SmallVector<FunctionTypeAndDecl, 2> PossibleCallees;
+  bool singleExpressionBody = false;
 
 public:
   ExprContextInfo(DeclContext *DC, Expr *TargetExpr);
 
   // Returns a list of possible context types.
   ArrayRef<Type> getPossibleTypes() const { return PossibleTypes; }
 
+  /// Whether the type context comes from a single-expression body, e.g.
+  /// `foo({ here })`.
+  ///
+  /// If the input may be incomplete, such as in code-completion, take into
+  /// account that the types returned by `getPossibleTypes()` are only a hint.
+  bool isSingleExpressionBody() const { return singleExpressionBody; }
+
   // Returns a list of possible argument label names.
   // Valid only if \c getKind() is \c CallArgument.
   ArrayRef<StringRef> getPossibleNames() const { return PossibleNames; }
diff --git a/lib/Parse/ParseStmt.cpp b/lib/Parse/ParseStmt.cpp
@@ -141,8 +141,10 @@ ParserStatus Parser::parseExprOrStmt(ASTNode &Result) {
     CodeCompletion->setExprBeginning(getParserPosition());
 
   if (Tok.is(tok::code_complete)) {
+    auto *CCE = new (Context) CodeCompletionExpr(Tok.getLoc());
+    Result = CCE;
     if (CodeCompletion)
-      CodeCompletion->completeStmtOrExpr();
+      CodeCompletion->completeStmtOrExpr(CCE);
     SyntaxParsingContext ErrorCtxt(SyntaxContext, SyntaxContextKind::Stmt);
     consumeToken(tok::code_complete);
     return makeParserCodeCompletionStatus();
diff --git a/test/IDE/complete_at_top_level.swift b/test/IDE/complete_at_top_level.swift
@@ -298,7 +298,7 @@ _ = {
 }()
 // TOP_LEVEL_CLOSURE_1: Begin completions
 // TOP_LEVEL_CLOSURE_1-DAG: Decl[Struct]/CurrModule: FooStruct[#FooStruct#]{{; name=.+$}}
-// TOP_LEVEL_CLOSURE_1-DAG: Decl[FreeFunction]/CurrModule: fooFunc1()[#Void#]{{; name=.+$}}
+// TOP_LEVEL_CLOSURE_1-DAG: Decl[FreeFunction]/CurrModule/TypeRelation[Identical]: fooFunc1()[#Void#]{{; name=.+$}}
 // TOP_LEVEL_CLOSURE_1-DAG: Decl[GlobalVar]/Local: fooObject[#FooStruct#]{{; name=.+$}}
 // TOP_LEVEL_CLOSURE_1: End completions
 
diff --git a/test/IDE/complete_in_closures.swift b/test/IDE/complete_in_closures.swift
@@ -70,7 +70,7 @@ struct FooStruct {
 // FOO_OBJECT_DOT: Begin completions
 // FOO_OBJECT_DOT-NEXT: Keyword[self]/CurrNominal: self[#FooStruct#]; name=self
 // FOO_OBJECT_DOT-NEXT: Decl[InstanceVar]/CurrNominal:    instanceVar[#Int#]{{; name=.+$}}
-// FOO_OBJECT_DOT-NEXT: Decl[InstanceMethod]/CurrNominal: instanceFunc0()[#Void#]{{; name=.+$}}
+// FOO_OBJECT_DOT-NEXT: Decl[InstanceMethod]/CurrNominal{{(/TypeRelation\[Identical\])?}}: instanceFunc0()[#Void#]{{; name=.+$}}
 // FOO_OBJECT_DOT-NEXT: End completions
 
 // WITH_GLOBAL_DECLS: Begin completions
diff --git a/test/IDE/complete_single_expression_return.swift b/test/IDE/complete_single_expression_return.swift
@@ -0,0 +1,137 @@
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureRet | %FileCheck %s -check-prefix=TestSingleExprClosureRet
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureRetVoid | %FileCheck %s -check-prefix=TestSingleExprClosureRetVoid
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureRetUnresolved | %FileCheck %s -check-prefix=TestSingleExprClosureRetUnresolved
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosure | %FileCheck %s -check-prefix=TestSingleExprClosure
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureVoid | %FileCheck %s -check-prefix=TestSingleExprClosureRetVoid
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureUnresolved | %FileCheck %s -check-prefix=TestSingleExprClosureRetUnresolved
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureCall | %FileCheck %s -check-prefix=TestSingleExprClosure
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TestSingleExprClosureGlobal | %FileCheck %s -check-prefix=TestSingleExprClosureGlobal
+
+struct TestSingleExprClosureRet {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() -> Int {
+    return { () in
+      return self.#^TestSingleExprClosureRet^#
+    }()
+  }
+
+// TestSingleExprClosureRet: Begin completions
+// TestSingleExprClosureRet-DAG: Decl[InstanceMethod]/CurrNominal:   str()[#String#];
+// TestSingleExprClosureRet-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Identical]: int()[#Int#];
+// TestSingleExprClosureRet-DAG: Decl[InstanceMethod]/CurrNominal/NotRecommended/TypeRelation[Invalid]: void()[#Void#];
+// TestSingleExprClosureRet: End completions
+}
+
+struct TestSingleExprClosureRetVoid {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() {
+    return { () in
+      return self.#^TestSingleExprClosureRetVoid^#
+    }()
+  }
+
+// TestSingleExprClosureRetVoid: Begin completions
+// TestSingleExprClosureRetVoid-DAG: Decl[InstanceMethod]/CurrNominal: str()[#String#];
+// TestSingleExprClosureRetVoid-DAG: Decl[InstanceMethod]/CurrNominal: int()[#Int#];
+// TestSingleExprClosureRetVoid-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Identical]: void()[#Void#];
+// TestSingleExprClosureRetVoid: End completions
+}
+
+struct TestSingleExprClosureRetUnresolved {
+  enum MyEnum { case myEnum }
+  enum NotMine { case notMine }
+  func mine() -> MyEnum { return .myEnum }
+  func notMine() -> NotMine { return .notMine }
+
+  func test() -> MyEnum {
+    return { () in
+      return .#^TestSingleExprClosureRetUnresolved^#
+    }()
+  }
+
+// TestSingleExprClosureRetUnresolved: Begin completions
+// TestSingleExprClosureRetUnresolved-NOT: notMine
+// TestSingleExprClosureRetUnresolved: Decl[EnumElement]/ExprSpecific: myEnum[#TestSingleExprClosure{{(Ret)?}}Unresolved.MyEnum#];
+// TestSingleExprClosureRetUnresolved-NOT: notMine
+// TestSingleExprClosureRetUnresolved: End completions
+}
+
+struct TestSingleExprClosure {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() -> Int {
+    return { () in
+      self.#^TestSingleExprClosure^#
+    }()
+  }
+// TestSingleExprClosure: Begin completions
+// TestSingleExprClosure-DAG: Decl[InstanceMethod]/CurrNominal:   str()[#String#];
+// TestSingleExprClosure-DAG: Decl[InstanceMethod]/CurrNominal/TypeRelation[Identical]: int()[#Int#];
+// NOTE: this differs from the one using a return keyword.
+// TestSingleExprClosure-DAG: Decl[InstanceMethod]/CurrNominal: void()[#Void#];
+// TestSingleExprClosure: End completions
+}
+
+struct TestSingleExprClosureVoid {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() {
+    return { () in
+      self.#^TestSingleExprClosureVoid^#
+    }()
+  }
+}
+
+struct TestSingleExprClosureUnresolved {
+  enum MyEnum { case myEnum }
+  enum NotMine { case notMine }
+  func mine() -> MyEnum { return .myEnum }
+  func notMine() -> NotMine { return .notMine }
+
+  func test() -> MyEnum {
+    return { () in
+      .#^TestSingleExprClosureUnresolved^#
+    }()
+  }
+}
+
+struct TestSingleExprClosureCall {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func take(_: () -> Int) {}
+
+  func test() {
+    take {
+      self.#^TestSingleExprClosureCall^#
+    }
+  }
+}
+
+struct TestSingleExprClosureGlobal {
+  func void() -> Void {}
+  func str() -> String { return "" }
+  func int() -> Int { return 0 }
+
+  func test() -> Int {
+    return { () -> Int in
+      #^TestSingleExprClosureGlobal^#
+    }()
+  }
+// TestSingleExprClosureGlobal: Begin completions
+// TestSingleExprClosureGlobal-DAG: Decl[InstanceMethod]/OutNominal:   str()[#String#];
+// TestSingleExprClosureGlobal-DAG: Decl[InstanceMethod]/OutNominal/TypeRelation[Identical]: int()[#Int#];
+// TestSingleExprClosureGlobal-DAG: Decl[InstanceMethod]/OutNominal: void()[#Void#];
+// TestSingleExprClosureGlobal: End completions
+}
diff --git a/test/IDE/complete_unresolved_members.swift b/test/IDE/complete_unresolved_members.swift
@@ -28,6 +28,7 @@
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_20 | %FileCheck %s -check-prefix=UNRESOLVED_3
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_21 | %FileCheck %s -check-prefix=UNRESOLVED_1
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_22 | %FileCheck %s -check-prefix=UNRESOLVED_1
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_22_noreturn | %FileCheck %s -check-prefix=UNRESOLVED_1
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_23 | %FileCheck %s -check-prefix=UNRESOLVED_1
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_24 | %FileCheck %s -check-prefix=UNRESOLVED_3
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=UNRESOLVED_25 | %FileCheck %s -check-prefix=UNRESOLVED_3
@@ -303,6 +304,10 @@ var c1 = {() -> SomeOptions1 in
   return .#^UNRESOLVED_22^#
 }
 
+var c1_noreturn = {() -> SomeOptions1 in
+  .#^UNRESOLVED_22_noreturn^#
+}
+
 class C6 {
   func f1() -> SomeOptions1 {
     return .#^UNRESOLVED_23^#
diff --git a/test/IDE/complete_value_expr.swift b/test/IDE/complete_value_expr.swift
