Merge pull request swiftlang#30136 from rintaro/ide-completion-rdar59285399

[CodeCompletion] Primarily use getPossibleCallees() for calling signature completion

Author: rintaro

lib/IDE/CodeCompletion.cpp

@@ -2399,8 +2399,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     return SemanticContextKind::OtherModule;
   }
 
-  void addSubscriptCallPattern(const AnyFunctionType *AFT,
-                               const SubscriptDecl *SD) {
+  void addSubscriptCallPattern(
+      const AnyFunctionType *AFT, const SubscriptDecl *SD,
+      const Optional<SemanticContextKind> SemanticContext = None) {
     foundFunction(AFT);
     auto genericSig =
         SD->getInnermostDeclContext()->getGenericSignatureOfContext();
@@ -2410,7 +2411,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     CommandWordsPairs Pairs;
     CodeCompletionResultBuilder Builder(
         Sink, CodeCompletionResult::ResultKind::Declaration,
-        getSemanticContextKind(SD), expectedTypeContext);
+        SemanticContext ? *SemanticContext : getSemanticContextKind(SD),
+        expectedTypeContext);
     Builder.setAssociatedDecl(SD);
     setClangDeclKeywords(SD, Pairs, Builder);
     if (!HaveLParen)
@@ -2429,8 +2431,9 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
       addTypeAnnotation(Builder, AFT->getResult());
   }
 
