[RequirementMachine] Use PropertyMap::getTypeFromSubstitutionSchema when

computing a concrete same-type or superclass for conflict diagnostics.

Otherwise, diagnostics will show fresh type parameters when the concrete
type is generic.

Author: hborla

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -754,15 +754,23 @@ void RewriteSystem::freeze() {
 }
 
 static Optional<Requirement>
-getRequirementForDiagnostics(Type subject, Symbol property) {
+getRequirementForDiagnostics(Type subject, Symbol property,
+                             const PropertyMap &map,
+                             TypeArrayView<GenericTypeParamType> genericParams) {
   switch (property.getKind()) {
-  case Symbol::Kind::ConcreteType:
-    return Requirement(RequirementKind::SameType, subject,
-                       property.getConcreteType());
+  case Symbol::Kind::ConcreteType: {
+    auto concreteType = map.getTypeFromSubstitutionSchema(
+        property.getConcreteType(), property.getSubstitutions(),
+        genericParams, MutableTerm());
+    return Requirement(RequirementKind::SameType, subject, concreteType);
+  }
 
-  case Symbol::Kind::Superclass:
-    return Requirement(RequirementKind::Superclass, subject,
-                       property.getConcreteType());
+  case Symbol::Kind::Superclass: {
+    auto concreteType = map.getTypeFromSubstitutionSchema(
+        property.getConcreteType(), property.getSubstitutions(),
+        genericParams, MutableTerm());
+    return Requirement(RequirementKind::Superclass, subject, concreteType);
+  }
 
   case Symbol::Kind::Protocol:
     return Requirement(RequirementKind::Conformance, subject,
@@ -785,14 +793,11 @@ void RewriteSystem::computeConflictDiagnostics(
     const auto &firstRule = getRule(pair.first);
     const auto &secondRule = getRule(pair.second);
 
-    auto firstProperty = firstRule.isPropertyRule();
-    auto secondProperty = secondRule.isPropertyRule();
-    assert(firstProperty && secondProperty);
+    assert(firstRule.isPropertyRule() && secondRule.isPropertyRule());
 
-    auto firstTerm = firstRule.getRHS();
-    auto secondTerm = secondRule.getRHS();
-    auto subjectTerm =
-        firstTerm.size() > secondTerm.size() ? firstTerm : secondTerm;
+    bool chooseFirstRule = firstRule.getRHS().size() > secondRule.getRHS().size();
+    auto subjectRule = chooseFirstRule ? firstRule : secondRule;
+    auto subjectTerm = subjectRule.getRHS();
 
     // If the root protocol of the subject term isn't in this minimization
     // domain, the conflict was already diagnosed.
@@ -801,8 +806,10 @@ void RewriteSystem::computeConflictDiagnostics(
 
     Type subject = propertyMap.getTypeForTerm(subjectTerm, genericParams);
     errors.push_back(RequirementError::forConflictingRequirement(
-        *getRequirementForDiagnostics(subject, *firstProperty),
-        *getRequirementForDiagnostics(subject, *secondProperty),
+        *getRequirementForDiagnostics(subject, *firstRule.isPropertyRule(),
+                                      propertyMap, genericParams),
+        *getRequirementForDiagnostics(subject, *secondRule.isPropertyRule(),
+                                      propertyMap, genericParams),
         signatureLoc));
   }
 }

test/Generics/requirement_machine_diagnostics.swift

@@ -305,4 +305,19 @@ func sameTypeConflicts() {
 
   // expected-error@+1{{no type for 'T.X' can satisfy both 'T.X == Int' and 'T.X == String'}}
   func fail6<U, T: Concrete>(_: U, _: T) where T.X == String {}
+
+  struct G<T> {}
+
+  // FIXME: conflict diagnosed twice
+  // expected-error@+1 2{{no type for 'T.X' can satisfy both 'T.X == Int' and 'T.X == G<U.Foo>'}}
+  func fail7<U: Fooable, T: Concrete>(_: U, _: T) where T.X == G<U.Foo> {}
+
+  // FIXME: conflict diagnosed twice
+  // expected-error@+2{{no type for 'T' can satisfy both 'T == Int' and 'T == G<U.Foo>'}}
+  // expected-error@+1{{no type for 'T' can satisfy both 'T == G<U.Foo>' and 'T == Int'}}
+  func fail8<T, U: Fooable>(_: U, _: T) where T == G<U.Foo>, T == Int {}
+
+  // FIXME: conflict diagnosed twice
+  // expected-error@+1 2{{no type for 'T' can satisfy both 'T == Int' and 'T == G<U.Foo>'}}
+  func fail9<T, U: Fooable>(_: U, _: T) where T == Int, T == G<U.Foo> {}
 }