[RequirementMachine] Diagnose same-element requirements.

The rewrite rules are not quite right yet for same-element requirements, so
let's ban them for now.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -2733,6 +2733,9 @@ ERROR(requires_not_suitable_archetype,none,
 ERROR(invalid_shape_requirement,none,
       "invalid same-shape requirement between %0 and %1",
       (Type, Type))
+ERROR(unsupported_same_element,none,
+      "same-element requirements are not yet supported",
+      ())
 
 ERROR(requires_generic_params_made_equal,none,
       "same-type requirement makes generic parameters %0 and %1 equivalent",

lib/AST/RequirementMachine/Diagnostics.cpp

@@ -209,6 +209,15 @@ bool swift::rewriting::diagnoseRequirementErrors(
 
       break;
     }
+
+    case RequirementError::Kind::UnsupportedSameElement: {
+      if (error.requirement.hasError())
+        break;
+
+      ctx.Diags.diagnose(loc, diag::unsupported_same_element);
+      diagnosedError = true;
+      break;
+    }
     }
   }
 

lib/AST/RequirementMachine/Diagnostics.h

@@ -42,6 +42,8 @@ struct RequirementError {
     RecursiveRequirement,
     /// A redundant requirement, e.g. T == T.
     RedundantRequirement,
+    /// A not-yet-supported same-element requirement, e.g. each T == Int.
+    UnsupportedSameElement,
   } kind;
 
   /// The invalid requirement.
@@ -100,6 +102,10 @@ struct RequirementError {
                                                   SourceLoc loc) {
     return {Kind::RecursiveRequirement, req, loc};
   }
+
+  static RequirementError forSameElement(Requirement req, SourceLoc loc) {
+    return {Kind::UnsupportedSameElement, req, loc};
+  }
 };
 
 /// Policy for the fixit that transforms 'T : S' where 'S' is not a protocol

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -194,6 +194,15 @@ static void desugarSameTypeRequirement(Type lhs, Type rhs, SourceLoc loc,
 
     bool mismatch(TypeBase *firstType, TypeBase *secondType,
                   Type sugaredFirstType) {
+      // If one side is a parameter pack, this is a same-element requirement, which
+      // is not yet supported.
+      if (firstType->isParameterPack() != secondType->isParameterPack()) {
+        errors.push_back(RequirementError::forSameElement(
+            {RequirementKind::SameType, sugaredFirstType, secondType}, loc));
+        recordedErrors = true;
+        return true;
+      }
+
       if (firstType->isTypeParameter() && secondType->isTypeParameter()) {
         result.emplace_back(RequirementKind::SameType,
                             sugaredFirstType, secondType);

test/Constraints/pack-expansion-expressions.swift

@@ -56,12 +56,20 @@ func outerArchetype<each T, U>(t: repeat each T, u: U) where each T: P {
 }
 
 func sameElement<each T, U>(t: repeat each T, u: U) where each T: P, each T == U {
+// expected-error@-1{{same-element requirements are not yet supported}}
+
+  // FIXME: Opened element archetypes in diagnostics
   let _: repeat each T = repeat (each t).f(u)
+  // expected-error@-1 {{cannot convert value of type 'U' to expected argument type 'τ_1_0'}}
 }
 
 func forEachEach<each C, U>(c: repeat each C, function: (U) -> Void)
     where each C: Collection, each C.Element == U {
+    // expected-error@-1{{same-element requirements are not yet supported}}
+
+  // FIXME: Opened element archetypes in diagnostics
   _ = repeat (each c).forEach(function)
+  // expected-error@-1 {{cannot convert value of type '(U) -> Void' to expected argument type '(τ_1_0.Element) throws -> Void'}}
 }
 
 func typeReprPacks<each T>(_ t: repeat each T) where each T: ExpressibleByIntegerLiteral {