[Features] Gate same-element requirements behind an experimental feature flag.

Author: hborla

include/swift/Basic/Features.def

@@ -123,6 +123,7 @@ EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
 EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
 EXPERIMENTAL_FEATURE(CodeItemMacros, false)
 EXPERIMENTAL_FEATURE(TupleConformances, false)
+EXPERIMENTAL_FEATURE(SameElementRequirements, false)
 
 SUPPRESSIBLE_LANGUAGE_FEATURE(ExtensionMacroAttr, 0, "@attached(extension)", true)
 

lib/AST/ASTPrinter.cpp

@@ -3261,6 +3261,10 @@ static bool usesFeatureTupleConformances(Decl *decl) {
   return false;
 }
 
+static bool usesFeatureSameElementRequirements(Decl *decl) {
+  return false;
+}
+
 static bool usesFeatureSymbolLinkageMarkers(Decl *decl) {
   auto &attrs = decl->getAttrs();
   return std::any_of(attrs.begin(), attrs.end(), [](auto *attr) {

lib/AST/RequirementMachine/RequirementLowering.cpp

@@ -218,6 +218,18 @@ static void desugarSameTypeRequirement(Requirement req, SourceLoc loc,
         break;
       }
 
+      auto &ctx = firstType->getASTContext();
+      if (!ctx.LangOpts.hasFeature(Feature::SameElementRequirements)) {
+        // 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(
+              {kind, sugaredFirstType, secondType}, loc));
+          recordedErrors = true;
+          return true;
+        }
+      }
+
       if (firstType->isTypeParameter() && secondType->isTypeParameter()) {
         result.emplace_back(kind, sugaredFirstType, secondType);
         return true;

test/Constraints/pack-expansion-expressions.swift

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

test/Generics/parameter-pack-requirements.swift

@@ -1,8 +1,12 @@
-// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -disable-availability-checking 2>&1 | %FileCheck %s
+// RUN: %target-swift-frontend -typecheck %s -debug-generic-signatures -disable-availability-checking -enable-experimental-feature SameElementRequirements 2>&1 | %FileCheck %s
+
+// REQUIRES: asserts
 
 protocol P {
   associatedtype A: P
   associatedtype B
+
+  func f(_ self: Self) -> Self
 }
 
 // CHECK-LABEL: inferSameShape(ts:us:)
@@ -158,3 +162,24 @@ func dependentSameElementConcrete<each C: Collection>(
 func dependentSameElementGeneric<each C: Collection, Element>(
   _: repeat each C
 ) where repeat (each C).Element == Element {}
+
+// FIXME: Either 'repeat each T: P' or 'U: P' should be redundant.
+// CHECK-LABEL: sameElementRedundantConformance
+// CHECK-NEXT: Generic signature: <each T, U where repeat each T : P, U : P, repeat U == each T>
+func sameElementRedundantConformance<each T, U>(
+  t: repeat each T,
+  u: U
+) where repeat each T: P,
+        repeat each T == U {
+  let _ = (repeat (each t).f(u))
+}
+
+// CHECK-LABEL: forEachEach
+// CHECK-NEXT: Generic signature: <each C, U where repeat each C : Collection, repeat U == (each C).[Sequence]Element>
+func forEachEach<each C, U>(
+  c: repeat each C,
+  function: (U) -> Void
+) where repeat each C: Collection,
+        repeat (each C).Element == U {
+  repeat (each c).forEach(function)
+}