Sema: Diagnose variadic enums, and inheritance from variadic classes

These are just temporary limitations.

Author: slavapestov

include/swift/AST/DiagnosticsSema.def

@@ -5411,9 +5411,12 @@ ERROR(vararg_not_allowed,none,
 ERROR(experimental_type_with_parameter_pack,none,
       "generic types with parameter packs are experimental",
       ())
-ERROR(more_than_one_parameter_pack_in_type,none,
-      "generic type cannot have more than one pack", ())
-
+ERROR(more_than_one_pack_in_type,none,
+      "generic type cannot declare more than one type pack", ())
+ERROR(enum_with_pack,none,
+      "enums cannot declare a type pack", ())
+ERROR(superclass_with_pack,none,
+      "cannot inherit from a generic class that declares a type pack", ())
 ERROR(expansion_not_allowed,none,
       "pack expansion %0 can only appear in a function parameter list, "
       "tuple element, or generic argument list", (Type))

lib/Sema/TypeCheckDeclPrimary.cpp

@@ -485,7 +485,7 @@ static void checkGenericParams(GenericContext *ownerCtx) {
       }
 
       if (hasPack) {
-        gp->diagnose(diag::more_than_one_parameter_pack_in_type);
+        gp->diagnose(diag::more_than_one_pack_in_type);
       }
 
       hasPack = true;
@@ -2555,6 +2555,17 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
   void visitEnumDecl(EnumDecl *ED) {
     checkUnsupportedNestedType(ED);
 
+    // Temporary restriction until we figure out pattern matching and
+    // enum case construction with packs.
+    if (auto genericSig = ED->getGenericSignature()) {
+      for (auto paramTy : genericSig.getGenericParams()) {
+        if (paramTy->isParameterPack()) {
+          ED->diagnose(diag::enum_with_pack);
+          break;
+        }
+      }
+    }
+
     // FIXME: Remove this once we clean up the mess involving raw values.
     (void) ED->getInterfaceType();
 
@@ -2834,6 +2845,18 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
       else if (superclass->isActor())
         CD->diagnose(diag::actor_inheritance,
                      /*distributed=*/CD->isDistributedActor());
+
+      // Enforce a temporary restriction on inheriting from a superclass
+      // type with a pack, until we figure out the semantics of method
+      // overrides in these situations.
+      if (auto genericSig = superclass->getGenericSignature()) {
+        for (auto paramTy : genericSig.getGenericParams()) {
+          if (paramTy->isParameterPack()) {
+            CD->diagnose(diag::superclass_with_pack);
+            break;
+          }
+        }
+      }
     }
 
     if (CD->isDistributedActor()) {

test/Generics/variadic_generic_types.swift

@@ -1,10 +1,31 @@
 // RUN: %target-typecheck-verify-swift -enable-experimental-feature VariadicGenerics
 
+// Because of -enable-experimental-feature VariadicGenerics
 // REQUIRES: asserts
 
-struct MultiplePack<each T, each U> {} // expected-error {{generic type cannot have more than one pack}}
-typealias MultiplePackAlias<each T, each U> = (repeat each T, repeat each U) // expected-error {{generic type cannot have more than one pack}}
+// Disallowed cases
+struct MultiplePack<each T, each U> {} // expected-error {{generic type cannot declare more than one type pack}}
+typealias MultiplePackAlias<each T, each U> = (repeat each T, repeat each U) // expected-error {{generic type cannot declare more than one type pack}}
 
+// Temporary limitations
+enum EnumWithPack<each T> { // expected-error {{enums cannot declare a type pack}}
+  case cheddar
+}
+
+class ClassWithPack<each T> {}
+
+struct OuterStruct<each T> {
+  enum NestedEnum { // expected-error {{enums cannot declare a type pack}}
+    case smokedGouda
+  }
+
+  class NestedClass {}
+}
+
+class BadInheritance1: ClassWithPack<Int> {} // expected-error {{cannot inherit from a generic class that declares a type pack}}
+class BadInheritance2: OuterStruct<Int>.NestedClass {} // expected-error {{cannot inherit from a generic class that declares a type pack}}
+
+// Type resolution of variadic type aliases
 func bindAll() {
   struct Bind<each U> {}
 

test/type/pack_expansion.swift

@@ -30,7 +30,7 @@ func f5<each T>() -> () -> (repeat each T) {}
 
 func f6<each T>() -> (repeat each T) -> () {}
 
-enum E<each T> {
+enum E<each T> { // expected-error {{enums cannot declare a type pack}}
   case f1(_: repeat each T)
 
   case f2(_: G<repeat each T>)