[Constraint system] Custom diagnostics for failed pattern matches.

Extend the constraint system’s diagnostics with specific handling for
matching an enum element pattern that has a subpattern (i.e., to capture
associated values) against an enum case that does not have any associated
value. This brings diagnostics for the new code path on par with the existing
diagnostics of coercePatternToType.

Author: DougGregor

lib/Sema/CSDiagnostics.cpp

@@ -2264,14 +2264,32 @@ bool ContextualFailure::diagnoseMissingFunctionCall() const {
     return false;
 
   auto *srcFT = getFromType()->getAs<FunctionType>();
-  if (!srcFT || !srcFT->getParams().empty())
+  if (!srcFT ||
+      !(srcFT->getParams().empty() ||
+        getLocator()->isLastElement<LocatorPathElt::PatternMatch>()))
     return false;
 
   auto toType = getToType();
   if (toType->is<AnyFunctionType>() ||
       !TypeChecker::isConvertibleTo(srcFT->getResult(), toType, getDC()))
     return false;
 
+  // Diagnose cases where the pattern tried to match associated values but
+  // the case we found had none.
+  if (auto match =
+          getLocator()->getLastElementAs<LocatorPathElt::PatternMatch>()) {
+    if (auto enumElementPattern =
+            dyn_cast<EnumElementPattern>(match->getPattern())) {
+      emitDiagnostic(enumElementPattern->getNameLoc(),
+                     diag::enum_element_pattern_assoc_values_mismatch,
+                     enumElementPattern->getName());
+      emitDiagnostic(enumElementPattern->getNameLoc(),
+                     diag::enum_element_pattern_assoc_values_remove)
+        .fixItRemove(enumElementPattern->getSubPattern()->getSourceRange());
+      return true;
+    }
+  }
+
   auto *anchor = getAnchor();
   emitDiagnostic(anchor->getLoc(), diag::missing_nullary_call,
                  srcFT->getResult())

lib/Sema/CSGen.cpp

@@ -2336,7 +2336,7 @@ namespace {
           CS.addValueMemberConstraint(
               parentMetaType, enumPattern->getName(), memberType, CurDC,
               functionRefKind, { },
-              locator.withPathElement(ConstraintLocator::PatternMatch));
+              locator.withPathElement(LocatorPathElt::PatternMatch(pattern)));
 
           // Parent type needs to be convertible to the pattern type; this
           // accounts for cases where the pattern type is existential.
@@ -2349,7 +2349,7 @@ namespace {
           CS.addUnresolvedValueMemberConstraint(
               MetatypeType::get(patternType), enumPattern->getName(),
               memberType, CurDC, functionRefKind,
-              locator.withPathElement(ConstraintLocator::PatternMatch));
+              locator.withPathElement(LocatorPathElt::PatternMatch(pattern)));
 
           baseType = patternType;
         }
@@ -2372,8 +2372,9 @@ namespace {
               CS.getConstraintLocator(locator),
               TVO_CanBindToNoEscape);
           Type functionType = FunctionType::get(params, outputType);
-          CS.addConstraint(ConstraintKind::Equal, functionType, memberType,
-                           locator);
+          CS.addConstraint(
+              ConstraintKind::Equal, functionType, memberType,
+              locator.withPathElement(LocatorPathElt::PatternMatch(pattern)));
 
           CS.addConstraint(ConstraintKind::Conversion, outputType, baseType,
                            locator);

lib/Sema/CSSimplify.cpp

@@ -3920,6 +3920,25 @@ bool ConstraintSystem::repairFailures(
     break;
   }
 
+  case ConstraintLocator::PatternMatch: {
+    // If either type is a hole, consider this fixed.
+    if (lhs->isHole() || rhs->isHole())
+      return true;
+
+    // If the left-hand side is a function type and the pattern is an enum
+    // element pattern, call it a contextual mismatch.
+    auto pattern = elt.castTo<LocatorPathElt::PatternMatch>().getPattern();
+    if (lhs->is<FunctionType>() && isa<EnumElementPattern>(pattern)) {
+      markAnyTypeVarsAsPotentialHoles(lhs);
+      markAnyTypeVarsAsPotentialHoles(rhs);
+
+      conversionsOrFixes.push_back(ContextualMismatch::create(
+          *this, lhs, rhs, getConstraintLocator(locator)));
+    }
+
+    break;
+  }
+
   default:
     break;
   }
@@ -6043,7 +6062,7 @@ performMemberLookup(ConstraintKind constraintKind, DeclNameRef memberName,
   // match, unwrap optionals and try again to allow implicit creation of
   // optional "some" patterns (spelled "?").
   if (result.ViableCandidates.empty() && result.UnviableCandidates.empty() &&
-      memberLocator->getLastElementAs<LocatorPathElt::PatternMatch>() &&
+      memberLocator->isLastElement<LocatorPathElt::PatternMatch>() &&
       instanceTy->getOptionalObjectType() &&
       baseObjTy->is<AnyMetatypeType>()) {
     SmallVector<Type, 2> optionals;

lib/Sema/ConstraintLocator.cpp

@@ -52,6 +52,11 @@ void ConstraintLocator::Profile(llvm::FoldingSetNodeID &id, Expr *anchor,
       id.AddPointer(kpElt.getKeyPathDecl());
       break;
     }
+
+    case PatternMatch:
+      id.AddPointer(elt.castTo<LocatorPathElt::PatternMatch>().getPattern());
+      break;
+
     case GenericArgument:
     case NamedTupleElement:
     case TupleElement:

lib/Sema/ConstraintLocator.h

@@ -68,6 +68,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
     case GenericParameter:
     case ProtocolRequirement:
     case Witness:
+    case PatternMatch:
       return 0;
 
     case ContextualType:
@@ -119,6 +120,7 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       StoredWitness,
       StoredGenericSignature,
       StoredKeyPathDynamicMemberBase,
+      StoredPattern,
       StoredKindAndValue
     };
 
@@ -239,6 +241,9 @@ class ConstraintLocator : public llvm::FoldingSetNode {
       case StoredKeyPathDynamicMemberBase:
         return PathElementKind::KeyPathDynamicMember;
 
+      case StoredPattern:
+        return PathElementKind::PatternMatch;
+
       case StoredKindAndValue:
         return decodeStorage(storage).first;
       }
@@ -803,6 +808,18 @@ class LocatorPathElt::TernaryBranch final : public LocatorPathElt {
   }
 };
 
+class LocatorPathElt::PatternMatch final : public LocatorPathElt {
+public:
+  PatternMatch(Pattern *pattern)
+      : LocatorPathElt(LocatorPathElt::StoredPattern, pattern) {}
+
+  Pattern *getPattern() const { return getStoredPointer<Pattern>(); }
+
+  static bool classof(const LocatorPathElt *elt) {
+    return elt->getKind() == ConstraintLocator::PatternMatch;
+  }
+};
+
 /// A simple stack-only builder object that constructs a
 /// constraint locator without allocating memory.
 ///

lib/Sema/ConstraintLocatorPathElts.def

@@ -176,7 +176,7 @@ SIMPLE_LOCATOR_PATH_ELT(DynamicCallable)
 CUSTOM_LOCATOR_PATH_ELT(TernaryBranch)
 
 /// Performing a pattern patch.
-SIMPLE_LOCATOR_PATH_ELT(PatternMatch)
+CUSTOM_LOCATOR_PATH_ELT(PatternMatch)
 
 #undef LOCATOR_PATH_ELT
 #undef CUSTOM_LOCATOR_PATH_ELT