[CS] Disfavor solutions that were unable to infer the variable type inside a named pattern

We need this to resolve a test failure in optional.swift.

Author: ahoppen

include/swift/Sema/CSFix.h

@@ -298,6 +298,10 @@ enum class FixKind : uint8_t {
   /// Ignore `ErrorExpr` or `ErrorType` during pre-check.
   IgnoreInvalidASTNode,
 
+  /// Ignore a named pattern whose type we couldn't infer. This issue should
+  /// already have been diagnosed elsewhere.
+  IgnoreInvalidNamedPattern,
+
   /// Resolve type of `nil` by providing a contextual type.
   SpecifyContextualTypeForNil,
 
@@ -2742,6 +2746,31 @@ class IgnoreInvalidASTNode final : public ConstraintFix {
   }
 };
 
+class IgnoreInvalidNamedPattern final : public ConstraintFix {
+  IgnoreInvalidNamedPattern(ConstraintSystem &cs, NamedPattern *pattern,
+                            ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::IgnoreInvalidNamedPattern, locator) {}
+
+public:
+  std::string getName() const override {
+    return "specify type for pattern match";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override {
+    return diagnose(*commonFixes.front().first);
+  }
+
+  static IgnoreInvalidNamedPattern *create(ConstraintSystem &cs,
+                                           NamedPattern *pattern,
+                                           ConstraintLocator *locator);
+
+  static bool classof(ConstraintFix *fix) {
+    return fix->getKind() == FixKind::IgnoreInvalidNamedPattern;
+  }
+};
+
 class SpecifyContextualTypeForNil final : public ConstraintFix {
   SpecifyContextualTypeForNil(ConstraintSystem &cs,
                               ConstraintLocator *locator)

include/swift/Sema/ConstraintSystem.h

@@ -640,6 +640,13 @@ T *getAsStmt(ASTNode node) {
   return nullptr;
 }
 
+template <typename T = Pattern>
+T *getAsPattern(ASTNode node) {
+  if (auto *P = node.dyn_cast<Pattern *>())
+    return dyn_cast_or_null<T>(P);
+  return nullptr;
+}
+
 SourceLoc getLoc(ASTNode node);
 SourceRange getSourceRange(ASTNode node);
 

lib/Sema/CSBindings.cpp

@@ -1989,6 +1989,20 @@ TypeVariableBinding::fixForHole(ConstraintSystem &cs) const {
     return std::make_pair(fix, /*impact=*/(unsigned)10);
   }
 
+  if (auto pattern = getAsPattern<NamedPattern>(dstLocator->getAnchor())) {
+    if (dstLocator->getPath().size() == 1 &&
+        dstLocator->isLastElement<LocatorPathElt::NamedPatternDecl>()) {
+      // Not being able to infer the type of a variable in a pattern binding
+      // decl is more dramatic than anything that could happen inside the
+      // expression because we want to preferrably point the diagnostic to a
+      // part of the expression that caused us to be unable to infer the
+      // variable's type.
+      ConstraintFix *fix =
+          IgnoreInvalidNamedPattern::create(cs, pattern, dstLocator);
+      return std::make_pair(fix, /*impact=*/(unsigned)100);
+    }
+  }
+
   return None;
 }
 

lib/Sema/CSFix.cpp

@@ -2004,6 +2004,20 @@ IgnoreResultBuilderWithReturnStmts::create(ConstraintSystem &cs, Type builderTy,
       IgnoreResultBuilderWithReturnStmts(cs, builderTy, locator);
 }
 
+bool IgnoreInvalidNamedPattern::diagnose(const Solution &solution,
+                                         bool asNote) const {
+  // Not being able to infer the type of a pattern should already have been
+  // diagnosed on the pattern's initializer or as a structural issue of the AST.
+  return true;
+}
+
+IgnoreInvalidNamedPattern *
+IgnoreInvalidNamedPattern::create(ConstraintSystem &cs, NamedPattern *pattern,
+                                  ConstraintLocator *locator) {
+  return new (cs.getAllocator())
+      IgnoreInvalidNamedPattern(cs, pattern, locator);
+}
+
 bool SpecifyBaseTypeForOptionalUnresolvedMember::diagnose(
     const Solution &solution, bool asNote) const {
   MemberMissingExplicitBaseTypeFailure failure(solution, MemberName,

lib/Sema/CSSimplify.cpp

@@ -12941,6 +12941,9 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
   case FixKind::IgnoreInvalidASTNode: {
     return recordFix(fix, 10) ? SolutionKind::Error : SolutionKind::Solved;
   }
+  case FixKind::IgnoreInvalidNamedPattern: {
+    return recordFix(fix, 100) ? SolutionKind::Error : SolutionKind::Solved;
+  }
 
   case FixKind::ExplicitlyConstructRawRepresentable: {
     // Let's increase impact of this fix for binary operators because