Merge pull request #65134 from hborla/parameter-pack-revision

hborla · web-flow · commit 35fcc371363a · 2023-04-13T08:33:25.000-07:00
[SE-0393] Require the `repeat` keyword for generic requirement expansions.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -5387,9 +5387,8 @@ ERROR(invalid_expansion_argument,none,
 ERROR(expansion_not_variadic,none,
       "pack expansion %0 must contain at least one pack reference", (Type))
 ERROR(pack_reference_outside_expansion,none,
-      "pack reference %0 can only appear in pack expansion "
-      "%select{or generic requirement|}1",
-      (Type, /*inExpression*/ bool))
+      "pack reference %0 can only appear in pack expansion ",
+      (Type))
 ERROR(each_non_pack,none,
       "'each' cannot be applied to non-pack type %0",
       (Type))
diff --git a/include/swift/AST/GenericParamList.h b/include/swift/AST/GenericParamList.h
@@ -58,6 +58,7 @@ class RequirementRepr {
   SourceLoc SeparatorLoc;
   RequirementReprKind Kind : 2;
   bool Invalid : 1;
+  bool IsExpansionPattern : 1;
   TypeRepr *FirstType;
 
   /// The second element represents the right-hand side of the constraint.
@@ -72,13 +73,17 @@ class RequirementRepr {
   StringRef AsWrittenString;
 
   RequirementRepr(SourceLoc SeparatorLoc, RequirementReprKind Kind,
-                  TypeRepr *FirstType, TypeRepr *SecondType)
+                  TypeRepr *FirstType, TypeRepr *SecondType,
+                  bool IsExpansionPattern)
     : SeparatorLoc(SeparatorLoc), Kind(Kind), Invalid(false),
+      IsExpansionPattern(IsExpansionPattern),
       FirstType(FirstType), SecondType(SecondType) { }
 
   RequirementRepr(SourceLoc SeparatorLoc, RequirementReprKind Kind,
-                  TypeRepr *FirstType, LayoutConstraintLoc SecondLayout)
+                  TypeRepr *FirstType, LayoutConstraintLoc SecondLayout,
+                  bool IsExpansionPattern)
     : SeparatorLoc(SeparatorLoc), Kind(Kind), Invalid(false),
+      IsExpansionPattern(IsExpansionPattern),
       FirstType(FirstType), SecondLayout(SecondLayout) { }
 
 public:
