[CodeCompletion] Postfix expr completion after trailing closures

Author: rintaro

lib/IDE/CodeCompletion.cpp

@@ -5948,8 +5948,37 @@ void CodeCompletionCallbacksImpl::doneParsing() {
         DoPostfixExprBeginning();
       } else {
         //   foo() {} <HERE>
-        // Member completion
-        // TODO: Member completion.
+        // Member completion.
+        Expr *analyzedExpr = ContextInfo.getAnalyzedExpr();
+        if (!analyzedExpr)
+          break;
+
+        // Only if the completion token is the last token in the call.
+        if (analyzedExpr->getEndLoc() != CodeCompleteTokenExpr->getLoc())
+          break;
+
+        // If the call expression doesn't have a type, infer it from the
+        // possible callee info.
+        Type resultTy = analyzedExpr->getType();
+        if (!resultTy) {
+          if (ContextInfo.getPossibleCallees().empty())
+            break;
+          auto calleeInfo = ContextInfo.getPossibleCallees()[0];
+          resultTy = calleeInfo.Type->getResult();
+          analyzedExpr->setType(resultTy);
+        }
+
+        auto &SM = CurDeclContext->getASTContext().SourceMgr;
+        auto leadingChar =
+            SM.extractText({SM.getCodeCompletionLoc().getAdvancedLoc(-1), 1});
+        Lookup.setHaveLeadingSpace(leadingChar.find_first_of(" \t\f\v") !=
+                                   StringRef::npos);
+
+        if (isDynamicLookup(resultTy))
+          Lookup.setIsDynamicLookup();
+        Lookup.getValueExprCompletions(resultTy, /*VD=*/nullptr);
+        Lookup.getOperatorCompletions(analyzedExpr, leadingSequenceExprs);
+        Lookup.getPostfixKeywordCompletions(resultTy, analyzedExpr);
       }
     }
     break;

lib/IDE/ExprContextAnalysis.cpp

