[Variadic Generics] require pack ident type within a pack expansion to form a pack reference

Author: sophiapoirier

include/swift/AST/DiagnosticsSema.def

@@ -5208,6 +5208,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

@@ -3819,6 +3819,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::FromPackExpansion) &&
+        !options.contains(TypeResolutionFlags::FromPackReference)) {
+      diagnose(repr->getLoc(), diag::pack_expansion_missing_pack_reference,
+               repr);
+      return ErrorType::get(result);
+    }
   } else {
     result = resolveType(baseComp, options);
   }
@@ -4257,7 +4265,8 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
                                                      TypeResolutionOptions options) {
   auto &ctx = getASTContext();
 
-  auto pair = maybeResolvePackExpansionType(repr, options);
+  const auto patternOptions = options | TypeResolutionFlags::FromPackExpansion;
+  auto pair = maybeResolvePackExpansionType(repr, patternOptions);
 
   if (pair.first->hasError())
     return ErrorType::get(ctx);
@@ -4298,6 +4307,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,12 @@ 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 expansion.
+  FromPackExpansion = 1 << 12,
+
+  /// Whether this is a resolution based on a pack reference.
+  FromPackReference = 1 << 13,
 };
 
 /// 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()
+}