[RequirementMachine] Always store an invalid requirement in RequirementError.

Author: hborla

include/swift/AST/Requirement.h

@@ -130,66 +130,46 @@ struct StructuralRequirement {
 /// generic signature of a declaration, and diagnosed via
 /// \c diagnoseRequirementErrors .
 struct RequirementError {
+  /// The kind of requirement error.
   enum class Kind {
     InvalidConformance,
     ConcreteTypeMismatch,
     NonTypeParameter,
     RedundantRequirement,
   } kind;
 
-  union {
-    struct {
-      Type subjectType;
-      Type constraint;
-    } invalidConformance;
-
-    struct {
-      Type type1;
-      Type type2;
-    } concreteTypeMismatch;
-
-    Type nonTypeParameter;
-
-    Requirement redundantRequirement;
-  };
+  /// The invalid requirement.
+  Requirement requirement;
 
   SourceLoc loc;
 
 private:
-  RequirementError(Kind kind, SourceLoc loc)
-  : kind(kind), loc(loc) {}
+  RequirementError(Kind kind, Requirement requirement, SourceLoc loc)
+    : kind(kind), requirement(requirement), loc(loc) {}
 
 public:
   static RequirementError forInvalidConformance(Type subjectType,
                                                 Type constraint,
                                                 SourceLoc loc) {
-    RequirementError error(Kind::InvalidConformance, loc);
-    error.invalidConformance.subjectType = subjectType;
-    error.invalidConformance.constraint = constraint;
-    return error;
+    Requirement requirement(RequirementKind::Conformance, subjectType, constraint);
+    return {Kind::InvalidConformance, requirement, loc};
   }
 
   static RequirementError forConcreteTypeMismatch(Type type1,
                                                   Type type2,
                                                   SourceLoc loc) {
-    RequirementError error(Kind::ConcreteTypeMismatch, loc);
-    error.concreteTypeMismatch.type1 = type1;
-    error.concreteTypeMismatch.type2 = type2;
-    return error;
+    Requirement requirement(RequirementKind::SameType, type1, type2);
+    return {Kind::ConcreteTypeMismatch, requirement, loc};
   }
 
-  static RequirementError forNonTypeParameter(Type subject,
+  static RequirementError forNonTypeParameter(Requirement req,
                                               SourceLoc loc) {
-    RequirementError error(Kind::NonTypeParameter, loc);
-    error.nonTypeParameter = subject;
-    return error;
+    return {Kind::NonTypeParameter, req, loc};
   }
 
   static RequirementError forRedundantRequirement(Requirement req,
                                                   SourceLoc loc) {
-    RequirementError error(Kind::RedundantRequirement, loc);
-    error.redundantRequirement = req;
-    return error;
+    return {Kind::RedundantRequirement, req, loc};
   }
 };
 

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -128,12 +128,14 @@ static void desugarSuperclassRequirement(Type subjectType,
                                          SmallVectorImpl<Requirement> &result,
                                          SmallVectorImpl<RequirementError> &errors) {
   if (!subjectType->isTypeParameter()) {
+    Requirement requirement(RequirementKind::Superclass,
+                            subjectType, constraintType);
     if (constraintType->isExactSuperclassOf(subjectType)) {
-      errors.push_back(RequirementError::forRedundantRequirement(
-          {RequirementKind::Superclass, subjectType, constraintType}, loc));
+      errors.push_back(
+          RequirementError::forRedundantRequirement(requirement, loc));
     } else {
       errors.push_back(
-          RequirementError::forNonTypeParameter(subjectType, loc));
+          RequirementError::forNonTypeParameter(requirement, loc));
     }
 
     return;
@@ -148,12 +150,14 @@ static void desugarLayoutRequirement(Type subjectType,
                                      SmallVectorImpl<Requirement> &result,
                                      SmallVectorImpl<RequirementError> &errors) {
   if (!subjectType->isTypeParameter()) {
+    Requirement requirement(RequirementKind::Layout,
+                            subjectType, layout);
     if (subjectType->isAnyClassReferenceType()) {
-      errors.push_back(RequirementError::forRedundantRequirement(
-          {RequirementKind::Layout, subjectType, layout}, loc));
+      errors.push_back(
+          RequirementError::forRedundantRequirement(requirement, loc));
     } else {
       errors.push_back(
-          RequirementError::forNonTypeParameter(subjectType, loc));
+          RequirementError::forNonTypeParameter(requirement, loc));
     }
 
     return;
@@ -189,8 +193,8 @@ static void desugarConformanceRequirement(Type subjectType, Type constraintType,
       auto *module = protoDecl->getParentModule();
       auto conformance = module->lookupConformance(subjectType, protoDecl);
       if (conformance.isInvalid()) {
-        errors.push_back(
-            RequirementError::forNonTypeParameter(subjectType, loc));
+        errors.push_back(RequirementError::forNonTypeParameter(
+            {RequirementKind::Conformance, subjectType, constraintType}, loc));
         return;
       }
 
@@ -541,8 +545,8 @@ bool swift::rewriting::diagnoseRequirementErrors(
 
     switch (error.kind) {
     case RequirementError::Kind::InvalidConformance: {
-      Type subjectType = error.invalidConformance.subjectType;
-      Type constraint = error.invalidConformance.constraint;
+      Type subjectType = error.requirement.getFirstType();
+      Type constraint = error.requirement.getSecondType();
 
       // FIXME: The constraint string is printed directly here because
       // the current default is to not print `any` for existential
@@ -578,8 +582,8 @@ bool swift::rewriting::diagnoseRequirementErrors(
     }
 
     case RequirementError::Kind::ConcreteTypeMismatch: {
-      auto type1 = error.concreteTypeMismatch.type1;
-      auto type2 = error.concreteTypeMismatch.type2;
+      auto type1 = error.requirement.getFirstType();
+      auto type2 = error.requirement.getSecondType();
 
       if (!type1->hasError() && !type2->hasError()) {
         ctx.Diags.diagnose(loc, diag::requires_same_concrete_type,
@@ -592,13 +596,13 @@ bool swift::rewriting::diagnoseRequirementErrors(
 
     case RequirementError::Kind::NonTypeParameter: {
       ctx.Diags.diagnose(loc, diag::requires_not_suitable_archetype,
-                         error.nonTypeParameter);
+                         error.requirement.getFirstType());
       diagnosedError = true;
       break;
     }
 
     case RequirementError::Kind::RedundantRequirement: {
-      auto requirement = error.redundantRequirement;
+      auto requirement = error.requirement;
       switch (requirement.getKind()) {
       case RequirementKind::SameType:
         ctx.Diags.diagnose(loc, diag::redundant_same_type_to_concrete,