Sema: Reject PackExpansionType in unsupported positions

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -5014,8 +5014,11 @@ ERROR(dot_protocol_on_non_existential,none,
       "cannot use 'Protocol' with non-protocol type %0", (Type))
 ERROR(tuple_single_element,none,
       "cannot create a single-element tuple with an element label", ())
+ERROR(expansion_not_allowed,none,
+      "variadic expansion %0 cannot appear outside of a function parameter list, "
+      "function result, tuple element or generic argument list", (Type))
 ERROR(expansion_not_variadic,none,
-      "cannot create expansion with non-variadic type %0", (Type))
+      "variadic expansion %0 must contain at least one variadic generic parameter", (Type))
 ERROR(tuple_duplicate_label,none,
       "cannot create a tuple with a duplicate element label", ())
 ERROR(multiple_ellipsis_in_tuple,none,

lib/Sema/TypeCheckType.cpp

@@ -508,14 +508,6 @@ Type TypeResolution::resolveTypeInContext(TypeDecl *typeDecl,
       fromDC->getParentModule(), typeDecl, selfType, /*useArchetypes=*/false);
 }
 
-static TypeResolutionOptions
-adjustOptionsForGenericArgs(TypeResolutionOptions options) {
-  options.setContext(None);
-  options -= TypeResolutionFlags::SILType;
-
-  return options;
-}
-
 /// This function checks if a bound generic type is UnsafePointer<Void> or
 /// UnsafeMutablePointer<Void>. For these two type representations, we should
 /// warn users that they are deprecated and replace them with more handy
@@ -713,8 +705,9 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
     // to a parameterized existential type.
     if (options.is(TypeResolverContext::ExistentialConstraint))
       options |= TypeResolutionFlags::DisallowOpaqueTypes;
