Merge pull request #26755 from xedin/port-throws-contextual-mismatch

[Diagnostics] Port tailored contextual diagnostic when thrown type do…

Author: xedin

lib/Sema/CSDiag.cpp

@@ -1683,43 +1683,6 @@ bool FailureDiagnosis::diagnoseContextualConversionError(
   if (isUnresolvedOrTypeVarType(exprType) || exprType->isEqual(contextualType))
     return false;
 
-  // If this is conversion failure due to a return statement with an argument
-  // that cannot be coerced to the result type of the function, emit a
-  // specific error.
-  if (CTP == CTP_ThrowStmt) {
-    // If we tried to throw the error code of an error type, suggest object
-    // construction.
-    auto &TC = CS.getTypeChecker();
-    if (auto errorCodeProtocol =
-            TC.Context.getProtocol(KnownProtocolKind::ErrorCodeProtocol)) {
-      if (auto conformance = TypeChecker::conformsToProtocol(
-              CS.getType(expr), errorCodeProtocol, CS.DC,
-              ConformanceCheckFlags::InExpression)) {
-        Type errorCodeType = CS.getType(expr);
-        Type errorType =
-            conformance
-                ->getTypeWitnessByName(errorCodeType, TC.Context.Id_ErrorType)
-                ->getCanonicalType();
-        if (errorType) {
-          auto diag = diagnose(expr->getLoc(), diag::cannot_throw_error_code,
-                               errorCodeType, errorType);
-          if (auto unresolvedDot = dyn_cast<UnresolvedDotExpr>(expr)) {
-            diag.fixItInsert(unresolvedDot->getDotLoc(), "(");
-            diag.fixItInsertAfter(unresolvedDot->getEndLoc(), ")");
-          }
-          return true;
-        }
-      }
-    }
-
-    // The conversion destination of throw is always ErrorType (at the moment)
-    // if this ever expands, this should be a specific form like () is for
-    // return.
-    diagnose(expr->getLoc(), diag::cannot_convert_thrown_type, exprType)
-        .highlight(expr->getSourceRange());
-    return true;
-  }
-
   if (CTP == CTP_YieldByReference) {
     if (auto contextualLV = contextualType->getAs<LValueType>())
       contextualType = contextualLV->getObjectType();

lib/Sema/CSDiagnostics.cpp

@@ -1882,6 +1882,9 @@ bool ContextualFailure::diagnoseAsError() {
     if (diagnoseConversionToBool())
       return true;
 
+    if (diagnoseThrowsTypeMismatch())
+      return true;
+
     auto contextualType = getToType();
     if (auto msg = getDiagnosticFor(CTP, contextualType->isExistentialType())) {
       diagnostic = *msg;
@@ -2191,6 +2194,50 @@ bool ContextualFailure::diagnoseConversionToDictionary() const {
   return true;
 }
 
+bool ContextualFailure::diagnoseThrowsTypeMismatch() const {
+  // If this is conversion failure due to a return statement with an argument
+  // that cannot be coerced to the result type of the function, emit a
+  // specific error.
+  if (CTP != CTP_ThrowStmt)
+    return false;
+
+  auto *anchor = getAnchor();
+
+  // If we tried to throw the error code of an error type, suggest object
+  // construction.
+  auto &TC = getTypeChecker();
+  if (auto errorCodeProtocol =
+          TC.Context.getProtocol(KnownProtocolKind::ErrorCodeProtocol)) {
+    Type errorCodeType = getFromType();
+    if (auto conformance = TypeChecker::conformsToProtocol(
+            errorCodeType, errorCodeProtocol, getDC(),
+            ConformanceCheckFlags::InExpression)) {
+      Type errorType = conformance
+                           ->getTypeWitnessByName(errorCodeType,
+                                                  getASTContext().Id_ErrorType)
+                           ->getCanonicalType();
+      if (errorType) {
+        auto diagnostic =
+            emitDiagnostic(anchor->getLoc(), diag::cannot_throw_error_code,
+                           errorCodeType, errorType);
+        if (auto *UDE = dyn_cast<UnresolvedDotExpr>(anchor)) {
+          diagnostic.fixItInsert(UDE->getDotLoc(), "(");
+          diagnostic.fixItInsertAfter(UDE->getEndLoc(), ")");
+        }
+        return true;
+      }
+    }
+  }
+
+  // The conversion destination of throw is always ErrorType (at the moment)
+  // if this ever expands, this should be a specific form like () is for
+  // return.
+  emitDiagnostic(anchor->getLoc(), diag::cannot_convert_thrown_type,
+                 getFromType())
+      .highlight(anchor->getSourceRange());
+  return true;
+}
+
 bool ContextualFailure::tryRawRepresentableFixIts(
     InFlightDiagnostic &diagnostic,
     KnownProtocolKind rawRepresentableProtocol) const {

lib/Sema/CSDiagnostics.h

@@ -629,6 +629,10 @@ class ContextualFailure : public FailureDiagnostic {
   /// or convert an array literal to a dictionary e.g. `let _: [String: Int] = ["A", 0]`
   bool diagnoseConversionToDictionary() const;
 
+  /// Produce a specialized diagnostic if this is an attempt to throw
+  /// something with doesn't conform to `Error`.
+  bool diagnoseThrowsTypeMismatch() const;
+
   /// Attempt to attach any relevant fix-its to already produced diagnostic.
   void tryFixIts(InFlightDiagnostic &diagnostic) const;
 

lib/Sema/CSSimplify.cpp

@@ -3831,14 +3831,23 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
       return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
     }
 
+    if (path.empty())
+      return SolutionKind::Error;
+
+    // If this is a conformance failure related to a contextual type
+    // let's record it as a "contextual mismatch" because diagnostic
+    // is going to be dependent on other contextual information.
+    if (path.back().is<LocatorPathElt::ContextualType>()) {
+      auto *fix = ContextualMismatch::create(*this, type, protocolTy,
+                                             getConstraintLocator(locator));
+      return recordFix(fix) ? SolutionKind::Error : SolutionKind::Solved;
+    }
+
     // Let's not try to fix missing conformance for Void
     // or Never because that doesn't really make sense.
     if (type->isVoid() || type->isUninhabited())
       return SolutionKind::Error;
 
-    if (path.empty())
-      return SolutionKind::Error;
-
     if (path.back().is<LocatorPathElt::AnyRequirement>()) {
       if (auto *fix =
               fixRequirementFailure(*this, type, protocolTy, anchor, path)) {