[CS] Record fix when encountering decl reference with placeholder type

We allow placeholder types in interface types in certain cases to allow
better recovery since we can suggest the inferred type as a replacement.
When referencing those decls though we need to make sure we record a fix
since we cannot form a valid solution with them.

Author: hamishknight

include/swift/Sema/CSFix.h

@@ -362,6 +362,9 @@ enum class FixKind : uint8_t {
   /// resolved.
   SpecifyTypeForPlaceholder,
 
+  /// Ignore an invalid placeholder in a decl's interface type.
+  IgnoreInvalidPlaceholderInDeclRef,
+
   /// Allow Swift -> C pointer conversion in an argument position
   /// of a Swift function.
   AllowSwiftToCPointerConversion,
@@ -3191,6 +3194,30 @@ class SpecifyTypeForPlaceholder final : public ConstraintFix {
   }
 };
 
+class IgnoreInvalidPlaceholderInDeclRef final : public ConstraintFix {
+  IgnoreInvalidPlaceholderInDeclRef(ConstraintSystem &cs,
+                                    ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::IgnoreInvalidPlaceholderInDeclRef, locator) {}
+
+public:
+  std::string getName() const override {
+    return "ignore invalid placeholder in decl ref";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static IgnoreInvalidPlaceholderInDeclRef *create(ConstraintSystem &cs,
+                                                   ConstraintLocator *locator);
+
+  static bool classof(const ConstraintFix *fix) {
+    return fix->getKind() == FixKind::IgnoreInvalidPlaceholderInDeclRef;
+  }
+};
+
 class AllowRefToInvalidDecl final : public ConstraintFix {
   AllowRefToInvalidDecl(ConstraintSystem &cs, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AllowRefToInvalidDecl, locator) {}

lib/Sema/CSFix.cpp

@@ -2264,6 +2264,20 @@ SpecifyTypeForPlaceholder::create(ConstraintSystem &cs,
   return new (cs.getAllocator()) SpecifyTypeForPlaceholder(cs, locator);
 }
 
+IgnoreInvalidPlaceholderInDeclRef *
+IgnoreInvalidPlaceholderInDeclRef::create(ConstraintSystem &cs, ConstraintLocator *locator) {
+  return new (cs.getAllocator()) IgnoreInvalidPlaceholderInDeclRef(cs, locator);
+}
+
+bool
+IgnoreInvalidPlaceholderInDeclRef::diagnose(const Solution &solution,
+                                            bool asNote) const {
+  // These are diagnosed separately. Unfortunately we can't enforce that a
+  // diagnostic has already been emitted since their diagnosis depends on e.g
+  // type-checking a function body for a placeholder result of a function.
+  return true;
+}
+
 bool AllowRefToInvalidDecl::diagnose(const Solution &solution,
                                      bool asNote) const {
   ReferenceToInvalidDeclaration failure(solution, getLocator());

lib/Sema/CSSimplify.cpp

@@ -16109,6 +16109,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowValueExpansionWithoutPackReferences:
   case FixKind::IgnoreInvalidPatternInExpr:
   case FixKind::IgnoreInvalidPlaceholder:
+  case FixKind::IgnoreInvalidPlaceholderInDeclRef:
   case FixKind::IgnoreOutOfPlaceThenStmt:
   case FixKind::IgnoreMissingEachKeyword:
   case FixKind::AllowInlineArrayLiteralCountMismatch:

lib/Sema/TypeOfReference.cpp

@@ -1080,13 +1080,39 @@ static Type replaceParamErrorTypeByPlaceholder(Type type, ValueDecl *value, bool
                            funcType->getExtInfo());
 }
 
+/// We allow placeholder types in interface types in certain cases to allow
+/// better recovery since we can suggest the inferred type as a replacement.
+/// When referencing those decls though we need to make sure we record a fix
+/// since we cannot form a valid solution with them.
+static void
+recordFixIfNeededForPlaceholderInDecl(ConstraintSystem &cs, ValueDecl *D,
+                                      ConstraintLocatorBuilder locator) {
+  auto mayHavePlaceholder = [&]() -> bool {
+    // Parameters with types may have placeholders, since this allows us to
+    // suggest an inferred type from a default argument. Match the logic in
+    // `getUnopenedTypeOfReference` and only query the interface type if we have
+    // one already.
+    if (auto *PD = dyn_cast<ParamDecl>(D))
+      return PD->hasInterfaceType();
+
+    // Therefore decls with parameter lists may also have placeholders.
+    return D->getParameterList();
+  };
+  if (!mayHavePlaceholder() || !D->getInterfaceType()->hasPlaceholder())
+    return;
+
+  auto *loc = cs.getConstraintLocator(locator);
+  cs.recordFix(IgnoreInvalidPlaceholderInDeclRef::create(cs, loc));
+}
+
 DeclReferenceType
 ConstraintSystem::getTypeOfReference(ValueDecl *value,
                                      FunctionRefInfo functionRefInfo,
                                      ConstraintLocatorBuilder locator,
                                      DeclContext *useDC,
                                      PreparedOverloadBuilder *preparedOverload) {
   ASSERT(!!preparedOverload == PreparingOverload);
+  recordFixIfNeededForPlaceholderInDecl(*this, value, locator);
 
   if (value->getDeclContext()->isTypeContext() && isa<FuncDecl>(value)) {
     // Unqualified lookup can find operator names within nominal types.
@@ -1777,6 +1803,7 @@ DeclReferenceType ConstraintSystem::getTypeOfMemberReference(
     SmallVectorImpl<OpenedType> *replacementsPtr,
     PreparedOverloadBuilder *preparedOverload) {
   ASSERT(!!preparedOverload == PreparingOverload);
+  recordFixIfNeededForPlaceholderInDecl(*this, value, locator);
 
   // Figure out the instance type used for the base.
   Type baseRValueTy = baseTy->getRValueType();

test/Sema/placeholder_type.swift

@@ -330,3 +330,30 @@ enum TestPlaceholderInEnumElement {
 
 @freestanding(expression) macro testPlaceholderMacro() -> _ = #file
 // expected-error@-1 {{type placeholder not allowed here}}
+
+// Make sure we can use decls with placeholders in their interface type.
+func usePlaceholderDecls(
+  _ fromProto: some TestPlaceholderRequirement, _ hasSubscript: TestPlaceholderSubscript
+) {
+  _ = optInt
+
+  _ = testPlaceholderComputed1
+  _ = testPlaceholderComputed2
+
+  fromProto.foo(0)
+  _ = fromProto.bar()
+  _ = fromProto.baz()
+  fromProto.qux([])
+  fromProto[0]
+
+  _ = hasSubscript[0]
+
+  _ = TestPlaceholderInEnumElement.a(0)
+  _ = TestPlaceholderInEnumElement.b([])
+
+  _ = #testPlaceholderMacro(0)
+  _ = #testPlaceholderMacro([])
+
+  _ = testPlaceholderFn1(0)
+  _ = testPlaceholderFn2()
+}

validation-test/compiler_crashers_2/88ba80199b702649.swift renamed to validation-test/compiler_crashers_2_fixed/88ba80199b702649.swift

@@ -1,3 +1,3 @@
 // {"kind":"typecheck","signature":"(anonymous namespace)::ExprRewriter::finishApply(swift::ApplyExpr*, swift::Type, swift::constraints::ConstraintLocatorBuilder, swift::constraints::ConstraintLocatorBuilder)","signatureAssert":"Assertion failed: (isa<To>(Val) && \"cast<Ty>() argument of incompatible type!\"), function cast"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 func a(b : ()->Void c : _->Void) { withoutActuallyEscaping(b do : c

validation-test/compiler_crashers_2/89acda2815351ec6.swift renamed to validation-test/compiler_crashers_2_fixed/89acda2815351ec6.swift

@@ -1,5 +1,5 @@
 // {"kind":"typecheck","signature":"(anonymous namespace)::ExprRewriter::coerceToType(swift::Expr*, swift::Type, swift::constraints::ConstraintLocatorBuilder)::$_3::operator()(swift::Type, swift::Type) const","signatureAssert":"Assertion failed: (restriction == ConversionRestrictionKind::DeepEquality), function operator()"}
-// RUN: not --crash %target-swift-frontend -typecheck %s
+// RUN: not %target-swift-frontend -typecheck %s
 func a(inout _ )
 var b = String
 a(b

validation-test/compiler_crashers_2_fixed/f6ae9d69266e6b1c.swift

@@ -0,0 +1,6 @@
+// {"kind":"typecheck","original":"0e81571d","signature":"swift::constraints::ConstraintSystem::applySolution(swift::constraints::Solution&, swift::constraints::SyntacticElementTarget)","signatureAssert":"Assertion failed: (isValidType(type) && \"type binding has invalid type\"), function applySolution"}
+// RUN: not %target-swift-frontend -typecheck %s
+subscript(a: _) -> <#type#> {
+  a
+  0
+}