[Sema] Diagnose user-specified placeholders which couldn’t be resolved

Author: Jumhyn

include/swift/AST/DiagnosticsSema.def

@@ -3596,6 +3596,9 @@ ERROR(unresolved_nil_literal,none,
 ERROR(cannot_force_unwrap_nil_literal,none,
       "'nil' literal cannot be force unwrapped", ())
 
+ERROR(could_not_infer_placeholder,none,
+      "could not infer type for placeholder", ())
+
 ERROR(type_of_expression_is_ambiguous,none,
       "type of expression is ambiguous without more context", ())
 

include/swift/Sema/CSFix.h

@@ -328,6 +328,10 @@ enum class FixKind : uint8_t {
   /// another property wrapper that is a part of the same composed
   /// property wrapper.
   AllowWrappedValueMismatch,
+
+  /// Specify a type for an explicitly written placeholder that could not be
+  /// resolved.
+  SpecifyTypeForPlaceholder
 };
 
 class ConstraintFix {
@@ -2257,6 +2261,25 @@ class SpecifyContextualTypeForNil final : public ConstraintFix {
                                              ConstraintLocator * locator);
 };
 
+class SpecifyTypeForPlaceholder final : public ConstraintFix {
+  SpecifyTypeForPlaceholder(ConstraintSystem &cs, ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::SpecifyTypeForPlaceholder, locator) {}
+
+public:
+  std::string getName() const override {
+    return "specify type for placeholder";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static SpecifyTypeForPlaceholder *create(ConstraintSystem &cs,
+                                           ConstraintLocator *locator);
+};
+
 class AllowRefToInvalidDecl final : public ConstraintFix {
   AllowRefToInvalidDecl(ConstraintSystem &cs, ConstraintLocator *locator)
       : ConstraintFix(cs, FixKind::AllowRefToInvalidDecl, locator) {}

lib/Sema/CSBindings.cpp

@@ -1904,6 +1904,11 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
     return std::make_pair(fix, defaultImpact);
   }
 
+  if (srcLocator->isLastElement<LocatorPathElt::PlaceholderType>()) {
+    ConstraintFix *fix = SpecifyTypeForPlaceholder::create(cs, srcLocator);
+    return std::make_pair(fix, defaultImpact);
+  }
+
   if (dstLocator->directlyAt<NilLiteralExpr>()) {
     // This is a dramatic event, it means that there is absolutely
     // no contextual information to resolve type of `nil`.

lib/Sema/CSDiagnostics.cpp

@@ -7501,6 +7501,19 @@ bool MissingContextualTypeForNil::diagnoseAsError() {
   return true;
 }
 
+bool CouldNotInferPlaceholderType::diagnoseAsError() {
+  // If this placeholder was explicitly written out by the user, they can maybe
+  // fix things by specifying an actual type.
+  if (auto *typeExpr = getAsExpr<TypeExpr>(getAnchor())) {
+    if (typeExpr->getLoc().isValid()) {
+      emitDiagnostic(diag::could_not_infer_placeholder);
+      return true;
+    }
+  }
+
+  return false;
+}
+
 bool ReferenceToInvalidDeclaration::diagnoseAsError() {
   auto &DE = getASTContext().Diags;
 

lib/Sema/CSDiagnostics.h

@@ -2406,6 +2406,21 @@ class MissingContextualTypeForNil final : public FailureDiagnostic {
   bool diagnoseAsError() override;
 };
 
+/// Diagnose situations where there is no context to determine the type of a
+/// placeholder, e.g.,
+///
+/// \code
+/// let _ = _.foo
+/// \endcode
+class CouldNotInferPlaceholderType final : public FailureDiagnostic {
+public:
+  CouldNotInferPlaceholderType(const Solution &solution,
+                               ConstraintLocator *locator)
+      : FailureDiagnostic(solution, locator) {}
+
+  bool diagnoseAsError() override;
+};
+
 /// Diagnostic situations where AST node references an invalid declaration.
 ///
 /// \code

lib/Sema/CSFix.cpp

@@ -1750,6 +1750,18 @@ SpecifyContextualTypeForNil::create(ConstraintSystem &cs,
   return new (cs.getAllocator()) SpecifyContextualTypeForNil(cs, locator);
 }
 
+bool SpecifyTypeForPlaceholder::diagnose(const Solution &solution,
+                                           bool asNote) const {
+  CouldNotInferPlaceholderType failure(solution, getLocator());
+  return failure.diagnose(asNote);
+}
+
+SpecifyTypeForPlaceholder *
+SpecifyTypeForPlaceholder::create(ConstraintSystem &cs,
+                                  ConstraintLocator *locator) {
+  return new (cs.getAllocator()) SpecifyTypeForPlaceholder(cs, locator);
+}
+
 bool AllowRefToInvalidDecl::diagnose(const Solution &solution,
                                      bool asNote) const {
   ReferenceToInvalidDeclaration failure(solution, getLocator());

lib/Sema/CSSimplify.cpp

@@ -11484,7 +11484,8 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::AllowAlwaysSucceedCheckedCast:
   case FixKind::AllowInvalidStaticMemberRefOnProtocolMetatype:
   case FixKind::AllowWrappedValueMismatch:
-  case FixKind::RemoveExtraneousArguments: {
+  case FixKind::RemoveExtraneousArguments:
+  case FixKind::SpecifyTypeForPlaceholder: {
     return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
   }