[Diagnostics] Change FailureDiagnostic::resolveType to replace

holes with generic parameters directly when possible.

Author: hborla

lib/Sema/CSDiagnostics.h

@@ -98,12 +98,23 @@ class FailureDiagnostic {
   /// Resolve type variables present in the raw type, if any.
   Type resolveType(Type rawType, bool reconstituteSugar = false,
                    bool wantRValue = true) const {
-    auto resolvedType = CS.simplifyType(rawType, /*forDiagnostics*/true);
-
-    if (reconstituteSugar)
-      resolvedType = resolvedType->reconstituteSugar(/*recursive*/ true);
+    if (!rawType->hasTypeVariable()) {
+      if (reconstituteSugar)
+        rawType = rawType->reconstituteSugar(/*recursive*/ true);
+      return wantRValue ? rawType->getRValueType() : rawType;
+    }
 
-    return wantRValue ? resolvedType->getRValueType() : resolvedType;
+    auto &cs = getConstraintSystem();
+    return cs.simplifyTypeImpl(rawType,
+        [&](TypeVariableType *typeVar) -> Type {
+          if (auto fixed = cs.getFixedType(typeVar)) {
+            auto *genericParam = typeVar->getImpl().getGenericParameter();
+            if (fixed->isHole() && genericParam)
+                return genericParam;
+            return resolveType(fixed, reconstituteSugar, wantRValue);
+          }
+          return cs.getRepresentative(typeVar);
+        });
   }
 
   /// Resolve type variables present in the raw type, using generic parameter

lib/Sema/ConstraintSystem.cpp

@@ -2250,9 +2250,8 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
   }
 }
 
-template <typename Fn>
-Type simplifyTypeImpl(const ConstraintSystem &cs, Type type,
-                      Fn getFixedTypeFn) {
+Type ConstraintSystem::simplifyTypeImpl(Type type,
+    llvm::function_ref<Type(TypeVariableType *)> getFixedTypeFn) const {
   return type.transform([&](Type type) -> Type {
     if (auto tvt = dyn_cast<TypeVariableType>(type.getPointer()))
       return getFixedTypeFn(tvt);
@@ -2261,7 +2260,7 @@ Type simplifyTypeImpl(const ConstraintSystem &cs, Type type,
     // the base to a non-type-variable, perform lookup.
     if (auto depMemTy = dyn_cast<DependentMemberType>(type.getPointer())) {
       // Simplify the base.
-      Type newBase = simplifyTypeImpl(cs, depMemTy->getBase(), getFixedTypeFn);
+      Type newBase = simplifyTypeImpl(depMemTy->getBase(), getFixedTypeFn);
 
       // If nothing changed, we're done.
       if (newBase.getPointer() == depMemTy->getBase().getPointer())
@@ -2279,7 +2278,7 @@ Type simplifyTypeImpl(const ConstraintSystem &cs, Type type,
 
       if (lookupBaseType->mayHaveMembers()) {
         auto *proto = assocType->getProtocol();
-        auto conformance = cs.DC->getParentModule()->lookupConformance(
+        auto conformance = DC->getParentModule()->lookupConformance(
           lookupBaseType, proto);
         if (!conformance)
           return DependentMemberType::get(lookupBaseType, assocType);
@@ -2298,21 +2297,15 @@ Type simplifyTypeImpl(const ConstraintSystem &cs, Type type,
   });
 }
 
-Type ConstraintSystem::simplifyType(Type type, bool forDiagnostics) const {
+Type ConstraintSystem::simplifyType(Type type) const {
   if (!type->hasTypeVariable())
     return type;
 
   // Map type variables down to the fixed types of their representatives.
-  return simplifyTypeImpl(
-      *this, type,
+  return simplifyTypeImpl(type,
       [&](TypeVariableType *tvt) -> Type {
-        if (auto fixed = getFixedType(tvt)) {
-          if (forDiagnostics && fixed->isHole() &&
-              tvt->getImpl().getLocator()->isForGenericParameter())
-            return tvt->getImpl().getLocator()->getGenericParameter();
-
+        if (auto fixed = getFixedType(tvt))
           return simplifyType(fixed);
-        }
 
         return getRepresentative(tvt);
       });
@@ -2323,8 +2316,7 @@ Type Solution::simplifyType(Type type) const {
     return type;
 
   // Map type variables to fixed types from bindings.
-  return simplifyTypeImpl(
-      getConstraintSystem(), type,
+  return getConstraintSystem().simplifyTypeImpl(type,
       [&](TypeVariableType *tvt) -> Type {
         auto known = typeBindings.find(tvt);
         assert(known != typeBindings.end());

lib/Sema/ConstraintSystem.h

@@ -986,7 +986,8 @@ class ConstraintSystem {
   DeclContext *DC;
   ConstraintSystemOptions Options;
   Optional<ExpressionTimer> Timer;
-  
+
+  friend class Solution;
   friend class ConstraintFix;
   friend class OverloadChoice;
   friend class ConstraintGraph;
@@ -3033,7 +3034,7 @@ class ConstraintSystem {
   ///
   /// The resulting types can be compared canonically, so long as additional
   /// type equivalence requirements aren't introduced between comparisons.
-  Type simplifyType(Type type, bool forDiagnostics = false) const;
+  Type simplifyType(Type type) const;
 
   /// Simplify a type, by replacing type variables with either their
   /// fixed types (if available) or their representatives.
@@ -3073,6 +3074,11 @@ class ConstraintSystem {
   isConversionEphemeral(ConversionRestrictionKind conversion,
                         ConstraintLocatorBuilder locator);
 
+  /// Simplifies a type by replacing type variables with the result of
+  /// \c getFixedTypeFn and performing lookup on dependent member types.
+  Type simplifyTypeImpl(Type type,
+      llvm::function_ref<Type(TypeVariableType *)> getFixedTypeFn) const;
+
   /// Attempt to simplify the given construction constraint.
   ///
   /// \param valueType The type being constructed.