Merge pull request #63208 from sophiapoirier/require-pack-reference-within-pack-expansion

[Variadic Generics] require pack ident type within a pack expansion t…

Author: sophiapoirier

include/swift/AST/DiagnosticsSema.def

@@ -5216,6 +5216,9 @@ ERROR(pack_reference_outside_expansion,none,
 ERROR(each_non_pack,none,
       "'each' cannot be applied to non-pack type %0",
       (Type))
+ERROR(pack_expansion_missing_pack_reference,none,
+      "pack expansion %0 must specify a pack reference",
+      (TypeRepr*))
 ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(multiple_ellipsis_in_tuple,none,

lib/Sema/TypeCheckType.cpp

@@ -3821,6 +3821,14 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
     // The base component uses unqualified lookup.
     result = resolveUnqualifiedIdentTypeRepr(resolution.withOptions(options),
                                              genericParams, identBase);
+
+    if (result && result->isParameterPack() &&
+        options.contains(TypeResolutionFlags::AllowPackReferences) &&
+        !options.contains(TypeResolutionFlags::FromPackReference)) {
+      diagnose(repr->getLoc(), diag::pack_expansion_missing_pack_reference,
+               repr);
+      return ErrorType::get(result);
+    }
   } else {
     result = resolveType(baseComp, options);
   }
@@ -4294,6 +4302,7 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
 NeverNullType TypeResolver::resolvePackReference(PackReferenceTypeRepr *repr,
                                                  TypeResolutionOptions options) {
   auto &ctx = getASTContext();
+  options |= TypeResolutionFlags::FromPackReference;
   auto packReference = resolveType(repr->getPackType(), options);
 
   // If we already failed, don't diagnose again.

lib/Sema/TypeCheckType.h

@@ -76,6 +76,9 @@ enum class TypeResolutionFlags : uint16_t {
   /// Pack references are only allowed inside pack expansions
   /// and in generic requirements.
   AllowPackReferences = 1 << 11,
+
+  /// Whether this is a resolution based on a pack reference.
+  FromPackReference = 1 << 12,
 };
 
 /// Type resolution contexts that require special handling.

test/Constraints/pack-expansion-expressions.swift

@@ -77,3 +77,19 @@ func sameShapeDiagnostics<T..., U...>(t: repeat each T, u: repeat each U) {
   _ = repeat Array<(each T, each U)>() // expected-error {{pack expansion requires that 'U' and 'T' have the same shape}}
   _ = repeat (Array<each T>(), each u) // expected-error {{pack expansion requires that 'U' and 'T' have the same shape}}
 }
+
+func returnPackExpansionType<T...>(_ t: repeat each T) -> repeat each T { // expected-error {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  fatalError()
+}
+
+func returnEachPackReference<T...>(_ t: repeat each T) -> each T { // expected-error {{pack reference 'T' can only appear in pack expansion or generic requirement}}
+  fatalError()
+}
+
+func returnRepeatTuple<T...>(_ t: repeat each T) -> (repeat T) { // expected-error {{pack expansion 'T' must specify a pack reference}}
+  fatalError()
+}
+
+func paremeterAsPackTypeWithoutExpansion<T...>(_ t: T) -> repeat each T { // expected-error {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  fatalError()
+}

test/Constraints/pack_expansion_types.swift

@@ -257,7 +257,7 @@ func patternInstantiationConcreteInvalid() {
   let _: (Array<Int>, Set<String>) = patternInstantiationTupleTest1() // expected-error {{type of expression is ambiguous without more context}}
 }
 
-func patternInstantiationGenericValid<T..., U...>(t: repeat each T, u: repeat each U) where (repeat (each T, each U)): Any, T: Hashable {
+func patternInstantiationGenericValid<T..., U...>(t: repeat each T, u: repeat each U) where (repeat (each T, each U)): Any, 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()
@@ -279,7 +279,7 @@ func patternInstantiationGenericValid<T..., U...>(t: repeat each T, u: repeat ea
   let _: (Dictionary<Int, String>, repeat Dictionary<each T, each U>, Dictionary<Double, Character>) -> () = patternInstantiationFunctionTest2()
 }
 
-func patternInstantiationGenericInvalid<T...>(t: repeat each T) where T: Hashable {
+func patternInstantiationGenericInvalid<T...>(t: repeat each T) where each T: Hashable {
   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}}
 

test/Constraints/variadic_generic_constraints.swift

@@ -47,7 +47,7 @@ takesAnyObject(C(), S(), C())  // expected-error {{type of expression is ambiguo
 
 // Same-type requirements
 
-func takesParallelSequences<T..., U...>(t: repeat each T, u: repeat each U) where T: Sequence, U: Sequence, T.Element == U.Element {}
+func takesParallelSequences<T..., 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'}}
 
 takesParallelSequences()  // ok

test/Constraints/variadic_generic_functions.swift

@@ -3,15 +3,15 @@
 // REQUIRES: asserts
 
 func debugPrint<T...>(_ items: repeat each T)
-  where T: CustomDebugStringConvertible
+  where each T: CustomDebugStringConvertible
 {
   /*for (item: T) in items {
     stdout.write(item.debugDescription)
   }*/
 }
 
 func max<T...>(_ values: repeat each T) -> T?
-  where T: Comparable
+  where each T: Comparable
 {
   return nil
 }

test/Constraints/variadic_generic_types.swift

@@ -1,3 +1,5 @@
+// REQUIRES: rdar104716322
+
 // RUN: %target-typecheck-verify-swift -enable-experimental-feature VariadicGenerics
 
 // REQUIRES: asserts
@@ -9,17 +11,16 @@ func f<T...>(_: repeat each T) {
   _ = G< >.self
   _ = G<Int>.self
   _ = G<Int, String>.self
-  _ = G<repeat T>.self
-  _ = G<Int, repeat Array<T>>.self
+  _ = G<repeat each T>.self
+  _ = G<Int, repeat Array<each T>>.self
 }
 
 // Forming PackExpansionTypeReprs in simplifyTypeExpr()
 func g<T...>(_: repeat each T) {
-  _ = (repeat T).self
-  _ = (Int, repeat T).self
-  _ = ((repeat T) -> ()).self
-  _ = ((Int, repeat Array<T>) -> ()).self
+  _ = (repeat each T).self
+  _ = (Int, repeat each T).self
+  _ = ((repeat each T) -> ()).self
+  _ = ((Int, repeat Array<each T>) -> ()).self
 
-  _ = (repeat Int).self // expected-error {{variadic expansion 'Int' must contain at least one variadic generic parameter}}
+  _ = (repeat each Int).self // expected-error {{variadic expansion 'Int' must contain at least one variadic generic parameter}}
 }
-

test/Generics/pack-shape-requirements.swift

@@ -13,7 +13,7 @@ func inferSameShape<T..., U...>(ts t: repeat each T, us u: repeat each U) where
 
 // CHECK-LABEL: desugarSameShape(ts:us:)
 // CHECK-NEXT: Generic signature: <T..., U... where T : P, ((T, U)...) : Any, U : P>
-func desugarSameShape<T..., U...>(ts t: repeat each T, us u: repeat each U) where T: P, U: P, (repeat (each T.A, each U.A)): Any {
+func desugarSameShape<T..., 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-LABEL: multipleSameShape1(ts:us:vs:)

test/Generics/tuple-conformances.swift

@@ -11,7 +11,7 @@ protocol P {
   func f()
 }
 
-extension Builtin.TheTupleType: P where Elements: P {
+extension Builtin.TheTupleType: P where each Elements: P {
   typealias A = (repeat each Elements.A)
   typealias B = Float
   func f() {}