@@ -92,8 +97,10 @@ class RequirementRepr {
   /// subject must conform, or superclass from which the subject must inherit.
   static RequirementRepr getTypeConstraint(TypeRepr *Subject,
                                            SourceLoc ColonLoc,
-                                           TypeRepr *Constraint) {
-    return { ColonLoc, RequirementReprKind::TypeConstraint, Subject, Constraint };
+                                           TypeRepr *Constraint,
+                                           bool IsExpansionPattern) {
+    return { ColonLoc, RequirementReprKind::TypeConstraint, Subject, Constraint,
+             IsExpansionPattern };
   }
 
   /// Construct a new same-type requirement.
@@ -104,8 +111,10 @@ class RequirementRepr {
   /// \param SecondType The second type.
   static RequirementRepr getSameType(TypeRepr *FirstType,
                                      SourceLoc EqualLoc,
-                                     TypeRepr *SecondType) {
-    return { EqualLoc, RequirementReprKind::SameType, FirstType, SecondType };
+                                     TypeRepr *SecondType,
+                                     bool IsExpansionPattern) {
+    return { EqualLoc, RequirementReprKind::SameType, FirstType, SecondType,
+             IsExpansionPattern };
   }
 
   /// Construct a new layout-constraint requirement.
@@ -118,9 +127,10 @@ class RequirementRepr {
   /// subject must conform.
   static RequirementRepr getLayoutConstraint(TypeRepr *Subject,
                                              SourceLoc ColonLoc,
-                                             LayoutConstraintLoc Layout) {
+                                             LayoutConstraintLoc Layout,
+                                             bool IsExpansionPattern) {
     return {ColonLoc, RequirementReprKind::LayoutConstraint, Subject,
-            Layout};
+            Layout, IsExpansionPattern};
   }
 
   /// Determine the kind of requirement
@@ -129,6 +139,12 @@ class RequirementRepr {
   /// Determine whether this requirement is invalid.
   bool isInvalid() const { return Invalid; }
 
+  /// Whether this requirement repr is the pattern of a requirement
+  /// expansion, e.g. `repeat G<each T> == (each U).A`
+  bool isExpansionPattern() const {
+    return IsExpansionPattern;
+  }
+
   /// Mark this requirement invalid.
   void setInvalid() { Invalid = true; }
 
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -1842,16 +1842,23 @@ void PrintAST::printRequirement(const Requirement &req) {
     Printer << ")) : Any";
     return;
   case RequirementKind::Layout:
+    if (req.getFirstType()->hasParameterPack())
+      Printer << "repeat ";
     printTransformedType(req.getFirstType());
     Printer << " : ";
     req.getLayoutConstraint()->print(Printer, Options);
     return;
   case RequirementKind::Conformance:
   case RequirementKind::Superclass:
+    if (req.getFirstType()->hasParameterPack())
+      Printer << "repeat ";
     printTransformedType(req.getFirstType());
     Printer << " : ";
     break;
   case RequirementKind::SameType:
+    if (req.getFirstType()->hasParameterPack() ||
+        req.getSecondType()->hasParameterPack())
+      Printer << "repeat ";
     printTransformedType(req.getFirstType());
     Printer << " == ";
     break;
diff --git a/lib/AST/CASTBridging.cpp b/lib/AST/CASTBridging.cpp
@@ -562,12 +562,12 @@ void *GenericParamList_create(void *ctx, void *lAngleLoc,
     case BridgedRequirementReprKindTypeConstraint:
       requirements.push_back(RequirementRepr::getTypeConstraint(
           (TypeRepr *)req.FirstType, getSourceLocFromPointer(req.SeparatorLoc),
-          (TypeRepr *)req.SecondType));
+          (TypeRepr *)req.SecondType, /*isExpansionPattern*/false));
       break;
     case BridgedRequirementReprKindSameType:
       requirements.push_back(RequirementRepr::getSameType(
           (TypeRepr *)req.FirstType, getSourceLocFromPointer(req.SeparatorLoc),
-          (TypeRepr *)req.SecondType));
+          (TypeRepr *)req.SecondType, /*isExpansionPattern*/false));
       break;
     case BridgedRequirementReprKindLayoutConstraint:
       llvm_unreachable("cannot handle layout constraints!");
diff --git a/lib/Parse/ParseGeneric.cpp b/lib/Parse/ParseGeneric.cpp
@@ -288,6 +288,13 @@ ParserStatus Parser::parseGenericWhereClause(
       break;
     }
 
+    // Parse the 'repeat' keyword for requirement expansions.
+    bool isRequirementExpansion = false;
+    if (Tok.is(tok::kw_repeat)) {
+      consumeToken();
+      isRequirementExpansion = true;
+    }
+
     // Parse the leading type. It doesn't necessarily have to be just a type
     // identifier if we're dealing with a same-type constraint.
     ParserResult<TypeRepr> FirstType = parseType();
@@ -326,7 +333,8 @@ ParserStatus Parser::parseGenericWhereClause(
           // Add the layout requirement.
           Requirements.push_back(RequirementRepr::getLayoutConstraint(
               FirstType.get(), ColonLoc,
-              LayoutConstraintLoc(Layout, LayoutLoc)));
+              LayoutConstraintLoc(Layout, LayoutLoc),
+              isRequirementExpansion));
         }
       } else {
         // Parse the protocol or composition.
@@ -337,7 +345,7 @@ ParserStatus Parser::parseGenericWhereClause(
 
         // Add the requirement.
         Requirements.push_back(RequirementRepr::getTypeConstraint(
-            FirstType.get(), ColonLoc, Protocol.get()));
+            FirstType.get(), ColonLoc, Protocol.get(), isRequirementExpansion));
       }
     } else if ((Tok.isAnyOperator() && Tok.getText() == "==") ||
                Tok.is(tok::equal)) {
@@ -367,15 +375,18 @@ ParserStatus Parser::parseGenericWhereClause(
         // completion token in the TypeRepr.
         Requirements.push_back(RequirementRepr::getTypeConstraint(
             FirstType.get(), EqualLoc,
-            new (Context) ErrorTypeRepr(SecondType.get()->getLoc())));
+            new (Context) ErrorTypeRepr(SecondType.get()->getLoc()),
+            isRequirementExpansion));
       } else {
         Requirements.push_back(RequirementRepr::getSameType(
-            FirstType.get(), EqualLoc, SecondType.get()));
+            FirstType.get(), EqualLoc, SecondType.get(),
+            isRequirementExpansion));
       }
     } else if (FirstType.hasCodeCompletion()) {
       // Recover by adding dummy constraint.
       Requirements.push_back(RequirementRepr::getTypeConstraint(
-          FirstType.get(), PreviousLoc, new (Context) ErrorTypeRepr(PreviousLoc)));
+          FirstType.get(), PreviousLoc, new (Context) ErrorTypeRepr(PreviousLoc),
+          isRequirementExpansion));
     } else {
       diagnose(Tok, diag::expected_requirement_delim);
       Status.setIsParseError();
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -6043,7 +6043,7 @@ bool InvalidPackElement::diagnoseAsError() {
 
 bool InvalidPackReference::diagnoseAsError() {
   emitDiagnostic(diag::pack_reference_outside_expansion,
-                 packType, /*inExpression*/true);
+                 packType);
   return true;
 }
 
diff --git a/lib/Sema/TypeCheckGeneric.cpp b/lib/Sema/TypeCheckGeneric.cpp
@@ -1028,7 +1028,8 @@ RequirementRequest::evaluate(Evaluator &evaluator,
     context = TypeResolverContext::GenericRequirement;
   }
   auto options = TypeResolutionOptions(context);
-  options |= TypeResolutionFlags::AllowPackReferences;
+  if (reqRepr.isExpansionPattern())
+    options |= TypeResolutionFlags::AllowPackReferences;
   if (owner.dc->isInSpecializeExtensionContext())
     options |= TypeResolutionFlags::AllowUsableFromInline;
   Optional<TypeResolution> resolution;
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
@@ -4637,7 +4637,7 @@ NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
   if (!options.contains(TypeResolutionFlags::AllowPackReferences)) {
     ctx.Diags.diagnose(repr->getLoc(),
                        diag::pack_reference_outside_expansion,
-                       packReference, /*inExpression*/false);
+                       packReference);
     return ErrorType::get(ctx);
   }
 
