[ModuleInterface] Add mechanism to exclude experimental flags from the module interface

rdar://109722548

Author: drexin

include/swift/Basic/Feature.h

@@ -66,6 +66,10 @@ llvm::Optional<Feature> getExperimentalFeature(llvm::StringRef name);
 /// \c None if it does not have such a version.
 llvm::Optional<unsigned> getFeatureLanguageVersion(Feature feature);
 
+/// Determine whether this feature should be included in the
+/// module interface
+bool includeInModuleInterface(Feature feature);
+
 }
 
 #endif // SWIFT_BASIC_FEATURES_H

include/swift/Basic/Features.def

@@ -57,7 +57,7 @@
 #ifndef EXPERIMENTAL_FEATURE
 // Warning: setting `AvailableInProd` to `true` on a feature means that the flag
 //          cannot be dropped in the future.
-#  define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)  \
+#  define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd, IncludeInModuleInterface) \
      LANGUAGE_FEATURE(FeatureName, 0, #FeatureName, \
                       langOpts.hasFeature(#FeatureName))
 #endif
@@ -109,92 +109,92 @@ UPCOMING_FEATURE(BareSlashRegexLiterals, 354, 6)
 UPCOMING_FEATURE(ExistentialAny, 335, 6)
 UPCOMING_FEATURE(ImportObjcForwardDeclarations, 384, 6)
 
-EXPERIMENTAL_FEATURE(StaticAssert, false)
-EXPERIMENTAL_FEATURE(VariadicGenerics, false)
-EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false)
-EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false)
-EXPERIMENTAL_FEATURE(FreestandingMacros, true)
-EXPERIMENTAL_FEATURE(CodeItemMacros, true)
-EXPERIMENTAL_FEATURE(TupleConformances, false)
+EXPERIMENTAL_FEATURE(StaticAssert, false, true)
+EXPERIMENTAL_FEATURE(VariadicGenerics, false, true)
+EXPERIMENTAL_FEATURE(NamedOpaqueTypes, false, true)
+EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures, false, true)
+EXPERIMENTAL_FEATURE(FreestandingMacros, true, true)
+EXPERIMENTAL_FEATURE(CodeItemMacros, true, true)
+EXPERIMENTAL_FEATURE(TupleConformances, false, true)
 
 // FIXME: MoveOnlyClasses is not intended to be in production,
 // but our tests currently rely on it, and we want to run those
 // tests in non-asserts builds too.
-EXPERIMENTAL_FEATURE(MoveOnlyClasses, true)
-EXPERIMENTAL_FEATURE(NoImplicitCopy, true)
-EXPERIMENTAL_FEATURE(OldOwnershipOperatorSpellings, true)
-EXPERIMENTAL_FEATURE(MoveOnlyEnumDeinits, true)
-EXPERIMENTAL_FEATURE(MoveOnlyTuples, true)
+EXPERIMENTAL_FEATURE(MoveOnlyClasses, true, true)
+EXPERIMENTAL_FEATURE(NoImplicitCopy, true, true)
+EXPERIMENTAL_FEATURE(OldOwnershipOperatorSpellings, true, true)
+EXPERIMENTAL_FEATURE(MoveOnlyEnumDeinits, true, true)
+EXPERIMENTAL_FEATURE(MoveOnlyTuples, true, true)
 
-EXPERIMENTAL_FEATURE(OneWayClosureParameters, false)
-EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false)
-EXPERIMENTAL_FEATURE(LayoutPrespecialization, true)
+EXPERIMENTAL_FEATURE(OneWayClosureParameters, false, true)
+EXPERIMENTAL_FEATURE(TypeWitnessSystemInference, false, true)
+EXPERIMENTAL_FEATURE(LayoutPrespecialization, true, true)
 
-EXPERIMENTAL_FEATURE(ModuleInterfaceExportAs, true)
-EXPERIMENTAL_FEATURE(AccessLevelOnImport, true)
+EXPERIMENTAL_FEATURE(ModuleInterfaceExportAs, true, true)
+EXPERIMENTAL_FEATURE(AccessLevelOnImport, true, true)
 
 /// Whether to enable experimental layout string value witnesses
