[IDE] Pass whether we have applied self to replaceParamErrorTypeByPlaceholder

Author: ahoppen

lib/Sema/ConstraintSystem.cpp

@@ -1526,30 +1526,35 @@ AnyFunctionType *ConstraintSystem::adjustFunctionTypeForConcurrency(
 /// that declared \p type. This is useful for code completion so we can match
 /// the types we do know instead of bailing out completely because \p type
 /// contains an error type.
-static Type replaceParamErrorTypeByPlaceholder(Type type, ValueDecl *value) {
+static Type replaceParamErrorTypeByPlaceholder(Type type, ValueDecl *value, bool hasAppliedSelf) {
   if (!type->is<AnyFunctionType>() || !isa<AbstractFunctionDecl>(value)) {
     return type;
   }
   auto funcType = type->castTo<AnyFunctionType>();
   auto funcDecl = cast<AbstractFunctionDecl>(value);
 
-  auto declParams = funcDecl->getParameters();
+  SmallVector<ParamDecl *> declParams;
+  if (hasAppliedSelf) {
+    declParams.append(funcDecl->getParameters()->begin(), funcDecl->getParameters()->end());
+  } else {
+    declParams.push_back(funcDecl->getImplicitSelfDecl());
+  }
   auto typeParams = funcType->getParams();
-  assert(declParams->size() == typeParams.size());
+  assert(declParams.size() == typeParams.size());
   SmallVector<AnyFunctionType::Param, 4> newParams;
-  newParams.reserve(declParams->size());
+  newParams.reserve(declParams.size());
   for (auto i : indices(typeParams)) {
     AnyFunctionType::Param param = typeParams[i];
     if (param.getPlainType()->is<ErrorType>()) {
-      auto paramDecl = declParams->get(i);
+      auto paramDecl = declParams[i];
       auto placeholder =
           PlaceholderType::get(paramDecl->getASTContext(), paramDecl);
       newParams.push_back(param.withType(placeholder));
     } else {
       newParams.push_back(param);
     }
   }
-  assert(newParams.size() == declParams->size());
+  assert(newParams.size() == declParams.size());
   return FunctionType::get(newParams, funcType->getResult());
 }
 
@@ -1620,7 +1625,7 @@ ConstraintSystem::getTypeOfReference(ValueDecl *value,
     if (isForCodeCompletion() && openedType->hasError()) {
       // In code completion, replace error types by placeholder types so we can
       // match the types we know instead of bailing out completely.
-      openedType = replaceParamErrorTypeByPlaceholder(openedType, value);
+      openedType = replaceParamErrorTypeByPlaceholder(openedType, value, /*hasAppliedSelf=*/true);
     }
 
     // If we opened up any type variables, record the replacements.
@@ -2288,7 +2293,7 @@ Type ConstraintSystem::getMemberReferenceTypeFromOpenedType(
   if (isForCodeCompletion() && type->hasError()) {
     // In code completion, replace error types by placeholder types so we can
     // match the types we know instead of bailing out completely.
-    type = replaceParamErrorTypeByPlaceholder(type, value);
+    type = replaceParamErrorTypeByPlaceholder(type, value, hasAppliedSelf);
   }
 
   return type;

test/IDE/complete_unapplied_static_ref_to_func_with_error.swift

@@ -0,0 +1,31 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-swift-ide-test -batch-code-completion -source-filename %s -filecheck %raw-FileCheck -completion-output-dir %t
+
+func myGlobalFunction() -> Invalid {}
+
+struct Test {
+  func myInstanceMethod() -> Invalid {}
+
+  func testInstanceMethod() {
+    Test.myInstanceMethod#^INSTANCE_METHOD^#
+    // Check that we don't crash
+    // INSTANCE_METHOD-NOT: Begin completions
+  }
+
+  func testGlobalFunctionMethod() {
+    myGlobalFunction#^GLOBAL_FUNCTION^#
+    // Check that we don't crash
+    // GLOBAL_FUNCTION: Begin completions
+    // GLOBAL_FUNCTION: Keyword[self]/CurrNominal:          .self[#_#]
+    // GLOBAL_FUNCTION: End completions
+  }
+
+  func testLocalFunction() {
+    func myLocalFunction() -> Invalid {}
+    myLocalFunction#^LOCAL_FUNCTION^#
+    // LOCAL_FUNCTION: Begin completions
+    // LOCAL_FUNCTION: Keyword[self]/CurrNominal:          .self[#_#]
+    // LOCAL_FUNCTION: End completions
+  }
+}
+