[Diagnostics] Preserve raw from/to types in contextual mismatch diagnostic

This is useful in some situations where access to type variable(s)
helps to diagnose the problem properly e.g. if it's a conversion
to generic parameter.

Author: xedin

lib/Sema/CSDiagnostics.cpp

@@ -2032,6 +2032,9 @@ bool ContextualFailure::diagnoseAsError() {
     return true;
   }
 
+  auto fromType = getFromType();
+  auto toType = getToType();
+
   Diag<Type, Type> diagnostic;
   switch (path.back().getKind()) {
   case ConstraintLocator::ClosureResult: {
@@ -2040,9 +2043,8 @@ bool ContextualFailure::diagnoseAsError() {
         closure->getExplicitResultTypeLoc().getTypeRepr()) {
       auto resultRepr = closure->getExplicitResultTypeLoc().getTypeRepr();
       emitDiagnostic(resultRepr->getStartLoc(),
-                     diag::incorrect_explicit_closure_result, getFromType(),
-                     getToType())
-          .fixItReplace(resultRepr->getSourceRange(), getToType().getString());
+                     diag::incorrect_explicit_closure_result, fromType, toType)
+          .fixItReplace(resultRepr->getSourceRange(), toType.getString());
       return true;
     }
 
@@ -2071,22 +2073,21 @@ bool ContextualFailure::diagnoseAsError() {
       return true;
 
     if (CTP == CTP_ForEachStmt) {
-      if (FromType->isAnyExistentialType()) {
+      if (fromType->isAnyExistentialType()) {
         emitDiagnostic(anchor->getLoc(), diag::type_cannot_conform,
-                       /*isExistentialType=*/true, FromType, ToType);
+                       /*isExistentialType=*/true, fromType, toType);
         return true;
       }
 
       emitDiagnostic(
           anchor->getLoc(),
           diag::foreach_sequence_does_not_conform_to_expected_protocol,
-          FromType, ToType, bool(FromType->getOptionalObjectType()))
+          fromType, toType, bool(fromType->getOptionalObjectType()))
           .highlight(anchor->getSourceRange());
       return true;
     }
 
-    auto contextualType = getToType();
-    if (auto msg = getDiagnosticFor(CTP, contextualType->isExistentialType())) {
+    if (auto msg = getDiagnosticFor(CTP, toType->isExistentialType())) {
       diagnostic = *msg;
       break;
     }
@@ -2102,11 +2103,11 @@ bool ContextualFailure::diagnoseAsError() {
       return false;
 
     auto *choice = overload->choice.getDecl();
-    auto fnType = FromType->getAs<FunctionType>();
+    auto fnType = fromType->getAs<FunctionType>();
     if (!fnType) {
       emitDiagnostic(anchor->getLoc(),
                      diag::expected_result_in_contextual_member,
-                     choice->getFullName(), FromType, ToType);
+                     choice->getFullName(), fromType, toType);
       return true;
     }
 
@@ -2151,7 +2152,8 @@ bool ContextualFailure::diagnoseAsError() {
     return false;
   }
 
-  auto diag = emitDiagnostic(anchor->getLoc(), diagnostic, FromType, ToType);
+  auto diag =
+      emitDiagnostic(anchor->getLoc(), diagnostic, fromType, toType);
   diag.highlight(anchor->getSourceRange());
 
   (void)tryFixIts(diag);
@@ -2357,12 +2359,13 @@ bool ContextualFailure::diagnoseMissingFunctionCall() const {
   if (getLocator()->isLastElement<LocatorPathElt::RValueAdjustment>())
     return false;
 
-  auto *srcFT = FromType->getAs<FunctionType>();
+  auto *srcFT = getFromType()->getAs<FunctionType>();
   if (!srcFT || !srcFT->getParams().empty())
     return false;
 
-  if (ToType->is<AnyFunctionType>() ||
-      !TypeChecker::isConvertibleTo(srcFT->getResult(), ToType, getDC()))
+  auto toType = getToType();
+  if (toType->is<AnyFunctionType>() ||
+      !TypeChecker::isConvertibleTo(srcFT->getResult(), toType, getDC()))
     return false;
 
   auto *anchor = getAnchor();
@@ -2663,7 +2666,10 @@ bool ContextualFailure::tryRawRepresentableFixIts(
 
 bool ContextualFailure::tryIntegerCastFixIts(
     InFlightDiagnostic &diagnostic) const {
-  if (!isIntegerType(FromType) || !isIntegerType(ToType))
+  auto fromType = getFromType();
+  auto toType = getToType();
+
+  if (!isIntegerType(fromType) || !isIntegerType(toType))
     return false;
 
   auto getInnerCastedExpr = [&](Expr *expr) -> Expr * {
@@ -2684,7 +2690,7 @@ bool ContextualFailure::tryIntegerCastFixIts(
   auto *anchor = getAnchor();
   if (Expr *innerE = getInnerCastedExpr(anchor)) {
     Type innerTy = getType(innerE);
-    if (TypeChecker::isConvertibleTo(innerTy, ToType, getDC())) {
+    if (TypeChecker::isConvertibleTo(innerTy, toType, getDC())) {
       // Remove the unnecessary cast.
       diagnostic.fixItRemoveChars(anchor->getLoc(), innerE->getStartLoc())
           .fixItRemove(anchor->getEndLoc());
@@ -2693,7 +2699,7 @@ bool ContextualFailure::tryIntegerCastFixIts(
   }
 
   // Add a wrapping integer cast.
-  std::string convWrapBefore = ToType.getString();
+  std::string convWrapBefore = toType.getString();
   convWrapBefore += "(";
   std::string convWrapAfter = ")";
   SourceRange exprRange = anchor->getSourceRange();
@@ -2715,8 +2721,8 @@ bool ContextualFailure::trySequenceSubsequenceFixIts(
 
   // Substring -> String conversion
   // Wrap in String.init
-  if (FromType->isEqual(Substring)) {
-    if (ToType->isEqual(String)) {
+  if (getFromType()->isEqual(Substring)) {
+    if (getToType()->isEqual(String)) {
       auto *anchor = getAnchor()->getSemanticsProvidingExpr();
       auto range = anchor->getSourceRange();
       diagnostic.fixItInsert(range.Start, "String(");
@@ -2775,10 +2781,11 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
   if (!nominal)
     return false;
 
+  auto fromType = getFromType();
   // We need to get rid of optionals and parens as it's not relevant when
   // printing the diagnostic and the fix-it.
   auto unwrappedToType =
-      ToType->lookThroughAllOptionalTypes()->getWithoutParens();
+      getToType()->lookThroughAllOptionalTypes()->getWithoutParens();
 
   // If the protocol requires a class & we don't have one (maybe the context
   // is a struct), then bail out instead of offering a broken fix-it later on.
@@ -2789,13 +2796,13 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
     requiresClass = layout.requiresClass();
   }
 
-  if (requiresClass && !FromType->is<ClassType>()) {
+  if (requiresClass && !fromType->is<ClassType>()) {
     return false;
   }
 
   // We can only offer a fix-it if we're assigning to a protocol type and
   // the type we're assigning is the same as the innermost type context.
-  bool shouldOfferFixIt = nominal->getSelfTypeInContext()->isEqual(FromType) &&
+  bool shouldOfferFixIt = nominal->getSelfTypeInContext()->isEqual(fromType) &&
                           unwrappedToType->isExistentialType();
   if (!shouldOfferFixIt)
     return false;
@@ -2805,7 +2812,7 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
   // Let's build a list of protocols that the context does not conform to.
   SmallVector<std::string, 8> missingProtoTypeStrings;
   for (auto protocol : layout.getProtocols()) {
-    if (!TypeChecker::conformsToProtocol(FromType, protocol->getDecl(), getDC(),
+    if (!TypeChecker::conformsToProtocol(fromType, protocol->getDecl(), getDC(),
                                          ConformanceCheckFlags::InExpression)) {
       missingProtoTypeStrings.push_back(protocol->getString());
     }
@@ -2833,7 +2840,7 @@ bool ContextualFailure::tryProtocolConformanceFixIt(
   // TODO: Maybe also insert the requirement stubs?
   auto conformanceDiag = emitDiagnostic(
       getAnchor()->getLoc(), diag::assign_protocol_conformance_fix_it,
-      unwrappedToType, nominal->getDescriptiveKind(), FromType);
+      unwrappedToType, nominal->getDescriptiveKind(), fromType);
   if (nominal->getInherited().size() > 0) {
     auto lastInherited = nominal->getInherited().back().getLoc();
     auto lastInheritedEndLoc =

lib/Sema/CSDiagnostics.h

@@ -694,23 +694,26 @@ class AssignmentFailure final : public FailureDiagnostic {
 /// e.g. argument/parameter, closure result, conversions etc.
 class ContextualFailure : public FailureDiagnostic {
   ContextualTypePurpose CTP;
-  Type FromType, ToType;
+  Type RawFromType, RawToType;
 
 public:
   ContextualFailure(ConstraintSystem &cs, Type lhs, Type rhs,
                     ConstraintLocator *locator)
       : ContextualFailure(cs, cs.getContextualTypePurpose(), lhs, rhs,
                           locator) {}
 
-  ContextualFailure(ConstraintSystem &cs,
-                    ContextualTypePurpose purpose, Type lhs, Type rhs,
-                    ConstraintLocator *locator)
-      : FailureDiagnostic(cs, locator), CTP(purpose),
-        FromType(resolve(lhs)), ToType(resolve(rhs)) {}
+  ContextualFailure(ConstraintSystem &cs, ContextualTypePurpose purpose,
+                    Type lhs, Type rhs, ConstraintLocator *locator)
+      : FailureDiagnostic(cs, locator), CTP(purpose), RawFromType(lhs),
+        RawToType(rhs) {}
+
+  Type getFromType() const { return resolve(RawFromType); }
+
+  Type getToType() const { return resolve(RawToType); }
 
-  Type getFromType() const { return FromType; }
+  Type getRawFromType() const { return RawFromType; }
 
-  Type getToType() const { return ToType; }
+  Type getRawToType() const { return RawToType; }
 
   bool diagnoseAsError() override;
 
@@ -791,7 +794,7 @@ class ContextualFailure : public FailureDiagnostic {
                                             Type contextualType);
 
 private:
-  Type resolve(Type rawType) {
+  Type resolve(Type rawType) const {
     return resolveType(rawType)->getWithoutSpecifierType();
   }