[RequirementMachine] Consolidate the various RequirementError::Kind cases

that represent conflict diagnostics.

Author: hborla

lib/AST/RequirementMachine/Diagnostics.h

@@ -30,12 +30,11 @@ struct RequirementError {
   enum class Kind {
     /// A constraint to a non-protocol, non-class type, e.g. T: Int.
     InvalidTypeRequirement,
-    /// A type mismatch, e.g. Int == String.
-    ConcreteTypeMismatch,
-    /// A requirement proven to be false, e.g. Bool: Collection
+    /// A type requirement on a trivially invalid subject type,
+    /// e.g. Bool: Collection.
+    InvalidRequirementSubject,
+    /// A pair of conflicting requirements, T == Int, T == String
     ConflictingRequirement,
-    /// A missing requirement on a concrete type in a same-type requirement.
-    SameTypeMissingRequirement,
     /// A redundant requirement, e.g. T == T.
     RedundantRequirement,
   } kind;
@@ -69,11 +68,9 @@ struct RequirementError {
     return {Kind::InvalidTypeRequirement, requirement, loc};
   }
 
-  static RequirementError forConcreteTypeMismatch(Type type1,
-                                                  Type type2,
-                                                  SourceLoc loc) {
-    Requirement requirement(RequirementKind::SameType, type1, type2);
-    return {Kind::ConcreteTypeMismatch, requirement, loc};
+  static RequirementError forInvalidRequirementSubject(Requirement req,
+                                                       SourceLoc loc) {
+    return {Kind::InvalidRequirementSubject, req, loc};
   }
 
   static RequirementError forConflictingRequirement(Requirement req,
@@ -87,11 +84,6 @@ struct RequirementError {
     return {Kind::ConflictingRequirement, typeParameter, 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

@@ -213,10 +213,8 @@ static void desugarSameTypeRequirement(Type lhs, Type rhs, SourceLoc loc,
         return true;
       }
 
-      errors.push_back(
-          RequirementError::forConcreteTypeMismatch(sugaredFirstType,
-                                                    secondType,
-                                                    loc));
+      errors.push_back(RequirementError::forConflictingRequirement(
+          {RequirementKind::SameType, sugaredFirstType, secondType}, loc));
       recordedErrors = true;
       return true;
     }
@@ -249,7 +247,7 @@ static void desugarSuperclassRequirement(Type subjectType,
           RequirementError::forRedundantRequirement(requirement, loc));
     } else {
       errors.push_back(
-          RequirementError::forConflictingRequirement(requirement, loc));
+          RequirementError::forInvalidRequirementSubject(requirement, loc));
     }
 
     return;
@@ -271,7 +269,7 @@ static void desugarLayoutRequirement(Type subjectType,
           RequirementError::forRedundantRequirement(requirement, loc));
     } else {
       errors.push_back(
-          RequirementError::forConflictingRequirement(requirement, loc));
+          RequirementError::forInvalidRequirementSubject(requirement, loc));
     }
 
     return;