-  void addFunctionCallPattern(const AnyFunctionType *AFT,
-                              const AbstractFunctionDecl *AFD = nullptr) {
+  void addFunctionCallPattern(
+      const AnyFunctionType *AFT, const AbstractFunctionDecl *AFD = nullptr,
+      const Optional<SemanticContextKind> SemanticContext = None) {
     if (AFD) {
       auto genericSig =
           AFD->getInnermostDeclContext()->getGenericSignatureOfContext();
@@ -2446,7 +2449,8 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
           Sink,
           AFD ? CodeCompletionResult::ResultKind::Declaration
               : CodeCompletionResult::ResultKind::Pattern,
-          getSemanticContextKind(AFD), expectedTypeContext);
+          SemanticContext ? *SemanticContext : getSemanticContextKind(AFD),
+          expectedTypeContext);
       if (AFD) {
         Builder.setAssociatedDecl(AFD);
         setClangDeclKeywords(AFD, Pairs, Builder);
@@ -3243,11 +3247,11 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
     return true;
   }
 
-  bool tryFunctionCallCompletions(Type ExprType, const ValueDecl *VD) {
+  bool tryFunctionCallCompletions(Type ExprType, const ValueDecl *VD, Optional<SemanticContextKind> SemanticContext = None) {
     ExprType = ExprType->getRValueType();
     if (auto AFT = ExprType->getAs<AnyFunctionType>()) {
       if (auto *AFD = dyn_cast_or_null<AbstractFunctionDecl>(VD)) {
-        addFunctionCallPattern(AFT, AFD);
+        addFunctionCallPattern(AFT, AFD, SemanticContext);
       } else {
         addFunctionCallPattern(AFT);
       }
@@ -5407,12 +5411,13 @@ void CodeCompletionCallbacksImpl::doneParsing() {
       ExprContextInfo ParentContextInfo(CurDeclContext, ParsedExpr);
       Lookup.setExpectedTypes(ParentContextInfo.getPossibleTypes(),
                               ParentContextInfo.isSingleExpressionBody());
-      if (ExprType && ((*ExprType)->is<AnyFunctionType>() ||
-                       (*ExprType)->is<AnyMetatypeType>())) {
-        Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl());
-      } else {
+      if (!ContextInfo.getPossibleCallees().empty()) {
         for (auto &typeAndDecl : ContextInfo.getPossibleCallees())
-          Lookup.tryFunctionCallCompletions(typeAndDecl.first, typeAndDecl.second);
+          Lookup.tryFunctionCallCompletions(typeAndDecl.Type, typeAndDecl.Decl,
+                                            typeAndDecl.SemanticContext);
+      } else if (ExprType && ((*ExprType)->is<AnyFunctionType>() ||
+                              (*ExprType)->is<AnyMetatypeType>())) {
+        Lookup.getValueExprCompletions(*ExprType, ReferencedDecl.getDecl());
       }
     } else {
       // Add argument labels, then fallthrough to get values.
@@ -5538,12 +5543,14 @@ void CodeCompletionCallbacksImpl::doneParsing() {
         !ContextInfo.getPossibleCallees().empty()) {
       Lookup.setHaveLParen(true);
       for (auto &typeAndDecl : ContextInfo.getPossibleCallees()) {
-        if (auto SD = dyn_cast_or_null<SubscriptDecl>(typeAndDecl.second)) {
-          Lookup.addSubscriptCallPattern(typeAndDecl.first, SD);
+        if (auto SD = dyn_cast_or_null<SubscriptDecl>(typeAndDecl.Decl)) {
+          Lookup.addSubscriptCallPattern(typeAndDecl.Type, SD,
+                                         typeAndDecl.SemanticContext);
         } else {
           Lookup.addFunctionCallPattern(
-              typeAndDecl.first,
-              dyn_cast_or_null<AbstractFunctionDecl>(typeAndDecl.second));
+              typeAndDecl.Type,
+              dyn_cast_or_null<AbstractFunctionDecl>(typeAndDecl.Decl),
+              typeAndDecl.SemanticContext);
         }
       }
       Lookup.setHaveLParen(false);

lib/IDE/ExprContextAnalysis.cpp

@@ -27,6 +27,7 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
 #include "swift/Basic/SourceManager.h"
+#include "swift/IDE/CodeCompletion.h"
 #include "swift/Sema/IDETypeChecking.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
@@ -279,19 +280,21 @@ static void collectPossibleCalleesByQualifiedLookup(
     DeclContext &DC, Type baseTy, DeclNameRef name,
     SmallVectorImpl<FunctionTypeAndDecl> &candidates) {
   bool isOnMetaType = baseTy->is<AnyMetatypeType>();
+  auto baseInstanceTy = baseTy->getMetatypeInstanceType();
 
   SmallVector<ValueDecl *, 2> decls;
-  if (!DC.lookupQualified(baseTy->getMetatypeInstanceType(),
+  if (!DC.lookupQualified(baseInstanceTy,
                           name.withoutArgumentLabels(),
                           NL_QualifiedDefault | NL_ProtocolMembers,
                           decls))
     return;
 
+  auto *baseNominal = baseInstanceTy->getAnyNominal();
   for (auto *VD : decls) {
     if ((!isa<AbstractFunctionDecl>(VD) && !isa<SubscriptDecl>(VD)) ||
         VD->shouldHideFromEditor())
       continue;
-    if (!isMemberDeclApplied(&DC, baseTy->getMetatypeInstanceType(), VD))
+    if (!isMemberDeclApplied(&DC, baseInstanceTy, VD))
       continue;
     Type declaredMemberType = VD->getInterfaceType();
     if (!declaredMemberType->is<AnyFunctionType>())
@@ -314,16 +317,15 @@ static void collectPossibleCalleesByQualifiedLookup(
       }
     }
 
-    auto subs = baseTy->getMetatypeInstanceType()->getMemberSubstitutionMap(
+    auto subs = baseInstanceTy->getMemberSubstitutionMap(
         DC.getParentModule(), VD,
         VD->getInnermostDeclContext()->getGenericEnvironmentOfContext());
     auto fnType = declaredMemberType.subst(subs);
     if (!fnType)
       continue;
 
     if (fnType->is<AnyFunctionType>()) {
-      auto baseInstanceTy = baseTy->getMetatypeInstanceType();
-      // If we are calling to typealias type, 
+      // If we are calling to typealias type,
       if (isa<SugarType>(baseInstanceTy.getPointer())) {
         auto canBaseTy = baseInstanceTy->getCanonicalType();
         fnType = fnType.transform([&](Type t) -> Type {
@@ -332,7 +334,13 @@ static void collectPossibleCalleesByQualifiedLookup(
           return t;
         });
       }
-      candidates.emplace_back(fnType->castTo<AnyFunctionType>(), VD);
+      auto semanticContext = SemanticContextKind::CurrentNominal;
+      if (baseNominal &&
+          VD->getDeclContext()->getSelfNominalTypeDecl() != baseNominal)
+        semanticContext = SemanticContextKind::Super;
+
+      candidates.emplace_back(fnType->castTo<AnyFunctionType>(), VD,
+                              semanticContext);
     }
   }
 }
@@ -347,10 +355,16 @@ static void collectPossibleCalleesByQualifiedLookup(
       DC.getASTContext(), &DC, CompletionTypeCheckKind::Normal, baseExpr, ref);
   if (!baseTyOpt)
     return;
-  auto baseTy = (*baseTyOpt)->getRValueType();
+
+  auto baseTy = (*baseTyOpt)->getWithoutSpecifierType();
   if (!baseTy->getMetatypeInstanceType()->mayHaveMembers())
     return;
 
+  // Use metatype for lookup 'super.init' if it's inside constructors.
+  if (isa<SuperRefExpr>(baseExpr) && isa<ConstructorDecl>(DC) &&
+      name == DeclNameRef::createConstructor())
+    baseTy = MetatypeType::get(baseTy);
+
   collectPossibleCalleesByQualifiedLookup(DC, baseTy, name, candidates);
 }
 
@@ -360,24 +374,17 @@ static bool collectPossibleCalleesForApply(
     SmallVectorImpl<FunctionTypeAndDecl> &candidates) {
   auto *fnExpr = callExpr->getFn();
 
-  if (auto type = fnExpr->getType()) {
-    if (!type->hasUnresolvedType() && !type->hasError()) {
-      if (auto *funcType = type->getAs<AnyFunctionType>()) {
-        auto refDecl = fnExpr->getReferencedDecl();
-        if (!refDecl)
-          if (auto apply = dyn_cast<ApplyExpr>(fnExpr))
-            refDecl = apply->getFn()->getReferencedDecl();
-        candidates.emplace_back(funcType, refDecl.getDecl());
-        return true;
-      }
-    }
-  }
-
   if (auto *DRE = dyn_cast<DeclRefExpr>(fnExpr)) {
     if (auto *decl = DRE->getDecl()) {
-      if (decl->hasInterfaceType())
-        if (auto *funcType = decl->getInterfaceType()->getAs<AnyFunctionType>())
-          candidates.emplace_back(funcType, decl);
+      Type fnType = fnExpr->getType();
+      if ((!fnType || fnType->hasError() || fnType->hasUnresolvedType()) &&
+          decl->hasInterfaceType())
+        fnType = decl->getInterfaceType();
+      if (fnType) {
+        fnType = fnType->getWithoutSpecifierType();
+        if (auto *funcTy = fnType->getAs<AnyFunctionType>())
+          candidates.emplace_back(funcTy, decl);
+      }
     }
   } else if (auto *OSRE = dyn_cast<OverloadSetRefExpr>(fnExpr)) {
     for (auto *decl : OSRE->getDecls()) {
@@ -386,30 +393,49 @@ static bool collectPossibleCalleesForApply(
           candidates.emplace_back(funcType, decl);
     }
   } else if (auto *UDE = dyn_cast<UnresolvedDotExpr>(fnExpr)) {
-    collectPossibleCalleesByQualifiedLookup(
-        DC, UDE->getBase(), UDE->getName(), candidates);
+    collectPossibleCalleesByQualifiedLookup(DC, UDE->getBase(), UDE->getName(),
+                                            candidates);
   } else if (auto *DSCE = dyn_cast<DotSyntaxCallExpr>(fnExpr)) {
     if (auto *DRE = dyn_cast<DeclRefExpr>(DSCE->getFn())) {
-    collectPossibleCalleesByQualifiedLookup(
-        DC, DSCE->getArg(), DeclNameRef(DRE->getDecl()->getFullName()),
-                                            candidates);
+      collectPossibleCalleesByQualifiedLookup(
+          DC, DSCE->getArg(), DeclNameRef(DRE->getDecl()->getFullName()),
+          candidates);
     }
+  } else if (auto CRCE = dyn_cast<ConstructorRefCallExpr>(fnExpr)) {
+    collectPossibleCalleesByQualifiedLookup(
+        DC, CRCE->getArg(), DeclNameRef::createConstructor(), candidates);
   }
 
-  if (candidates.empty()) {
-    ConcreteDeclRef ref = nullptr;
-    auto fnType = getTypeOfCompletionContextExpr(
-        DC.getASTContext(), &DC, CompletionTypeCheckKind::Normal, fnExpr, ref);
-    if (!fnType)
-      return false;
+  if (!candidates.empty())
+    return true;
 
-    if (auto *AFT = (*fnType)->getAs<AnyFunctionType>()) {
-      candidates.emplace_back(AFT, ref.getDecl());
-    } else if (auto *AMT = (*fnType)->getAs<AnyMetatypeType>()) {
-      auto baseTy = AMT->getInstanceType();
-      if (baseTy->mayHaveMembers())
-        collectPossibleCalleesByQualifiedLookup(
-            DC, AMT, DeclNameRef::createConstructor(), candidates);
+  ConcreteDeclRef refDecl = nullptr;
+  Type fnType = fnExpr->getType();
+  if (fnType) {
+    refDecl = fnExpr->getReferencedDecl();
+    if (!refDecl)
+      if (auto apply = dyn_cast<ApplyExpr>(fnExpr))
+        refDecl = apply->getFn()->getReferencedDecl();
+  }
+  if (!fnType) {
+    auto fnTypeOpt = getTypeOfCompletionContextExpr(
+        DC.getASTContext(), &DC, CompletionTypeCheckKind::Normal, fnExpr,
+        refDecl);
+    if (fnTypeOpt)
+      fnType = *fnTypeOpt;
+  }
+
+  if (!fnType || fnType->hasUnresolvedType() || fnType->hasError())
+    return false;
+  fnType = fnType->getWithoutSpecifierType();
+
+  if (auto *AFT = fnType->getAs<AnyFunctionType>()) {
+    candidates.emplace_back(AFT, refDecl.getDecl());
+  } else if (auto *AMT = fnType->getAs<AnyMetatypeType>()) {
+    auto baseTy = AMT->getInstanceType();
+    if (isa<TypeExpr>(fnExpr) && baseTy->mayHaveMembers()) {
+      collectPossibleCalleesByQualifiedLookup(
+          DC, AMT, DeclNameRef::createConstructor(), candidates);
     }
   }
 
@@ -454,7 +480,7 @@ static bool collectPossibleCalleesForUnresolvedMember(
                                             members);
     for (auto member : members) {
       if (isReferenceableByImplicitMemberExpr(currModule, &DC, expectedTy,
-                                              member.second))
+                                              member.Decl))
         candidates.push_back(member);
     }
   }
@@ -549,12 +575,12 @@ class ExprContextAnalyzer {
       SmallPtrSet<Identifier, 4> seenNames;
       for (auto &typeAndDecl : Candidates) {
         DeclContext *memberDC = nullptr;
-        if (typeAndDecl.second)
-          memberDC = typeAndDecl.second->getInnermostDeclContext();
+        if (typeAndDecl.Decl)
+          memberDC = typeAndDecl.Decl->getInnermostDeclContext();
 
-        auto Params = typeAndDecl.first->getParams();
+        auto Params = typeAndDecl.Type->getParams();
         ParameterList *paramList = nullptr;
-        if (auto VD = typeAndDecl.second) {
+        if (auto VD = typeAndDecl.Decl) {
           if (auto FD = dyn_cast<AbstractFunctionDecl>(VD))
             paramList = FD->getParameters();
           else if (auto SD = dyn_cast<SubscriptDecl>(VD))

lib/IDE/ExprContextAnalysis.h

@@ -24,6 +24,7 @@ class ValueDecl;
 class AnyFunctionType;
 
 namespace ide {
+enum class SemanticContextKind;
 
 /// Type check parent contexts of the given decl context, and the body of the
 /// given context until \c Loc if the context is a function body.
@@ -37,7 +38,17 @@ Expr *findParsedExpr(const DeclContext *DC, SourceRange TargetRange);
 /// \p DC should be an \c AbstractFunctionDecl or an \c AbstractClosureExpr.
 Type getReturnTypeFromContext(const DeclContext *DC);
 
-using FunctionTypeAndDecl = std::pair<AnyFunctionType *, ValueDecl *>;
+struct FunctionTypeAndDecl {
+  AnyFunctionType *Type;
+  ValueDecl *Decl;
+  Optional<SemanticContextKind> SemanticContext;
+
+  FunctionTypeAndDecl(AnyFunctionType *Type, ValueDecl *Decl)
+      : Type(Type), Decl(Decl) {}
+  FunctionTypeAndDecl(AnyFunctionType *Type, ValueDecl *Decl,
+                      SemanticContextKind SemanticContext)
+      : Type(Type), Decl(Decl), SemanticContext(SemanticContext) {}
+};
 
 /// Given an expression and its decl context, the analyzer tries to figure out
 /// the expected type of the expression by analyzing its context.

test/IDE/complete_at_top_level.swift

@@ -470,7 +470,7 @@ func resyncParserB14() {}
 var stringInterp = "\(#^STRING_INTERP_3^#)"
 _ = "" + "\(#^STRING_INTERP_4^#)" + ""
 // STRING_INTERP: Begin completions
-// STRING_INTERP-DAG: Decl[InstanceMethod]/CurrNominal:   ['(']{#(value): _#}[')'][#Void#]; name=value: _
+// STRING_INTERP-DAG: Decl[InstanceMethod]/CurrNominal:   ['(']{#(value): T#}[')'][#Void#];
 // STRING_INTERP-DAG: Decl[Struct]/CurrModule: FooStruct[#FooStruct#];
 // STRING_INTERP-DAG: Decl[FreeFunction]/CurrModule/NotRecommended/TypeRelation[Invalid]: fooFunc1()[#Void#];
 // STRING_INTERP-DAG: Decl[FreeFunction]/CurrModule: optStr()[#String?#];

test/IDE/complete_call_arg.swift

@@ -93,6 +93,7 @@
 
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=ARCHETYPE_GENERIC_1 | %FileCheck %s -check-prefix=ARCHETYPE_GENERIC_1
 // RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=PARAM_WITH_ERROR_AUTOCLOSURE| %FileCheck %s -check-prefix=PARAM_WITH_ERROR_AUTOCLOSURE
+// RUN: %target-swift-ide-test -code-completion -source-filename %s -code-completion-token=TYPECHECKED_OVERLOADED | %FileCheck %s -check-prefix=TYPECHECKED_OVERLOADED
 
 var i1 = 1
 var i2 = 2
@@ -737,7 +738,7 @@ struct Wrap<T> {
 func testGenricMethodOnGenericOfArchetype<Wrapped>(value: Wrap<Wrapped>) {
   value.method(#^ARCHETYPE_GENERIC_1^#)
 // ARCHETYPE_GENERIC_1: Begin completions
-// ARCHETYPE_GENERIC_1: Decl[InstanceMethod]/CurrNominal:   ['(']{#(fn): (Wrapped) -> _##(Wrapped) -> _#}[')'][#Wrap<_>#];
+// ARCHETYPE_GENERIC_1: Decl[InstanceMethod]/CurrNominal:   ['(']{#(fn): (Wrapped) -> U##(Wrapped) -> U#}[')'][#Wrap<U>#];
 }
 
 struct TestHasErrorAutoclosureParam {
@@ -751,3 +752,17 @@ struct TestHasErrorAutoclosureParam {
 // PARAM_WITH_ERROR_AUTOCLOSURE: End completions
   }
 }
+
+struct MyType {
+  func overloaded() {}
+  func overloaded(_ int: Int) {}
+  func overloaded(name: String, value: String) {}
+}
+func testTypecheckedOverloaded(value: MyType) {
+  value.overloaded(#^TYPECHECKED_OVERLOADED^#)
+// TYPECHECKED_OVERLOADED: Begin completions
+// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal:   ['('][')'][#Void#];
+// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal:   ['(']{#(int): Int#}[')'][#Void#];
+// TYPECHECKED_OVERLOADED-DAG: Decl[InstanceMethod]/CurrNominal:   ['(']{#name: String#}, {#value: String#}[')'][#Void#];
+// TYPECHECKED_OVERLOADED: End completions
+}