diff --git a/test/Constraints/pack-expansion-expressions.swift b/test/Constraints/pack-expansion-expressions.swift
@@ -52,11 +52,11 @@ protocol P {
   func f(_ self: Self) -> Self
 }
 
-func outerArchetype<each T, U>(t: repeat each T, u: U) where each T: P {
+func outerArchetype<each T, U>(t: repeat each T, u: U) where repeat each T: P {
   let _: (repeat (each T.A, U)) = (repeat ((each t).value, u))
 }
 
-func sameElement<each T, U>(t: repeat each T, u: U) where each T: P, each T == U {
+func sameElement<each T, U>(t: repeat each T, u: U) where repeat each T: P, repeat each T == U {
 // expected-error@-1{{same-element requirements are not yet supported}}
 
   // FIXME: Opened element archetypes in diagnostics
@@ -65,15 +65,15 @@ func sameElement<each T, U>(t: repeat each T, u: U) where each T: P, each T == U
 }
 
 func forEachEach<each C, U>(c: repeat each C, function: (U) -> Void)
-    where each C: Collection, each C.Element == U {
+    where repeat each C: Collection, repeat (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 {
+func typeReprPacks<each T: ExpressibleByIntegerLiteral>(_ t: repeat each T) {
   _ = (repeat Array<each T>())
   _ = (repeat 1 as each T)
 
diff --git a/test/Constraints/pack_expansion_types.swift b/test/Constraints/pack_expansion_types.swift
@@ -264,7 +264,8 @@ func patternInstantiationConcreteInvalid() {
   let _: (Array<Int>, Set<String>) = patternInstantiationTupleTest1() // expected-error {{type of expression is ambiguous without more context}}
 }
 
-func patternInstantiationGenericValid<each T, each U>(t: repeat each T, u: repeat each U) where (repeat (each T, each U)): Any, each T: Hashable {
+func patternInstantiationGenericValid<each T, each U>(t: repeat each T, u: repeat each U)
+    where (repeat (each T, each U)): Any, repeat each T: Hashable {
   let _: (repeat Array<each T>) = patternInstantiationTupleTest1()
   let _: (repeat Array<each T>, Array<String>) = patternInstantiationTupleTest1()
   let _: (Array<String>, repeat Array<each T>) = patternInstantiationTupleTest1()
@@ -286,7 +287,7 @@ func patternInstantiationGenericValid<each T, each U>(t: repeat each T, u: repea
   let _: (Dictionary<Int, String>, repeat Dictionary<each T, each U>, Dictionary<Double, Character>) -> () = patternInstantiationFunctionTest2()
 }
 
-func patternInstantiationGenericInvalid<each T>(t: repeat each T) where each T: Hashable {
+func patternInstantiationGenericInvalid<each T: Hashable>(t: repeat each T) {
   let _: (repeat Set<each T>) = patternInstantiationTupleTest1() // expected-error {{cannot convert value of type '(repeat Array<each T>)' to specified type '(repeat Set<each T>)}}
   // expected-error@-1 {{generic parameter 'T' could not be inferred}}
 
diff --git a/test/Constraints/variadic_generic_constraints.swift b/test/Constraints/variadic_generic_constraints.swift
@@ -47,9 +47,11 @@ takesAnyObject(C(), S(), C())  // expected-error {{type of expression is ambiguo
 
 // Same-type requirements
 
-func takesParallelSequences<each T, each U>(t: repeat each T, u: repeat each U) where each T: Sequence, each U: Sequence, each T.Element == each U.Element {}
-// expected-note@-1 {{where 'T.Element' = 'String', 'U.Element' = 'Int'}}
-
+// expected-note@+1 {{where 'T.Element' = 'String', 'U.Element' = 'Int'}}
+func takesParallelSequences<each T, each U>(t: repeat each T, u: repeat each U)
+    where repeat each T: Sequence,
+          repeat each U: Sequence,
+          repeat (each T).Element == (each U).Element {}
 takesParallelSequences()  // ok
 takesParallelSequences(t: Array<Int>(), u: Set<Int>())  // ok
 takesParallelSequences(t: Array<String>(), Set<Int>(), u: Set<String>(), Array<Int>())  // ok
diff --git a/test/Constraints/variadic_generic_functions.swift b/test/Constraints/variadic_generic_functions.swift
@@ -3,15 +3,15 @@
 // REQUIRES: asserts
 
 func debugPrint<each T>(_ items: repeat each T)
-  where each T: CustomDebugStringConvertible
+  where repeat each T: CustomDebugStringConvertible
 {
   /*for (item: T) in items {
     stdout.write(item.debugDescription)
   }*/
 }
 
 func max<each T>(_ values: repeat each T) -> (repeat each T)?
-  where each T: Comparable
+  where repeat each T: Comparable
 {
   return nil
 }
diff --git a/test/Frontend/experimental_feature.swift b/test/Frontend/experimental_feature.swift
@@ -11,6 +11,6 @@ let x = BOOM
 
 // Use variadic generics
 func debugPrint<each T>(_ items: repeat each T)
-  where each T: CustomDebugStringConvertible
+  where repeat each T: CustomDebugStringConvertible
 {
 }
diff --git a/test/Generics/pack-shape-requirements.swift b/test/Generics/pack-shape-requirements.swift
@@ -12,9 +12,9 @@ func inferSameShape<each T, each U>(ts t: repeat each T, us u: repeat each U) wh
 }
 
 // CHECK-LABEL: desugarSameShape(ts:us:)
-// CHECK-NEXT: Generic signature: <each T, each U where T : P, (repeat (each T, each U)) : Any, U : P>
-func desugarSameShape<each T, each U>(ts t: repeat each T, us u: repeat each U) where each T: P, each U: P, (repeat (each T.A, each U.A)): Any {
-}
+// CHECK-NEXT: Generic signature: <each T, each U where repeat T : P, (repeat (each T, each U)) : Any, repeat U : P>
+func desugarSameShape<each T, each U>(ts t: repeat each T, us u: repeat each U)
+  where repeat each T: P, repeat each U: P, (repeat (each T.A, each U.A)): Any {}
 
 // CHECK-LABEL: multipleSameShape1(ts:us:vs:)
 // CHECK-NEXT: Generic signature: <each T, each U, each V where (repeat (each T, each U)) : Any, (repeat (each U, each V)) : Any>
@@ -49,14 +49,14 @@ func multipleSameShape6<each T, each U, each V>(ts t: repeat each T, us u: repea
 struct Ts<each T> {
   struct Us<each U> {
     // CHECK-LABEL: Ts.Us.packEquality()
-    // CHECK-NEXT: Generic signature: <each T, each U where T == U>
-    func packEquality() where each T == each U, (repeat (each T, each U)): Any {
+    // CHECK-NEXT: Generic signature: <each T, each U where repeat T == U>
+    func packEquality() where repeat each T == each U, (repeat (each T, each U)): Any {
     }
 
     struct Vs<each V> {
       // CHECK-LABEL: Ts.Us.Vs.packEquality()
-      // CHECK-NEXT: Generic signature: <each T, each U, each V where T == U, (repeat (each T, each V)) : Any>
-      func packEquality() where each T == each U, (repeat (each U, each V)): Any {
+      // CHECK-NEXT: Generic signature: <each T, each U, each V where repeat T == U, (repeat (each T, each V)) : Any>
+      func packEquality() where repeat each T == each U, (repeat (each U, each V)): Any {
       }
     }
   }
diff --git a/test/Generics/tuple-conformances.swift b/test/Generics/tuple-conformances.swift
@@ -11,7 +11,7 @@ protocol P {
   func f()
 }
 
-extension Builtin.TheTupleType: P where each Elements: P {
+extension Builtin.TheTupleType: P where repeat each Elements: P {
   typealias A = (repeat each Elements.A)
   typealias B = Float
   func f() {}
diff --git a/test/Generics/variadic_generic_requirements.swift b/test/Generics/variadic_generic_requirements.swift
@@ -22,7 +22,7 @@ _ = Layout<Class, Subclass>.self  // ok
 _ = Layout<Int, String>.self  // expected-error {{'Layout' requires that 'Int' be a class type}}
 
 struct Outer<each T: Sequence> {
-  struct Inner<each U: Sequence> where each T.Element == each U.Element {}
+  struct Inner<each U: Sequence> where repeat each T.Element == each U.Element {}
   // expected-note@-1 {{requirement specified as 'T.Element' == 'U.Element' [with each T = Array<Int>, Array<String>; each U = Set<String>, Set<Int>]}}
   // expected-note@-2 {{requirement specified as 'T.Element' == 'U.Element' [with each T = Array<Int>; each U = Set<Int>, Set<String>]}}
 
@@ -36,4 +36,4 @@ _ = Outer<Array<Int>, Array<String>>.Inner<Set<String>, Set<Int>>.self  // expec
 _ = Outer<Array<Int>>.Inner<Set<Int>, Set<String>>.self  // expected-error {{'Outer<Array<Int>>.Inner' requires the types 'Pack{Int}' and 'Pack{Int, String}' be equivalent}}
 
 _ = Outer<Array<Int>, Array<String>>.InnerShape<Set<String>, Set<Int>>.self  // ok
-_ = Outer<Array<Int>>.InnerShape<Set<Int>, Set<String>>.self  // expected-error {{'Outer<Array<Int>>.InnerShape' requires the type packs 'Pack{Array<Int>}' and 'Pack{Set<Int>, Set<String>}' have the same shape}}
+_ = Outer<Array<Int>>.InnerShape<Set<Int>, Set<String>>.self  // expected-error {{'Outer<Array<Int>>.InnerShape' requires the type packs 'Pack{Array<Int>}' and 'Pack{Set<Int>, Set<String>}' have the same shape}}
diff --git a/test/IRGen/run_variadic_generics.sil b/test/IRGen/run_variadic_generics.sil
@@ -626,7 +626,7 @@ entry(%intIndex : $Builtin.Word):
   return %t : $()
 }
 
-sil @unwrap_from_PA : $<each T_1 : PA where each T_1.A : P> (Builtin.Word) -> () {
+sil @unwrap_from_PA : $<each T_1 : PA where repeat each T_1.A : P> (Builtin.Word) -> () {
 entry(%intIndex : $Builtin.Word):
   %direct_access_from_parameter_with_conformance = function_ref @direct_access_from_parameter_with_conformance : $@convention(thin) <each T_1: P> (Builtin.Word) -> ()
   apply %direct_access_from_parameter_with_conformance<Pack{repeat GenFwdP<each T_1.A>}>(%intIndex) : $@convention(thin) <each T_1: P> (Builtin.Word) -> ()
@@ -637,7 +637,7 @@ entry(%intIndex : $Builtin.Word):
 sil @extract_associatedtype_with_conformance : $<each T_1 : P> (Builtin.Word) -> () {
 entry(%intIndex : $Builtin.Word):
   %innerIndex = dynamic_pack_index %intIndex of $Pack{repeat each T_1}
-  %token = open_pack_element %innerIndex of <each U_1 : PA where each U_1.A : P> at <Pack{repeat GenAssocPA<GenFwdP<each T_1>>}>, shape $U_1, uuid "01234567-89AB-CDEF-0123-000000000005"
+  %token = open_pack_element %innerIndex of <each U_1 : PA where repeat each U_1.A : P> at <Pack{repeat GenAssocPA<GenFwdP<each T_1>>}>, shape $U_1, uuid "01234567-89AB-CDEF-0123-000000000005"
   %metatype_1 = metatype $@thick (@pack_element("01234567-89AB-CDEF-0123-000000000005") U_1).Type
   %printGenericType = function_ref @printGenericType : $@convention(thin) <T> (@thick T.Type) -> ()
   apply %printGenericType<(@pack_element("01234567-89AB-CDEF-0123-000000000005") U_1)>(%metatype_1) : $@convention(thin) <T> (@thick T.Type) -> ()
@@ -653,7 +653,7 @@ sil @extract_associatedtype_with_conformance2 : $<each T_1 : P, Tee : P, each T_
 entry(%intIndex : $Builtin.Word):
   %innerIndex = dynamic_pack_index %intIndex of $Pack{repeat GenAssocPA<GenAssocPA<GenAssocPA<GenFwdP<each T_1>>>>, repeat GenAssocPA<GenAssocPA<GenAssocPA<GenFwdP<each T_1>>>>}
   %token = open_pack_element %innerIndex 
-    of <each U_1 : PA, Ewe : PA, each U_2 : PA where each U_1.A : PA, each U_1.A.A : PA, each U_1.A.A.A : P, Ewe.A : PA, Ewe.A.A : PA, Ewe.A.A.A : P, each U_2.A : PA, each U_2.A.A : PA, each U_2.A.A.A : P, (repeat (each U_1, each U_2)): Any> 
+    of <each U_1 : PA, Ewe : PA, each U_2 : PA where repeat each U_1.A : PA, repeat each U_1.A.A : PA, repeat each U_1.A.A.A : P, Ewe.A : PA, Ewe.A.A : PA, Ewe.A.A.A : P, repeat each U_2.A : PA, repeat each U_2.A.A : PA, repeat each U_2.A.A.A : P, (repeat (each U_1, each U_2)): Any> 
     at <
         Pack{repeat GenAssocPA<GenAssocPA<GenAssocPA<GenFwdP<each T_1>>>>, repeat GenAssocPA<GenAssocPA<GenAssocPA<GenFwdP<each T_1>>>>}, 
         GenAssocPA<GenAssocPA<GenAssocPA<GenFwdP<Tee>>>>, 
diff --git a/test/IRGen/variadic_generic_captures.swift b/test/IRGen/variadic_generic_captures.swift
@@ -82,6 +82,6 @@ public func has_witness_table_pack<each T: Sequence>(t: repeat each T) -> () ->
 }
 
 public func has_witness_table_pack2<each T: Sequence>(t: repeat each T) -> () -> ()
-    where each T.Element: Sequence {
+    where repeat each T.Element: Sequence {
   return { _ = (repeat (each T).Element.Element).self }
 }
diff --git a/test/IRGen/variadic_generic_functions.sil b/test/IRGen/variadic_generic_functions.sil
diff --git a/test/Interpreter/variadic_generic_captures.swift b/test/Interpreter/variadic_generic_captures.swift
diff --git a/test/Interpreter/variadic_generic_types.swift b/test/Interpreter/variadic_generic_types.swift
diff --git a/test/SILGen/variadic_generic_types.swift b/test/SILGen/variadic_generic_types.swift
diff --git a/test/TypeDecoder/variadic_nominal_types.swift b/test/TypeDecoder/variadic_nominal_types.swift
diff --git a/test/type/pack_expansion.swift b/test/type/pack_expansion.swift

Original file line number	Diff line number	Diff line change
`@@ -6043,7 +6043,7 @@ bool InvalidPackElement::diagnoseAsError() {`
`6043`	`6043`
`6044`	`6044`	`bool InvalidPackReference::diagnoseAsError() {`
`6045`	`6045`	`emitDiagnostic(diag::pack_reference_outside_expansion,`
`6046`		`- packType, /inExpression/true);`
	`6046`	`+ packType);`
`6047`	`6047`	`return true;`
`6048`	`6048`	`}`
`6049`	`6049`
Original file line number	Diff line number	Diff line change
`@@ -4637,7 +4637,7 @@ NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,`
`4637`	`4637`	`if (!options.contains(TypeResolutionFlags::AllowPackReferences)) {`
`4638`	`4638`	`ctx.Diags.diagnose(repr->getLoc(),`
`4639`	`4639`	`diag::pack_reference_outside_expansion,`
`4640`		`- packReference, /inExpression/false);`
	`4640`	`+ packReference);`
`4641`	`4641`	`return ErrorType::get(ctx);`
`4642`	`4642`	`}`
`4643`	`4643`
Original file line number	Diff line number	Diff line change
`@@ -52,11 +52,11 @@ protocol P {`
`52`	`52`	`func f(_ self: Self) -> Self`
`53`	`53`	`}`
`54`	`54`
`55`		`-func outerArchetype<each T, U>(t: repeat each T, u: U) where each T: P {`
	`55`	`+func outerArchetype<each T, U>(t: repeat each T, u: U) where repeat each T: P {`
`56`	`56`	`let _: (repeat (each T.A, U)) = (repeat ((each t).value, u))`
`57`	`57`	`}`
`58`	`58`
`59`		`-func sameElement<each T, U>(t: repeat each T, u: U) where each T: P, each T == U {`
	`59`	`+func sameElement<each T, U>(t: repeat each T, u: U) where repeat each T: P, repeat each T == U {`
`60`	`60`	`// expected-error@-1{{same-element requirements are not yet supported}}`
`61`	`61`
`62`	`62`	`// FIXME: Opened element archetypes in diagnostics`
`@@ -65,15 +65,15 @@ func sameElement<each T, U>(t: repeat each T, u: U) where each T: P, each T == U`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`func forEachEach<each C, U>(c: repeat each C, function: (U) -> Void)`
`68`		`- where each C: Collection, each C.Element == U {`
	`68`	`+ where repeat each C: Collection, repeat (each C).Element == U {`
`69`	`69`	`// expected-error@-1{{same-element requirements are not yet supported}}`
`70`	`70`
`71`	`71`	`// FIXME: Opened element archetypes in diagnostics`
`72`	`72`	`_ = (repeat (each c).forEach(function))`
`73`	`73`	`// expected-error@-1 {{cannot convert value of type '(U) -> Void' to expected argument type '(τ_1_0.Element) throws -> Void'}}`
`74`	`74`	`}`
`75`	`75`
`76`		`-func typeReprPacks<each T>(_ t: repeat each T) where each T: ExpressibleByIntegerLiteral {`
	`76`	`+func typeReprPacks<each T: ExpressibleByIntegerLiteral>(_ t: repeat each T) {`
`77`	`77`	`_ = (repeat Array<each T>())`
`78`	`78`	`_ = (repeat 1 as each T)`
`79`	`79`