@@ -295,7 +293,7 @@ static void desugarConformanceRequirement(Type subjectType, Type constraintType,
       auto *module = protoDecl->getParentModule();
       auto conformance = module->lookupConformance(subjectType, protoDecl);
       if (conformance.isInvalid()) {
-        errors.push_back(RequirementError::forConflictingRequirement(
+        errors.push_back(RequirementError::forInvalidRequirementSubject(
             {RequirementKind::Conformance, subjectType, constraintType}, loc));
         return;
       }
@@ -712,38 +710,7 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
-    case RequirementError::Kind::ConcreteTypeMismatch: {
-      auto type1 = error.requirement.getFirstType();
-      auto type2 = error.requirement.getSecondType();
-
-      if (!type1->hasError() && !type2->hasError()) {
-        ctx.Diags.diagnose(loc, diag::requires_same_concrete_type,
-                           type1, type2);
-        diagnosedError = true;
-      }
-
-      break;
-    }
-
-    case RequirementError::Kind::ConflictingRequirement: {
-      // FIXME: Unify this case with SameTypeMissingRequirement.
-      if (auto subjectType = error.typeParameter) {
-        auto firstType = error.requirement.getFirstType();
-        auto secondType = error.requirement.getSecondType();
-
-        if (error.requirement.getKind() == RequirementKind::SameType) {
-          ctx.Diags.diagnose(loc, diag::same_type_conflict,
-                             false, subjectType, firstType, secondType);
-        } else {
-          assert(error.requirement.getKind() == RequirementKind::Superclass);
-          ctx.Diags.diagnose(loc, diag::conflicting_superclass_constraints,
-                             subjectType, firstType, secondType);
-
-        }
-        diagnosedError = true;
-        break;
-      }
-
+    case RequirementError::Kind::InvalidRequirementSubject: {
       auto subjectType = error.requirement.getFirstType();
       if (subjectType->hasError())
         break;
@@ -754,32 +721,49 @@ bool swift::rewriting::diagnoseRequirementErrors(
       break;
     }
 
-    case RequirementError::Kind::SameTypeMissingRequirement: {
+    case RequirementError::Kind::ConflictingRequirement: {
       auto requirement = error.requirement;
+      auto subjectType = error.typeParameter;
       switch (requirement.getKind()) {
       case RequirementKind::SameType:
-        // FIXME: This case should be diagnosed through `ConcreteTypeMismatch`.
+        if (requirement.getFirstType()->hasError() ||
+            requirement.getSecondType()->hasError()) {
+          // Don't emit a cascading error.
+        } else if (subjectType) {
+          ctx.Diags.diagnose(loc, diag::same_type_conflict,
+                             false, subjectType,
+                             requirement.getFirstType(),
+                             requirement.getSecondType());
+        } else {
+          ctx.Diags.diagnose(loc, diag::requires_same_concrete_type,
+                             requirement.getFirstType(),
+                             requirement.getSecondType());
+        }
         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;
+        if (subjectType) {
+          ctx.Diags.diagnose(loc, diag::conflicting_superclass_constraints,
+                             subjectType, requirement.getFirstType(),
+                             requirement.getSecondType());
+        } else {
+          ctx.Diags.diagnose(loc, diag::same_type_does_not_inherit,
+                             requirement.getFirstType(),
+                             requirement.getSecondType());
+        }
         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;
       }
 
+      diagnosedError = true;
       break;
     }
 

lib/AST/RequirementMachine/RewriteSystem.cpp

@@ -812,25 +812,26 @@ void RewriteSystem::computeConflictDiagnostics(
       auto subjectType = subject.getConcreteType();
       switch (constraint.getKind()) {
       case Symbol::Kind::ConcreteType:
-        errors.push_back(RequirementError::forConcreteTypeMismatch(
-            subjectType, constraint.getConcreteType(), signatureLoc));
+        errors.push_back(RequirementError::forConflictingRequirement(
+            {RequirementKind::SameType, subjectType, constraint.getConcreteType()},
+            signatureLoc));
         return;
 
       case Symbol::Kind::Superclass:
-        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+        errors.push_back(RequirementError::forConflictingRequirement(
             {RequirementKind::Superclass, subjectType, constraint.getConcreteType()},
             signatureLoc));
         return;
 
       case Symbol::Kind::Protocol:
-        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+        errors.push_back(RequirementError::forConflictingRequirement(
             {RequirementKind::Conformance, subjectType,
              constraint.getProtocol()->getDeclaredInterfaceType()},
             signatureLoc));
         return;
 
       case Symbol::Kind::Layout:
-        errors.push_back(RequirementError::forSameTypeMissingRequirement(
+        errors.push_back(RequirementError::forConflictingRequirement(
             {RequirementKind::Layout, subjectType, constraint.getLayoutConstraint()},
             signatureLoc));
         return;