[Variadic Generics] distinctly diagnose more types of pack expansion errors + add fixits

Author: sophiapoirier

include/swift/AST/DiagnosticsSema.def

@@ -5310,8 +5310,8 @@ ERROR(vararg_not_allowed,none,
       "variadic parameter cannot appear outside of a function parameter list",
       ())
 ERROR(expansion_not_allowed,none,
-      "pack expansion %0 cannot appear outside of a function parameter list, "
-      "function result, tuple element or generic argument list", (Type))
+      "pack expansion %0 can only appear in a function parameter list, "
+      "tuple element, or generic argument list", (Type))
 ERROR(expansion_not_variadic,none,
       "pack expansion %0 must contain at least one pack reference", (Type))
 ERROR(pack_reference_outside_expansion,none,
@@ -5320,7 +5320,10 @@ 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,
+ERROR(pack_reference_must_be_in_expansion,none,
+      "pack reference %0 requires expansion using keyword 'repeat'",
+      (TypeRepr*))
+ERROR(pack_type_requires_keyword_each,none,
       "pack type %0 must be referenced with 'each'",
       (TypeRepr*))
 ERROR(tuple_duplicate_label,none,

lib/Sema/TypeCheckType.cpp

@@ -4077,11 +4077,24 @@ TypeResolver::resolveDeclRefTypeRepr(DeclRefTypeRepr *repr,
                                              silContext, 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);
+        // Workaround to allow 'shape' type checking of SIL.
+        // TODO: Explicitly pass along whether in a 'shape' context.
+        !options.contains(TypeResolutionFlags::SILMode)) {
+      bool invalid = false;
+      if (!options.contains(TypeResolutionFlags::AllowPackReferences)) {
+        diagnose(repr->getLoc(), diag::pack_reference_must_be_in_expansion,
+                 repr);
+        invalid = true;
+      }
+      if (!options.contains(TypeResolutionFlags::FromPackReference)) {
+        diagnose(repr->getLoc(), diag::pack_type_requires_keyword_each,
+                 repr)
+            .fixItInsert(repr->getLoc(), "each ");
+        invalid = true;
+      }
+      if (invalid) {
+        return ErrorType::get(result);
+      }
     }
   } else {
     result = resolveType(baseComp, options);
@@ -4548,27 +4561,33 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
     return ErrorType::get(ctx);
   }
 
+  PackExpansionType *result{};
+  GenericSignature genericSig;
+  Type shapeType;
+  if (resolution.getStage() == TypeResolutionStage::Interface) {
+    genericSig = resolution.getGenericSignature();
+    shapeType = genericSig->getReducedShape(rootParameterPacks[0]);
+    result = PackExpansionType::get(patternType, shapeType);
+  } else {
+    result = PackExpansionType::get(patternType, rootParameterPacks[0]);
+  }
+
   // We might not allow variadic expansions here at all.
   if (!options.isPackExpansionSupported(getDeclContext())) {
-    diagnose(repr->getLoc(), diag::expansion_not_allowed, patternType);
+    diagnose(repr->getLoc(), diag::expansion_not_allowed, result);
     return ErrorType::get(ctx);
   }
 
   if (resolution.getStage() == TypeResolutionStage::Interface) {
-    auto genericSig = resolution.getGenericSignature();
-    auto shapeType = genericSig->getReducedShape(rootParameterPacks[0]);
-    auto result = PackExpansionType::get(patternType, shapeType);
-
     for (auto type : rootParameterPacks) {
       if (!genericSig->haveSameShape(type, shapeType)) {
         ctx.Diags.diagnose(repr->getLoc(), diag::expansion_not_same_shape,
                            result, shapeType, type);
       }
     }
-    return result;
   }
 
-  return PackExpansionType::get(patternType, rootParameterPacks[0]);
+  return result;
 }
 
 NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
@@ -4592,6 +4611,7 @@ NeverNullType TypeResolver::resolvePackElement(PackElementTypeRepr *repr,
         }
       }
     }
+    // TODO: else 'each' probably should be removed preceding repr
     return packReference;
   }
 

test/Constraints/pack-expansion-expressions.swift

@@ -76,8 +76,8 @@ func typeReprPacks<each T>(_ t: repeat each T) where each T: ExpressibleByIntege
   _ = repeat Array<each T>()
   _ = repeat 1 as each T
 
-  _ = Array<each T>() // expected-error {{pack reference 'T' can only appear in pack expansion or generic requirement}}
-  _ = 1 as each T // expected-error {{pack reference 'T' can only appear in pack expansion or generic requirement}}
+  _ = Array<each T>() // expected-error {{pack reference 'T' requires expansion using keyword 'repeat'}}
+  _ = 1 as each T // expected-error {{pack reference 'T' requires expansion using keyword 'repeat'}}
   repeat Invalid<String, each T>("") // expected-error {{cannot find 'Invalid' in scope}}
 }
 
