[RequirementMachine] Add a RequirementError for diagnosing a conflicting

same-type requirement.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -2491,6 +2491,9 @@ ERROR(recursive_superclass_constraint,none,
 ERROR(requires_generic_param_same_type_does_not_conform,none,
       "same-type constraint type %0 does not conform to required protocol %1",
       (Type, Identifier))
+ERROR(same_type_does_not_inherit,none,
+      "same-type constraint type %0 does not inherit from required superclass %1",
+      (Type, Type))
 ERROR(requires_same_concrete_type,none,
       "generic signature requires types %0 and %1 to be the same", (Type, Type))
 WARNING(redundant_conformance_constraint,none,

lib/AST/RequirementMachine/Diagnostics.h

@@ -34,6 +34,8 @@ struct RequirementError {
     ConcreteTypeMismatch,
     /// A requirement proven to be false, e.g. Bool: Collection
     ConflictingRequirement,
+    /// A missing requirement on a concrete type in a same-type requirement.
+    SameTypeMissingRequirement,
     /// A redundant requirement, e.g. T == T.
     RedundantRequirement,
   } kind;
@@ -67,6 +69,11 @@ struct RequirementError {
     return {Kind::ConflictingRequirement, req, loc};
   }
 
+  static RequirementError forSameTypeMissingRequirement(Requirement req,
+                                                        SourceLoc loc) {
+    return {Kind::SameTypeMissingRequirement, req, loc};
+  }
+
   static RequirementError forRedundantRequirement(Requirement req,
                                                   SourceLoc loc) {
     return {Kind::RedundantRequirement, req, loc};

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -736,6 +736,35 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
+    case RequirementError::Kind::SameTypeMissingRequirement: {
+      auto requirement = error.requirement;
+      switch (requirement.getKind()) {
+      case RequirementKind::SameType:
+        // FIXME: This case should be diagnosed through `ConcreteTypeMismatch`.
+        break;
+      case RequirementKind::Conformance:
+        ctx.Diags.diagnose(loc, diag::requires_generic_param_same_type_does_not_conform,
+                           requirement.getFirstType(),
+                           requirement.getProtocolDecl()->getName());
+        diagnosedError = true;
+        break;
+      case RequirementKind::Superclass:
+        ctx.Diags.diagnose(loc, diag::same_type_does_not_inherit,
+                           requirement.getFirstType(),
+                           requirement.getSecondType());
+        diagnosedError = true;
+        break;
+      case RequirementKind::Layout:
+        ctx.Diags.diagnose(loc, diag::requires_generic_param_same_type_does_not_conform,
+                           requirement.getFirstType(),
+                           ctx.getIdentifier(requirement.getLayoutConstraint()->getName()));
+        diagnosedError = true;
+        break;
+      }
+
+      break;
+    }
+
     case RequirementError::Kind::RedundantRequirement: {
       auto requirement = error.requirement;
       switch (requirement.getKind()) {