Guard usage of variadic generics with $ParameterPacks in module interface files

Fixes rdar://107559541.

Author: slavapestov

include/swift/Basic/Features.def

@@ -100,6 +100,7 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(
         hasSwiftSwiftParser)
 LANGUAGE_FEATURE(AttachedMacros, 389, "Attached macros", hasSwiftSwiftParser)
 LANGUAGE_FEATURE(MoveOnly, 390, "noncopyable types", true)
+LANGUAGE_FEATURE(ParameterPacks, 393, "Value and type parameter packs", true)
 
 UPCOMING_FEATURE(ConciseMagicFile, 274, 6)
 UPCOMING_FEATURE(ForwardTrailingClosures, 286, 6)

lib/AST/ASTPrinter.cpp

@@ -3320,15 +3320,15 @@ static bool usesFeatureFreestandingExpressionMacros(Decl *decl) {
 static void
 suppressingFeatureFreestandingExpressionMacros(PrintOptions &options,
                                         llvm::function_ref<void()> action) {
-  llvm::SaveAndRestore<PrintOptions> orignalOptions(options);
+  llvm::SaveAndRestore<PrintOptions> originalOptions(options);
   options.SuppressingFreestandingExpression = true;
   action();
 }
 
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {
-  llvm::SaveAndRestore<PrintOptions> orignalOptions(options);
+  llvm::SaveAndRestore<PrintOptions> originalOptions(options);
   options.SuppressNoAsyncAvailabilityAttr = true;
   action();
 }
@@ -3342,6 +3342,43 @@ static bool usesFeatureBuiltinModule(Decl *decl) {
   return false;
 }
 
+static bool hasParameterPacks(Decl *decl) {
+  if (auto genericContext = decl->getAsGenericContext()) {
+    auto sig = genericContext->getGenericSignature();
+    if (llvm::any_of(
+          sig.getGenericParams(),
+          [&](const GenericTypeParamType *GP) { return GP->isParameterPack(); })) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/// A declaration needs the $ParameterPacks feature if it declares a
+/// generic parameter pack, or if its type references a generic nominal
+/// or type alias which declares a generic parameter pack.
+static bool usesFeatureParameterPacks(Decl *decl) {
+  if (hasParameterPacks(decl))
+    return true;
+
+  if (auto *valueDecl = dyn_cast<ValueDecl>(decl)) {
+    if (valueDecl->getInterfaceType().findIf(
+        [&](Type t) {
+          if (auto *alias = dyn_cast<TypeAliasType>(t.getPointer()))
+            return hasParameterPacks(alias->getDecl());
+          if (auto *nominal = t->getAnyNominal())
+            return hasParameterPacks(nominal);
+
+          return false;
+        })) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {

test/ModuleInterface/pack_expansion_type.swift

@@ -5,10 +5,13 @@
 // Experimental features require an asserts compiler
 // REQUIRES: asserts
 
-// CHECK: public func variadicFunction<each T, each U>(t: repeat each T, u: repeat each U) -> (repeat (each T, each U)) where (repeat (each T, each U)) : Any
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public func variadicFunction<each T, each U>(t: repeat each T, u: repeat each U) -> (repeat (each T, each U)) where (repeat (each T, each U)) : Any
 public func variadicFunction<each T, each U>(t: repeat each T, u: repeat each U) -> (repeat (each T, each U)) {}
+// CHECK-NEXT: #endif
 
-// CHECK: public struct VariadicType<each T> {
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public struct VariadicType<each T> {
 public struct VariadicType<each T> {
   // CHECK: public func variadicMethod<each U>(t: repeat each T, u: repeat each U) -> (repeat (each T, each U)) where (repeat (each T, each U)) : Any
   public func variadicMethod<each U>(t: repeat each T, u: repeat each  U) -> (repeat (each T, each U)) {}
@@ -17,24 +20,35 @@ public struct VariadicType<each T> {
   public func returnsSelf() -> Self {}
 }
 // CHECK: }
+// CHECK-NEXT: #endif
 
 // CHECK: public func returnsVariadicType() -> PackExpansionType.VariadicType<>
 public func returnsVariadicType() -> VariadicType< > {}
 
 // CHECK: public func returnsVariadicType() -> PackExpansionType.VariadicType<Swift.Int, Swift.String, Swift.Float>
 public func returnsVariadicType() -> VariadicType<Int, String, Float> {}
 
-// CHECK: public func returnsVariadicType<each T>() -> PackExpansionType.VariadicType<repeat each T>
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public func returnsVariadicType<each T>() -> PackExpansionType.VariadicType<repeat each T>
 public func returnsVariadicType<each T>() -> VariadicType<repeat each T> {}
+// CHECK-NEXT: #endif
 
-// CHECK: public typealias VariadicAlias<each T> = PackExpansionType.VariadicType<repeat Swift.Array<each T>>
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public typealias VariadicAlias<each T> = PackExpansionType.VariadicType<repeat Swift.Array<each T>>
+// CHECK-NEXT: #endif
 public typealias VariadicAlias<each T> = VariadicType<repeat Array<each T>>
 
-// CHECK: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<>
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<>
+// CHECK-NEXT: #endif
 public func returnsVariadicAlias() -> VariadicAlias< > {}
 
-// CHECK: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<Swift.Int, Swift.String, Swift.Float>
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public func returnsVariadicAlias() -> PackExpansionType.VariadicAlias<Swift.Int, Swift.String, Swift.Float>
+// CHECK-NEXT: #endif
 public func returnsVariadicAlias() -> VariadicAlias<Int, String, Float> {}
 
-// CHECK: public func returnsVariadicAlias<each T>() -> PackExpansionType.VariadicAlias<repeat each T>
+// CHECK: #if compiler(>=5.3) && $ParameterPacks
+// CHECK-NEXT: public func returnsVariadicAlias<each T>() -> PackExpansionType.VariadicAlias<repeat each T>
+// CHECK-NEXT: #endif
 public func returnsVariadicAlias<each T>() -> VariadicAlias<repeat each T> {}