Merge pull request #64415 from slavapestov/reduced-type-of-pack-expansion

RequirementMachine: The reduced type of a PackExpansionType has a reduced *shape* for the count type

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -5310,26 +5310,26 @@ ERROR(vararg_not_allowed,none,
       "variadic parameter cannot appear outside of a function parameter list",
       ())
 ERROR(expansion_not_allowed,none,
-      "variadic expansion %0 cannot appear outside of a function parameter list, "
+      "pack expansion %0 cannot appear outside of a function parameter list, "
       "function result, tuple element or generic argument list", (Type))
 ERROR(expansion_not_variadic,none,
-      "variadic expansion %0 must contain at least one variadic generic parameter", (Type))
+      "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 or generic requirement",
       (Type))
 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",
+      "pack type %0 must be referenced with 'each'",
       (TypeRepr*))
 ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(multiple_ellipsis_in_tuple,none,
       "only a single element can be variadic", ())
 
 ERROR(expansion_not_same_shape,none,
-      "variadic expansion %0 requires that %1 and %2 have the same shape",
+      "pack expansion %0 requires that %1 and %2 have the same shape",
       (Type, Type, Type))
 ERROR(expansion_expr_not_same_shape,none,
       "pack expansion requires that %0 and %1 have the same shape",

lib/AST/GenericSignature.cpp

@@ -536,7 +536,7 @@ GenericSignatureImpl::lookupNestedType(Type type, Identifier name) const {
 
 Type
 GenericSignatureImpl::getReducedShape(Type type) const {
-  return getRequirementMachine()->getReducedShape(type);
+  return getRequirementMachine()->getReducedShape(type, getGenericParams());
 }
 
 bool

lib/AST/RequirementMachine/GenericSignatureQueries.cpp

@@ -57,7 +57,7 @@ RequirementMachine::getLocalRequirements(
 
   GenericSignature::LocalRequirements result;
   result.anchor = Map.getTypeForTerm(term, genericParams);
-  result.packShape = getReducedShape(depType);
+  result.packShape = getReducedShape(depType, genericParams);
 
   auto *props = Map.lookUpProperties(term);
   if (!props)
@@ -365,6 +365,17 @@ Type RequirementMachine::getReducedType(
     if (!t->hasTypeParameter())
       return t;
 
+    // The reduced type of a PackExpansionType has a reduced *shape* for
+    // the count type.
+    if (auto *packExpansionType = t->getAs<PackExpansionType>()) {
+      auto reducedPattern = getReducedType(packExpansionType->getPatternType(),
+                                           genericParams);
+      auto reducedShape = packExpansionType->getCountType();
+      if (reducedShape->isParameterPack())
+        reducedShape = getReducedShape(reducedShape, genericParams);
+      return Type(PackExpansionType::get(reducedPattern, reducedShape));
+    }
+
     if (!t->isTypeParameter())
       return None;
 
@@ -727,12 +738,12 @@ RequirementMachine::getReducedShapeTerm(Type type) const {
   return reducedTerm;
 }
 
-Type RequirementMachine::getReducedShape(Type type) const {
+Type RequirementMachine::getReducedShape(Type type,
+                      TypeArrayView<GenericTypeParamType> genericParams) const {
   if (!type->isParameterPack())
     return Type();
 
-  return Map.getTypeForTerm(getReducedShapeTerm(type),
-                            getGenericParams());
+  return Map.getTypeForTerm(getReducedShapeTerm(type), genericParams);
 }
 
 bool RequirementMachine::haveSameShape(Type type1, Type type2) const {

lib/AST/RequirementMachine/RequirementMachine.h

@@ -164,7 +164,8 @@ class RequirementMachine final {
   MutableTerm getReducedShapeTerm(Type type) const;
 
 public:
-  Type getReducedShape(Type type) const;
+  Type getReducedShape(Type type,
+                       TypeArrayView<GenericTypeParamType> genericParams) const;
 
   bool haveSameShape(Type type1, Type type2) const;
 

lib/AST/Type.cpp

@@ -4684,7 +4684,18 @@ static Type substType(Type derivedType,
                              boxTy->getLayout(),
                              newSubMap);
     }
-    
+
+    if (auto packExpansionTy = dyn_cast<PackExpansionType>(type)) {
+      auto patternTy = substType(packExpansionTy->getPatternType(),
+                                 substitutions, lookupConformances, options);
+      auto countTy = substType(packExpansionTy->getCountType(),
+                               substitutions, lookupConformances, options);
+      if (auto *archetypeTy = countTy->getAs<PackArchetypeType>())
+        countTy = archetypeTy->getReducedShape();
+
+      return Type(PackExpansionType::get(patternTy, countTy)->expand());
+    }
+
     if (auto silFnTy = dyn_cast<SILFunctionType>(type)) {
       if (silFnTy->isPolymorphic())
         return None;

test/Constraints/pack-expansion-expressions.swift

@@ -87,25 +87,25 @@ func sameShapeDiagnostics<each T, each 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}}
 }
 
-func returnPackExpansionType<each 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}}
+func returnPackExpansionType<each T>(_ t: repeat each T) -> repeat each T { // expected-error {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
   fatalError()
 }
 
 func returnEachPackReference<each T>(_ t: repeat each T) -> each T { // expected-error {{pack reference 'T' can only appear in pack expansion or generic requirement}}
   fatalError()
 }
 
-func returnRepeatTuple<each T>(_ t: repeat each T) -> (repeat T) { // expected-error {{pack expansion 'T' must specify a pack reference}}
+func returnRepeatTuple<each T>(_ t: repeat each T) -> (repeat T) { // expected-error {{pack type 'T' must be referenced with 'each'}}
   fatalError()
 }
 
-func parameterAsPackTypeWithoutExpansion<each 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}}
+func parameterAsPackTypeWithoutExpansion<each T>(_ t: T) -> repeat each T { // expected-error {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
   fatalError()
 }
 
 func expansionOfNonPackType<T>(_ t: repeat each T) {}
 // expected-error@-1 {{'each' cannot be applied to non-pack type 'T'}}{{29-29=each }}
-// expected-error@-2 {{variadic expansion 'T' must contain at least one variadic generic parameter}}
+// expected-error@-2 {{pack expansion 'T' must contain at least one pack reference}}
 
 func tupleExpansion<each T, each U>(
   _ tuple1: (repeat each T),
@@ -143,7 +143,7 @@ func copyIntoTuple<each T>(_ arg: repeat each T) -> (repeat each T) {
 }
 func callCopyAndBind<T>(_ arg: repeat each T) {
   // expected-error@-1 {{'each' cannot be applied to non-pack type 'T'}}
-  // expected-error@-2 {{variadic expansion 'T' must contain at least one variadic generic parameter}}
+  // expected-error@-2 {{pack expansion 'T' must contain at least one pack reference}}
 
   // Don't propagate errors for invalid declaration reference
   let result = copyIntoTuple(repeat each arg)

test/Constraints/variadic_generic_functions.swift

@@ -22,8 +22,8 @@ func min<each T: Comparable>(_ values: repeat each T) -> T? {
 
 func invalidPacks() {
   func monovariadic1() -> (each String) {} // expected-error {{'each' cannot be applied to non-pack type 'String'}}
-  func monovariadic2<T>() -> (repeat T) {} // expected-error {{variadic expansion 'T' must contain at least one variadic generic parameter}}
-  func monovariadic3<T, U>() -> (T, repeat U) {} // expected-error {{variadic expansion 'U' must contain at least one variadic generic parameter}}
+  func monovariadic2<T>() -> (repeat T) {} // expected-error {{pack expansion 'T' must contain at least one pack reference}}
+  func monovariadic3<T, U>() -> (T, repeat U) {} // expected-error {{pack expansion 'U' must contain at least one pack reference}}
 }
 
 func call() {

test/Constraints/variadic_generic_types.swift

@@ -21,6 +21,6 @@ func g<each T>(_: repeat each T) {
   _ = ((Int, repeat Array<each T>) -> ()).self
 
   _ = (repeat each Int).self
-  // expected-error@-1 {{variadic expansion 'Int' must contain at least one variadic generic parameter}}
+  // expected-error@-1 {{pack expansion 'Int' must contain at least one pack reference}}
   // expected-error@-2 {{'each' cannot be applied to non-pack type 'Int'}}
 }

test/type/pack_expansion.swift

@@ -3,7 +3,7 @@
 // REQUIRES: asserts
 
 func f1<each T>() -> repeat each T {}
-// expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
 func f2<each T>() -> (repeat each T) {}
 // okay
@@ -19,12 +19,12 @@ protocol P<T> {
 func f4<each T>() -> any P<repeat each T> {}
 
 typealias T1<each T> = repeat each T
-// expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
 typealias T2<each T> = (repeat each T)
 
 func f4<each T>() -> repeat () -> each T {}
-// expected-error@-1 {{variadic expansion '() -> T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion '() -> T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
 func f5<each T>() -> () -> (repeat each T) {}
 
@@ -36,24 +36,24 @@ enum E<each T> {
   case f2(_: G<repeat each T>)
 
   var x: repeat each T { fatalError() }
-  // expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  // expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
   var x: (repeat each T) { fatalError() }
 
   subscript(_: repeat each T) -> Int { fatalError() }
 
   subscript() -> repeat each T { fatalError() }
-  // expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  // expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
   subscript() -> (repeat each T) { fatalError() }
 }
 
 func withWhereClause<each T>(_ x: repeat each T) where repeat each T: P {}
-// expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
 
 struct Outer<each T> {
   struct Bad<each U> {
-    typealias Value = (repeat (each T, each U)) // expected-error {{variadic expansion 'repeat (each T, each U)' requires that 'T' and 'U' have the same shape}}
+    typealias Value = (repeat (each T, each U)) // expected-error {{pack expansion 'repeat (each T, each U)' requires that 'T' and 'U' have the same shape}}
   }
 
   struct Good<each U> where (repeat (each T, each U)): Any {