-EXPERIMENTAL_FEATURE(LayoutStringValueWitnesses, true)
-EXPERIMENTAL_FEATURE(LayoutStringValueWitnessesInstantiation, true)
+EXPERIMENTAL_FEATURE(LayoutStringValueWitnesses, true, false)
+EXPERIMENTAL_FEATURE(LayoutStringValueWitnessesInstantiation, true, false)
 
 /// Whether to enable experimental differentiable programming features:
 /// `@differentiable` declaration attribute, etc.
-EXPERIMENTAL_FEATURE(DifferentiableProgramming, false)
+EXPERIMENTAL_FEATURE(DifferentiableProgramming, false, true)
 
 /// Whether to enable forward mode differentiation.
-EXPERIMENTAL_FEATURE(ForwardModeDifferentiation, false)
+EXPERIMENTAL_FEATURE(ForwardModeDifferentiation, false, true)
 
 /// Whether to enable experimental `AdditiveArithmetic` derived
 /// conformances.
-EXPERIMENTAL_FEATURE(AdditiveArithmeticDerivedConformances, false)
+EXPERIMENTAL_FEATURE(AdditiveArithmeticDerivedConformances, false, true)
 
 /// Whether Objective-C completion handler parameters are imported as
 /// @Sendable.
-EXPERIMENTAL_FEATURE(SendableCompletionHandlers, false)
+EXPERIMENTAL_FEATURE(SendableCompletionHandlers, false, true)
 
 /// Enables opaque type erasure without also enabling implict dynamic
-EXPERIMENTAL_FEATURE(OpaqueTypeErasure, false)
+EXPERIMENTAL_FEATURE(OpaqueTypeErasure, false, true)
 
 /// Whether to perform round-trip testing of the Swift Swift parser.
-EXPERIMENTAL_FEATURE(ParserRoundTrip, false)
+EXPERIMENTAL_FEATURE(ParserRoundTrip, false, true)
 
 /// Whether to perform validation of the parse tree produced by the Swift
 /// Swift parser.
-EXPERIMENTAL_FEATURE(ParserValidation, false)
+EXPERIMENTAL_FEATURE(ParserValidation, false, true)
 
 /// Whether to emit diagnostics from the new parser first, and only emit
 /// diagnostics from the existing parser when there are none from the new
 /// parser.
-EXPERIMENTAL_FEATURE(ParserDiagnostics, false)
+EXPERIMENTAL_FEATURE(ParserDiagnostics, false, true)
 
 /// Enables implicit some while also enabling existential `any`
-EXPERIMENTAL_FEATURE(ImplicitSome, false)
+EXPERIMENTAL_FEATURE(ImplicitSome, false, true)
 
 /// Parse using the Swift (swift-syntax) parser and use ASTGen to generate the
 /// corresponding syntax tree.
-EXPERIMENTAL_FEATURE(ParserASTGen, false)
+EXPERIMENTAL_FEATURE(ParserASTGen, false, true)
 
 /// Parse using the Swift (swift-syntax) parser and use ASTGen to generate the
 /// corresponding syntax tree.
-EXPERIMENTAL_FEATURE(BuiltinMacros, false)
+EXPERIMENTAL_FEATURE(BuiltinMacros, false, true)
 
 /// Whether to enable experimental @runtimeMetadata feature which allows to
 /// declare an attribute which is discoverable and constructable at runtime.
-EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false)
+EXPERIMENTAL_FEATURE(RuntimeDiscoverableAttrs, false, true)
 
 /// Import C++ class templates as semantically-meaningless symbolic
 /// Swift types and C++ methods as symbolic functions with blank
 /// signatures.
-EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false)
+EXPERIMENTAL_FEATURE(ImportSymbolicCXXDecls, false, true)
 
 /// Generate bindings for functions that 'throw' in the C++ section of the generated Clang header.
-EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false)
+EXPERIMENTAL_FEATURE(GenerateBindingsForThrowingFunctionsInCXX, false, true)
 
 /// Enable reference bindings.