-    auto genericResolution =
-      resolution.withOptions(adjustOptionsForGenericArgs(options));
+    auto argOptions = options.withoutContext().withContext(
+        TypeResolverContext::GenericArgument);
+    auto genericResolution = resolution.withOptions(argOptions);
 
     SmallVector<Type, 2> argTys;
     for (auto *genericArg : genericArgs) {
@@ -810,8 +803,9 @@ static Type applyGenericArguments(Type type, TypeResolution resolution,
   }
 
   // Resolve the types of the generic arguments.
-  auto genericResolution =
-      resolution.withOptions(adjustOptionsForGenericArgs(options));
+  auto argOptions = options.withoutContext().withContext(
+      TypeResolverContext::GenericArgument);
+  auto genericResolution = resolution.withOptions(argOptions);
 
   SmallVector<Type, 2> args;
   for (auto tyR : genericArgs) {
@@ -3910,14 +3904,15 @@ NeverNullType TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
 NeverNullType
 TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
                                     TypeResolutionOptions options) {
-  options = adjustOptionsForGenericArgs(options);
+  auto argOptions = options.withoutContext().withContext(
+      TypeResolverContext::GenericArgument);
 
-  auto keyTy = resolveType(repr->getKey(), options.withoutContext());
+  auto keyTy = resolveType(repr->getKey(), argOptions);
   if (keyTy->hasError()) {
     return ErrorType::get(getASTContext());
   }
 
-  auto valueTy = resolveType(repr->getValue(), options.withoutContext());
+  auto valueTy = resolveType(repr->getValue(), argOptions);
   if (valueTy->hasError()) {
     return ErrorType::get(getASTContext());
   }
@@ -3973,6 +3968,9 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
   case TypeResolverContext::PatternBindingDecl:
     doDiag = !isDirect;
     break;
+  case TypeResolverContext::TupleElement:
+  case TypeResolverContext::GenericArgument:
+  case TypeResolverContext::ProtocolGenericArgument:
   case TypeResolverContext::VariadicFunctionInput:
   case TypeResolverContext::ForEachStmt:
   case TypeResolverContext::ExtensionBinding:
@@ -4068,9 +4066,17 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
                                                      TypeResolutionOptions options) {
   auto pair = maybeResolvePackExpansionType(repr, options);
 
-  // If there's no reference to a variadic generic parameter, complain
-  // - the pack won't actually expand to anything meaningful.
-  if (!pair.first->hasError() && !pair.second) {
+  if (pair.first->hasError())
+    return ErrorType::get(getASTContext());
+
+  // We might not allow variadic expansions here at all.
+  if (!options.isPackExpansionSupported()) {
+    diagnose(repr->getLoc(), diag::expansion_not_allowed, pair.first);
+    return ErrorType::get(getASTContext());
+  }
+
+  // The pattern type must contain at least one variadic generic parameter.
+  if (!pair.second) {
     diagnose(repr->getLoc(), diag::expansion_not_variadic, pair.first)
       .highlight(repr->getSourceRange());
     return ErrorType::get(getASTContext());
@@ -4090,6 +4096,7 @@ NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
   auto elementOptions = options;
   if (!repr->isParenType()) {
     elementOptions = elementOptions.withoutContext(true);
+    elementOptions = elementOptions.withContext(TypeResolverContext::TupleElement);
   }
 
   bool hadError = false;

lib/Sema/TypeCheckType.h

@@ -77,6 +77,15 @@ enum class TypeResolverContext : uint8_t {
   /// No special type handling is required.
   None,
 
+  /// Whether we are checking generic arguments of a bound generic type.
+  GenericArgument,
+
+  /// Whether we are checking generic arguments of a parameterized protocol type.
+  ProtocolGenericArgument,
+
+  /// Whether we are checking a tuple element type.
+  TupleElement,
+
   /// Whether we are checking the parameter list of a function.
   AbstractFunctionDecl,
 
@@ -97,8 +106,7 @@ enum class TypeResolverContext : uint8_t {
   /// Whether this is an 'inout' function input.
   InoutFunctionInput,
 
-  /// Whether we are in the result type of a function, including multi-level
-  /// tuple return values. See also: TypeResolutionFlags::Direct
+  /// Whether we are in the result type of a function.
   FunctionResult,
 
   /// Whether this is a pattern binding entry.
@@ -227,6 +235,9 @@ class TypeResolutionOptions {
     case Context::ClosureExpr:
       return true;
     case Context::None:
+    case Context::GenericArgument:
+    case Context::ProtocolGenericArgument:
+    case Context::TupleElement:
     case Context::FunctionInput:
     case Context::VariadicFunctionInput:
     case Context::InoutFunctionInput:
@@ -264,6 +275,9 @@ class TypeResolutionOptions {
     case Context::MetatypeBase:
       return false;
     case Context::None:
+    case Context::GenericArgument:
+    case Context::ProtocolGenericArgument:
+    case Context::TupleElement:
     case Context::InExpression:
     case Context::ExplicitCastExpr:
     case Context::ForEachStmt:
@@ -298,6 +312,9 @@ class TypeResolutionOptions {
     case Context::MetatypeBase:
       return true;
     case Context::None:
+    case Context::GenericArgument:
+    case Context::ProtocolGenericArgument:
+    case Context::TupleElement:
     case Context::InExpression:
     case Context::ExplicitCastExpr:
     case Context::ForEachStmt:
@@ -320,6 +337,44 @@ class TypeResolutionOptions {
     }
   }
 
+  /// Whether pack expansion types are supported in this context.
+  bool isPackExpansionSupported() const {
+    switch (context) {
+    case Context::FunctionInput:
+    case Context::TupleElement:
+    case Context::GenericArgument:
+      return true;
+
+    case Context::None:
+    case Context::ProtocolGenericArgument:
+    case Context::Inherited:
+    case Context::ExtensionBinding:
+    case Context::TypeAliasDecl:
+    case Context::GenericTypeAliasDecl:
+    case Context::GenericRequirement:
+    case Context::ExistentialConstraint:
+    case Context::MetatypeBase:
+    case Context::InExpression:
+    case Context::ExplicitCastExpr:
+    case Context::ForEachStmt:
+    case Context::PatternBindingDecl:
+    case Context::EditorPlaceholderExpr:
+    case Context::ClosureExpr:
+    case Context::VariadicFunctionInput:
+    case Context::InoutFunctionInput:
+    case Context::FunctionResult:
+    case Context::SubscriptDecl:
+    case Context::EnumElementDecl:
+    case Context::EnumPatternPayload:
+    case Context::SameTypeRequirement:
+    case Context::ProtocolMetatypeBase:
+    case Context::ImmediateOptionalTypeArgument:
+    case Context::AbstractFunctionDecl:
+    case Context::CustomAttr:
+      return false;
+    }
+  }
+
   /// Determine whether all of the given options are set.
   bool contains(TypeResolutionFlags set) const {
     return !static_cast<bool>(unsigned(set) & ~unsigned(flags));

test/Constraints/tuple.swift

@@ -74,7 +74,7 @@ var values = getIntFloat()
 func wantFloat(_: Float) {}
 wantFloat(values.float)
 
-var e : (x: Int..., y: Int) // expected-error{{cannot create a variadic tuple}}
+var e : (x: Int..., y: Int) // expected-error{{variadic expansion 'Int' must contain at least one variadic generic parameter}}
 
 typealias Interval = (a:Int, b:Int)
 func takeInterval(_ x: Interval) {}

test/Constraints/type_sequence.swift

@@ -64,9 +64,9 @@ func bindPrefixAndSuffix() {
 }
 
 func invalidPacks() {
-  func monovariadic1() -> (String...) {} // expected-error {{cannot create expansion with non-variadic type 'String'}}
-  func monovariadic2<T>() -> (T...) {} // expected-error {{cannot create expansion with non-variadic type 'T'}}
-  func monovariadic3<T, U>() -> (T, U...) {} // expected-error {{cannot create a variadic tuple}}
+  func monovariadic1() -> (String...) {} // expected-error {{variadic expansion 'String' must contain at least one variadic generic parameter}}
+  func monovariadic2<T>() -> (T...) {} // expected-error {{variadic expansion 'T' must contain at least one variadic generic parameter}}
+  func monovariadic3<T, U>() -> (T, U...) {} // expected-error {{variadic expansion 'U' must contain at least one variadic generic parameter}}
 }
 
 func call() {

test/decl/func/vararg.swift

@@ -1,7 +1,7 @@
 // RUN: %target-typecheck-verify-swift
 
 var t1a: (Int...) = (1)
-// expected-error@-1 {{cannot create a variadic tuple}}
+// expected-error@-1 {{variadic expansion 'Int' must contain at least one variadic generic parameter}}
 var t2d: (Double = 0.0) = 1 // expected-error {{default argument not permitted in a tuple type}} {{18-23=}}
 
 func f1(_ a: Int...) { for _ in a {} }

test/type/pack_expansion.swift

@@ -0,0 +1,47 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-variadic-generics
+
+func f1<@_typeSequence T>() -> T... {}
+// expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+
+func f2<@_typeSequence T>() -> (T...) {}
+// okay
+
+struct G<@_typeSequence T> {}
+
+func f3<@_typeSequence T>() -> G<T... > {}
+
+protocol P<T> {
+  associatedtype T
+}
+
+func f4<@_typeSequence T>() -> any P<T... > {}
+
+typealias T1<@_typeSequence T> = T...
+// expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+
+typealias T2<@_typeSequence T> = (T...)
+
+func f4<@_typeSequence T>() -> () -> T... {}
+// expected-error@-1 {{variadic expansion '() -> T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+
+func f5<@_typeSequence T>() -> () -> (T...) {}
+
+func f6<@_typeSequence T>() -> (T...) -> () {}
+
+enum E<@_typeSequence T> {
+  case f1(_: T...)
+
+  case f2(_: G<T... >)
+
+  var x: T... { fatalError() }
+  // expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+
+  var x: (T...) { fatalError() }
+
+  subscript(_: T...) -> Int { fatalError() }
+
+  subscript() -> T... { fatalError() }
+  // expected-error@-1 {{variadic expansion 'T' cannot appear outside of a function parameter list, function result, tuple element or generic argument list}}
+
+  subscript() -> (T...) { fatalError() }
+}