@@ -573,6 +573,7 @@ class ExprContextAnalyzer {
   SmallVectorImpl<Type> &PossibleTypes;
   SmallVectorImpl<PossibleParamInfo> &PossibleParams;
   SmallVectorImpl<FunctionTypeAndDecl> &PossibleCallees;
+  Expr *&AnalyzedExpr;
   bool &singleExpressionBody;
 
   void recordPossibleType(Type ty) {
@@ -674,6 +675,7 @@ class ExprContextAnalyzer {
   }
 
   void analyzeExpr(Expr *Parent) {
+    AnalyzedExpr = Parent;
     switch (Parent->getKind()) {
     case ExprKind::Call:
     case ExprKind::Subscript:
@@ -936,10 +938,11 @@ class ExprContextAnalyzer {
       DeclContext *DC, Expr *ParsedExpr, SmallVectorImpl<Type> &PossibleTypes,
       SmallVectorImpl<PossibleParamInfo> &PossibleArgs,
       SmallVectorImpl<FunctionTypeAndDecl> &PossibleCallees,
-      bool &singleExpressionBody)
+      Expr *&AnalyzedExpr, bool &singleExpressionBody)
       : DC(DC), ParsedExpr(ParsedExpr), SM(DC->getASTContext().SourceMgr),
         Context(DC->getASTContext()), PossibleTypes(PossibleTypes),
         PossibleParams(PossibleArgs), PossibleCallees(PossibleCallees),
+        AnalyzedExpr(AnalyzedExpr),
         singleExpressionBody(singleExpressionBody) {}
 
   void Analyze() {
@@ -1048,7 +1051,8 @@ class ExprContextAnalyzer {
 
 ExprContextInfo::ExprContextInfo(DeclContext *DC, Expr *TargetExpr) {
   ExprContextAnalyzer Analyzer(DC, TargetExpr, PossibleTypes, PossibleParams,
-                               PossibleCallees, singleExpressionBody);
+                               PossibleCallees, AnalyzedExpr,
+                               singleExpressionBody);
   Analyzer.Analyze();
 }
 

lib/IDE/ExprContextAnalysis.h

@@ -73,6 +73,7 @@ class ExprContextInfo {
   SmallVector<Type, 2> PossibleTypes;
   SmallVector<PossibleParamInfo, 2> PossibleParams;
   SmallVector<FunctionTypeAndDecl, 2> PossibleCallees;
+  Expr *AnalyzedExpr = nullptr;
   bool singleExpressionBody = false;
 
 public:
@@ -99,6 +100,10 @@ class ExprContextInfo {
   ArrayRef<FunctionTypeAndDecl> getPossibleCallees() const {
     return PossibleCallees;
   }
+
+  Expr *getAnalyzedExpr() const {
+    return AnalyzedExpr;
+  }
 };
 
 /// Returns whether \p VD is referenceable with implicit member expression.

test/IDE/complete_multiple_trailingclosure.swift

@@ -33,16 +33,26 @@ func testGlobalFunc() {
 // GLOBALFUNC_AFTERLABEL-NOT: Begin completions
 }
 
+struct SimpleEnum {
+  case foo, bar
+
+  func enumFunc() {}
+  static func + (lhs: SimpleEnum, rhs: SimpleEnum) -> SimpleEnum {}
+}
+
 struct MyStruct {
-  func method1(fn1: () -> Int, fn2: (() -> String)? = nil) {}
-  func method1(fn1: () -> Int, fn2: Int = nil) {}
+  func method1(fn1: () -> Int, fn2: (() -> String)? = nil) -> SimpleEnum {}
+  func method1(fn1: () -> Int, fn2: Int = nil) -> SimpleEnum {}
 }
 func testMethod(value: MyStruct) {
   value.method1 {
   } #^METHOD_SAMELINE^#
   #^METHOD_NEWLINE^#
-// METHOD_SAMELINE: Begin completions, 1 items
+// METHOD_SAMELINE: Begin completions, 4 items
 // METHOD_SAMELINE-DAG: Pattern/ExprSpecific:               {#fn2: (() -> String)?##() -> String#}[#(() -> String)?#];
+// METHOD_SAMELINE-DAG: Decl[InstanceMethod]/CurrNominal:   .enumFunc()[#Void#];
+// METHOD_SAMELINE-DAG: Decl[InfixOperatorFunction]/OtherModule[Swift]: [' ']+ {#SimpleEnum#}[#SimpleEnum#];
+// METHOD_SAMELINE-DAG: Keyword[self]/CurrNominal:          .self[#SimpleEnum#];
 // METHOD_SAMELINE: End completions
 
 // METHOD_NEWLINE: Begin completions
@@ -59,6 +69,8 @@ struct TestStruct {
   init(fn1: () -> Int) {}
   init(fn1: () -> Int, fn2: () -> String) {}
   init(fn1: () -> Int, fn3: () -> String) {}
+
+  func testStructMethod() {}
 }
 
 func testOverloadedInit() {
@@ -67,9 +79,11 @@ func testOverloadedInit() {
   } #^INIT_OVERLOADED_SAMELINE^#
   #^INIT_OVERLOADED_NEWLINE^#
 
-// INIT_OVERLOADED_SAMELINE: Begin completions, 2 items
+// INIT_OVERLOADED_SAMELINE: Begin completions, 4 items
 // INIT_OVERLOADED_SAMELINE-DAG: Pattern/ExprSpecific:               {#fn2: () -> String##() -> String#}[#() -> String#];
 // INIT_OVERLOADED_SAMELINE-DAG: Pattern/ExprSpecific:               {#fn3: () -> String##() -> String#}[#() -> String#];
+// INIT_OVERLOADED_SAMELINE-DAG: Decl[InstanceMethod]/CurrNominal:   .testStructMethod()[#Void#];
+// INIT_OVERLOADED_SAMELINE-DAG: Keyword[self]/CurrNominal:          .self[#TestStruct#];
 // INIT_OVERLOADED_SAMELINE: End completions
 
 // INIT_OVERLOADED_NEWLINE: Begin completions
@@ -84,16 +98,19 @@ func testOverloadedInit() {
 
 struct TestStruct2 {
   init(fn1: () -> Int, fn2: () -> String = {}, fn3: () -> String = {}) {}
+  func testStructMethod() {}
 }
 func testOptionalInit() {
   TestStruct2 {
     2
   } #^INIT_OPTIONAL_SAMELINE^#
   #^INIT_OPTIONAL_NEWLINE^#
 
-// INIT_OPTIONAL_SAMELINE: Begin completions, 2 items
+// INIT_OPTIONAL_SAMELINE: Begin completions, 4 items
 // INIT_OPTIONAL_SAMELINE-DAG: Pattern/ExprSpecific:               {#fn2: () -> String##() -> String#}[#() -> String#];
 // INIT_OPTIONAL_SAMELINE-DAG: Pattern/ExprSpecific:               {#fn3: () -> String##() -> String#}[#() -> String#];
+// INIT_OPTIONAL_SAMELINE-DAG: Decl[InstanceMethod]/CurrNominal:   .testStructMethod()[#Void#];
+// INIT_OPTIONAL_SAMELINE-DAG: Keyword[self]/CurrNominal:          .self[#TestStruct2#];
 // INIT_OPTIONAL_SAMELINE: End completions
 
 // INIT_OPTIONAL_NEWLINE: Begin completions
@@ -108,6 +125,7 @@ func testOptionalInit() {
 
 struct TestStruct3 {
   init(fn1: () -> Int, fn2: () -> String, fn3: () -> String) {}
+  func testStructMethod() {}
 }
 func testOptionalInit() {
   // missing 'fn2' and 'fn3'.
@@ -150,7 +168,10 @@ func testOptionalInit() {
   } #^INIT_REQUIRED_SAMELINE_3^#
   #^INIT_REQUIRED_NEWLINE_3^#
 
-// INIT_REQUIRED_SAMELINE_3-NOT: Begin completions
+// INIT_REQUIRED_SAMELINE_3: Begin completions, 2 items
+// INIT_REQUIRED_SAMELINE_3-DAG: Decl[InstanceMethod]/CurrNominal:   .testStructMethod()[#Void#];
+// INIT_REQUIRED_SAMELINE_3-DAG: Keyword[self]/CurrNominal:          .self[#TestStruct3#];
+// INIT_REQIORED_SAMELINE_3: End completions
 
 // INIT_REQUIRED_NEWLINE_3: Begin completions
 // INIT_REQUIRED_NEWLINE_3-NOT: name=fn2

validation-test/IDE/slow/rdar45511835.swift

@@ -1,6 +1,4 @@
 // RUN: %target-swift-ide-test -code-completion -code-completion-token=COMPLETE -source-filename=%s | %FileCheck %s
-// TODO: Postfix completion after trailing closure.
-// XFAIL: *
 
 // REQUIRES: long_test