-EXPERIMENTAL_FEATURE(ReferenceBindings, false)
+EXPERIMENTAL_FEATURE(ReferenceBindings, false, true)
 
 /// Enable the explicit 'import Builtin' and allow Builtin usage.
-EXPERIMENTAL_FEATURE(BuiltinModule, true)
+EXPERIMENTAL_FEATURE(BuiltinModule, true, true)
 
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

lib/Basic/LangOptions.cpp

@@ -489,7 +489,7 @@ bool swift::isFeatureAvailableInProduction(Feature feature) {
   switch (feature) {
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)  \
   case Feature::FeatureName: return true;
-#define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)            \
+#define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd, IncludeInModuleInterface) \
   case Feature::FeatureName: return AvailableInProd;
 #include "swift/Basic/Features.def"
   }
@@ -508,7 +508,7 @@ llvm::Optional<Feature> swift::getUpcomingFeature(llvm::StringRef name) {
 llvm::Optional<Feature> swift::getExperimentalFeature(llvm::StringRef name) {
   return llvm::StringSwitch<Optional<Feature>>(name)
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
-#define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)                  \
+#define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd, IncludeInModuleInterface) \
                    .Case(#FeatureName, Feature::FeatureName)
 #include "swift/Basic/Features.def"
                    .Default(None);
@@ -524,6 +524,17 @@ llvm::Optional<unsigned> swift::getFeatureLanguageVersion(Feature feature) {
   }
 }
 
+bool swift::includeInModuleInterface(Feature feature) {
+  switch (feature) {
+#define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)  \
+  case Feature::FeatureName: return true;
+#define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd, IncludeInModuleInterface) \
+  case Feature::FeatureName: return IncludeInModuleInterface;
+#include "swift/Basic/Features.def"
+  }
+  llvm_unreachable("covered switch");
+}
+
 DiagnosticBehavior LangOptions::getAccessNoteFailureLimit() const {
   switch (AccessNoteBehavior) {
   case AccessNoteDiagnosticBehavior::Ignore:

lib/Frontend/CompilerInvocation.cpp

@@ -417,6 +417,19 @@ static void ParseModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
   }
 }
 
+/// Checks if an arg is generally allowed to be included
+/// in a module interface
+static bool ShouldIncludeModuleInterfaceArg(const Arg *A) {
+  if (!A->getOption().matches(options::OPT_enable_experimental_feature))
+    return true;
+
+  if (auto feature = getExperimentalFeature(A->getValue())) {
+    return swift::includeInModuleInterface(*feature);
+  }
+
+  return true;
+}
+
 /// Save a copy of any flags marked as ModuleInterfaceOption, if running
 /// in a mode that is going to emit a .swiftinterface file.
 static void SaveModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
@@ -428,6 +441,9 @@ static void SaveModuleInterfaceArgs(ModuleInterfaceOptions &Opts,
   ArgStringList RenderedArgsIgnorable;
   ArgStringList RenderedArgsIgnorablePrivate;
   for (auto A : Args) {
+    if (!ShouldIncludeModuleInterfaceArg(A))
+      continue;
+
     if (A->getOption().hasFlag(options::ModuleInterfaceOptionIgnorablePrivate)) {
       A->render(Args, RenderedArgsIgnorablePrivate);
     } else if (A->getOption().hasFlag(options::ModuleInterfaceOptionIgnorable)) {

test/ModuleInterface/option-filtering.swift

@@ -0,0 +1,10 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -enable-library-evolution -emit-module-interface-path %t.swiftinterface -module-name t %s -target-min-inlining-version 42 -emit-module -o /dev/null -O -enable-experimental-feature LayoutStringValueWitnesses -enable-experimental-feature LayoutStringValueWitnessesInstantiation
+// RUN: %FileCheck %s < %t.swiftinterface -check-prefix=CHECK-SWIFTINTERFACE
+//
+// CHECK-SWIFTINTERFACE: swift-module-flags-ignorable:
+// CHECK-SWIFTINTERFACE-NOT: -enable-experimental-feature LayoutStringValueWitnesses
+// CHECK-SWIFTINTERFACE-NOT: -enable-experimental-feature LayoutStringValueWitnessesInstantiation
+
+public func foo() { }