@@ -87,22 +87,38 @@ 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 {{pack 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 'repeat each T' can only appear in a function parameter list, 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}}
+func returnEachPackReference<each T>(_ t: repeat each T) -> each T { // expected-error {{pack reference 'T' requires expansion using keyword 'repeat'}}
   fatalError()
 }
 
-func returnRepeatTuple<each T>(_ t: repeat each T) -> (repeat T) { // expected-error {{pack type 'T' must be referenced with 'each'}}
+// expected-error@+1 {{pack type 'T' must be referenced with 'each'}}{{63-63=each }}
+func returnRepeatTuple<each T>(_ t: repeat each T) -> (repeat T) {
   fatalError()
 }
 
-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}}
+// expected-error@+2 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+// expected-error@+1 {{pack type 'T' must be referenced with 'each'}}{{55-55=each }}
+func parameterAsPackTypeWithoutExpansion<each T>(_ t: T) {
+}
+
+// expected-error@+2 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+// expected-error@+1 {{pack type 'T' must be referenced with 'each'}}{{57-57=each }}
+func returnPackReference<each T>(_ t: repeat each T) -> T {
   fatalError()
 }
 
+func packTypeParameterOutsidePackExpansionType<each T>(_ t: T,
+  // expected-error@-1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+  // expected-error@-2 {{pack type 'T' must be referenced with 'each'}}{{61-61=each }}
+                                                       _ a: Array<T>) {
+  // expected-error@-1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+  // expected-error@-2 {{pack type 'T' must be referenced with 'each'}}{{67-67=each }}
+}
+
 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 {{pack expansion 'T' must contain at least one pack reference}}
@@ -125,7 +141,7 @@ protocol Generatable {
 
 func generateTuple<each T : Generatable>() -> (repeat each T) {
   (each T).generate()
-  // expected-error@-1 {{pack reference 'T' can only appear in pack expansion or generic requirement}}
+  // expected-error@-1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
 
   return (repeat (each T).generate())
 }

test/Constraints/variadic_generic_functions.swift

@@ -10,13 +10,13 @@ func debugPrint<each T>(_ items: repeat each T)
   }*/
 }
 
-func max<each T>(_ values: repeat each T) -> T?
+func max<each T>(_ values: repeat each T) -> (repeat each T)?
   where each T: Comparable
 {
   return nil
 }
 
-func min<each T: Comparable>(_ values: repeat each T) -> T? {
+func min<each T: Comparable>(_ values: repeat each T) -> (repeat each T)? {
   return nil
 }
 

test/type/pack_expansion.swift

@@ -3,7 +3,7 @@
 // REQUIRES: asserts
 
 func f1<each T>() -> repeat each T {}
-// expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'repeat each T' can only appear in a function parameter list, 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 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'repeat each T' can only appear in a function parameter list, tuple element, or generic argument list}}
 
 typealias T2<each T> = (repeat each T)
 
 func f4<each T>() -> repeat () -> each T {}
-// expected-error@-1 {{pack expansion '() -> T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'repeat () -> each T' can only appear in a function parameter list, tuple element, or generic argument list}}
 
 func f5<each T>() -> () -> (repeat each T) {}
 
@@ -36,20 +36,20 @@ enum E<each T> {
   case f2(_: G<repeat each T>)
 
   var x: repeat each T { fatalError() }
-  // expected-error@-1 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  // expected-error@-1 {{pack expansion 'repeat each T' can only appear in a function parameter list, 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 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+  // expected-error@-1 {{pack expansion 'repeat each T' can only appear in a function parameter list, 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 {{pack expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+// expected-error@-1 {{pack expansion 'repeat each T' can only appear in a function parameter list, tuple element, or generic argument list}}
 
 struct Outer<each T> {
   struct Bad<each U> {
@@ -70,11 +70,26 @@ func packRef<each T>(_: repeat each T) where each T: P {}
 func packMemberRef<each T>(_: repeat each T.T) where each T: P {}
 
 // expected-error@+1 {{'each' cannot be applied to non-pack type 'Int'}}
-func invalidPackRef(_: each Int) {}
+func invalidPackRefEachInt(_: each Int) {}
 
-// expected-error@+1 {{pack reference 'T' can only appear in pack expansion or generic requirement}}
+// expected-error@+1 {{pack expansion 'Int' must contain at least one pack reference}}
+func invalidPackRefRepeatInt(_: repeat Int) {}
+
+// expected-error@+1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
 func packRefOutsideExpansion<each T>(_: each T) {}
 
+// expected-error@+1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+func packRefOutsideExpansion<each T>(_: Array<each T>) {}
+
+// expected-error@+1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+func packRefOutsideExpansion<each T>(_: Array<(each T) -> ()>) {}
+
+// expected-error@+1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+func packRefOutsideExpansion<each T>(_: (each T)) {}
+
+// expected-error@+1 {{pack reference 'T' requires expansion using keyword 'repeat'}}
+func packRefOutsideExpansion<each T>(_: each T.Type) {}
+
 // coverage to ensure a 'repeat each' type is considered Copyable
 func golden<Z>(_ z: Z) {}
 func hour<each T>(_ t: repeat each T)  {