LangOptions: Refactor feature state and API to account for adoption mode

Author: AnthonyLatsis

include/swift/Basic/Feature.h

@@ -21,7 +21,7 @@ namespace swift {
 class LangOptions;
 
 /// Enumeration describing all of the named features.
-enum class Feature {
+enum class Feature : uint16_t {
 #define LANGUAGE_FEATURE(FeatureName, IsAdoptable, SENumber, Description)      \
   FeatureName,
 #include "swift/Basic/Features.def"

include/swift/Basic/LangOptions.h

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -20,7 +20,6 @@
 
 #include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/Feature.h"
-#include "swift/Basic/FixedBitSet.h"
 #include "swift/Basic/FunctionBodySkipping.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/PlaygroundOption.h"
@@ -725,19 +724,6 @@ namespace swift {
       return cxxInteropCompatVersion.isVersionAtLeast(major, minor);
     }
 
-    /// Determine whether the given feature is enabled.
-    bool hasFeature(Feature feature) const;
-
-    /// Determine whether the given feature is enabled, looking up the feature
-    /// by name.
-    bool hasFeature(llvm::StringRef featureName) const;
-
-    /// Enable the given feature.
-    void enableFeature(Feature feature) { Features.insert(feature); }
-
-    /// Disable the given feature.
-    void disableFeature(Feature feature) { Features.remove(feature); }
-
     /// Sets the "_hasAtomicBitWidth" conditional.
     void setHasAtomicBitWidth(llvm::Triple triple);
 
@@ -822,10 +808,68 @@ namespace swift {
         PlatformConditionValues;
     llvm::SmallVector<std::string, 2> CustomConditionalCompilationFlags;
 
-    /// The set of features that have been enabled. Doesn't include upcoming
-    /// features, which are checked against the language version in
-    /// `hasFeature`.
-    FixedBitSet<numFeatures(), Feature> Features;
+  public:
+    // MARK: Features
+    // =========================================================================
+
+    /// A wrapper around the feature state enumeration.
+    struct FeatureState {
+      enum Kind : uint8_t { Off, EnabledForAdoption, Enabled };
+
+    private:
+      Feature feature;
+      Kind state;
+
+    public:
+      FeatureState(Feature feature, Kind state)
+          : feature(feature), state(state) {}
+
+      /// Returns whether the feature is enabled.
+      bool isEnabled() const;
+
+      /// Returns whether the feature is enabled in adoption mode. Should only
+      /// be called if the feature is known to support this mode.
+      bool isEnabledForAdoption() const;
+
+      operator Kind() const { return state; }
+    };
+
+  private:
+    class FeatureStateStorage {
+      std::vector<FeatureState::Kind> states;
+
+    public:
+      FeatureStateStorage();
+
+      /// Sets the given state for the given feature.
+      void setState(Feature feature, FeatureState::Kind state);
+
+      /// Retrieves the state of the given feature.
+      FeatureState getState(Feature feature) const;
+    };
+
+    /// The states of language features.
+    FeatureStateStorage featureStates;
+
+  public:
+    /// Retrieve the state of the given feature.
+    FeatureState getFeatureState(Feature feature) const;
+
+    /// Returns whether the given feature is enabled.
+    bool hasFeature(Feature feature) const;
+
+    /// Returns whether a feature with the given name is enabled. Returns
+    /// `false` if a feature by this name is not known.
+    bool hasFeature(llvm::StringRef featureName) const;
+
+    /// Enables the given feature (enables in adoption mode if `forAdoption` is
+    /// `true`).
+    void enableFeature(Feature feature, bool forAdoption = false);
+
+    /// Disables the given feature.
+    void disableFeature(Feature feature);
+
+    // =========================================================================
   };
 
   class TypeCheckerOptions final {

lib/Basic/LangOptions.cpp

@@ -17,6 +17,7 @@
 
 #include "swift/Basic/LangOptions.h"
 #include "swift/AST/DiagnosticEngine.h"
+#include "swift/Basic/Assertions.h"
 #include "swift/Basic/Feature.h"
 #include "swift/Basic/FileTypes.h"
 #include "swift/Basic/Platform.h"
@@ -35,7 +36,7 @@ using namespace swift;
 LangOptions::LangOptions() {
   // Add all promoted language features
 #define LANGUAGE_FEATURE(FeatureName, IsAdoptable, SENumber, Description)      \
-  Features.insert(Feature::FeatureName);
+  this->enableFeature(Feature::FeatureName);
 #define UPCOMING_FEATURE(FeatureName, SENumber, Version)
 #define EXPERIMENTAL_FEATURE(FeatureName, AvailableInProd)
 #define OPTIONAL_LANGUAGE_FEATURE(FeatureName, SENumber, Description)
@@ -44,14 +45,16 @@ LangOptions::LangOptions() {
   // Special case: remove macro support if the compiler wasn't built with a
   // host Swift.
 #if !SWIFT_BUILD_SWIFT_SYNTAX
-  Features.removeAll({Feature::Macros, Feature::FreestandingExpressionMacros,
-                      Feature::AttachedMacros, Feature::ExtensionMacros});
+  this->disableFeature(Feature::Macros);
+  this->disableFeature(Feature::FreestandingExpressionMacros);
+  this->disableFeature(Feature::AttachedMacros);
+  this->disableFeature(Feature::ExtensionMacros);
 #endif
 
   // Note: Introduce default-on language options here.
-  Features.insert(Feature::NoncopyableGenerics);
-  Features.insert(Feature::BorrowingSwitch);
-  Features.insert(Feature::MoveOnlyPartialConsumption);
+  this->enableFeature(Feature::NoncopyableGenerics);
+  this->enableFeature(Feature::BorrowingSwitch);
+  this->enableFeature(Feature::MoveOnlyPartialConsumption);
 
   // Enable any playground options that are enabled by default.
 #define PLAYGROUND_OPTION(OptionName, Description, DefaultOn, HighPerfOn) \
@@ -291,8 +294,50 @@ bool LangOptions::isCustomConditionalCompilationFlagSet(StringRef Name) const {
       != CustomConditionalCompilationFlags.end();
 }
 
+bool LangOptions::FeatureState::isEnabled() const {
+  return this->state != FeatureState::Off;
+}
+
+bool LangOptions::FeatureState::isEnabledForAdoption() const {
+  ASSERT(isFeatureAdoptable(this->feature) &&
+         "You forgot to make the feature adoptable!");
+
+  return this->state == FeatureState::EnabledForAdoption;
+}
+
+LangOptions::FeatureStateStorage::FeatureStateStorage()
+    : states(numFeatures(), FeatureState::Off) {}
+
+void LangOptions::FeatureStateStorage::setState(Feature feature,
+                                                FeatureState::Kind state) {
+  auto index = size_t(feature);
+
+  this->states[index] = state;
+}
+
+LangOptions::FeatureState
+LangOptions::FeatureStateStorage::getState(Feature feature) const {
+  auto index = size_t(feature);
+
+  return FeatureState(feature, this->states[index]);
+}
+
+LangOptions::FeatureState LangOptions::getFeatureState(Feature feature) const {
+  auto state = this->featureStates.getState(feature);
+  if (state.isEnabled())
+    return state;
+
+  if (auto version = getFeatureLanguageVersion(feature)) {
+    if (this->isSwiftVersionAtLeast(*version)) {
+      return FeatureState(feature, FeatureState::Enabled);
+    }
+  }
+
+  return state;
+}
+
 bool LangOptions::hasFeature(Feature feature) const {
-  if (Features.contains(feature))
+  if (this->featureStates.getState(feature).isEnabled())
     return true;
 
   if (auto version = getFeatureLanguageVersion(feature))
@@ -313,6 +358,19 @@ bool LangOptions::hasFeature(llvm::StringRef featureName) const {
   return false;
 }
 
+void LangOptions::enableFeature(Feature feature, bool forAdoption) {
+  if (forAdoption) {
+    ASSERT(isFeatureAdoptable(feature));
+    this->featureStates.setState(feature, FeatureState::EnabledForAdoption);
+  } else {
+    this->featureStates.setState(feature, FeatureState::Enabled);
+  }
+}
+
+void LangOptions::disableFeature(Feature feature) {
+  this->featureStates.setState(feature, FeatureState::Off);
+}
+
 void LangOptions::setHasAtomicBitWidth(llvm::Triple triple) {
   // We really want to use Clang's getMaxAtomicInlineWidth(), but that requires
   // a Clang::TargetInfo and we're setting up lang opts very early in the

lib/Frontend/CompilerInvocation.cpp

@@ -847,9 +847,6 @@ static bool ParseEnabledFeatureArgs(LangOptions &Opts, ArgList &Args,
                        option.getPrefixedName(), argValue);
         continue;
       }
-
-      // Adoption mode is not plumbed through; ignore it.
-      continue;
     }
 
     // Skip features that are already enabled or disabled.
@@ -858,7 +855,7 @@ static bool ParseEnabledFeatureArgs(LangOptions &Opts, ArgList &Args,
 
     // Enable the feature if requested.
     if (isEnableFeatureFlag)
-      Opts.enableFeature(*feature);
+      Opts.enableFeature(*feature, /*forAdoption=*/featureMode.has_value());
   }
 
   // Since pseudo-features don't have a boolean on/off state, process them in

lib/Sema/TypeCheckType.cpp

@@ -46,6 +46,7 @@
 #include "swift/AST/TypeResolutionStage.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/Basic/EnumMap.h"
+#include "swift/Basic/FixedBitSet.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/StringExtras.h"

lib/Sema/TypeCheckType.h

@@ -19,7 +19,6 @@
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeResolutionStage.h"
 #include "swift/AST/Types.h"
-#include "swift/Basic/LangOptions.h"
 
 namespace swift {
 

unittests/Frontend/FeatureParsingTest.cpp

@@ -41,3 +41,22 @@ void swift::PrintTo(const StrictConcurrency &value, std::ostream *os) {
     break;
   }
 }
+
+void swift::PrintTo(const LangOptions::FeatureState &value, std::ostream *os) {
+  PrintTo((const LangOptions::FeatureState::Kind &)value, os);
+}
+
+void swift::PrintTo(const LangOptions::FeatureState::Kind &value,
+                    std::ostream *os) {
+  switch (value) {
+  case LangOptions::FeatureState::Off:
+    *os << "Off";
+    break;
+  case LangOptions::FeatureState::EnabledForAdoption:
+    *os << "EnabledForAdoption";
+    break;
+  case LangOptions::FeatureState::Enabled:
+    *os << "Enabled";
+    break;
+  }
+}

unittests/Frontend/FeatureParsingTest.h

@@ -38,6 +38,8 @@ struct FeatureWrapper final {
 // the type they take.
 namespace swift {
 void PrintTo(const StrictConcurrency &, std::ostream *);
+void PrintTo(const LangOptions::FeatureState &, std::ostream *);
+void PrintTo(const LangOptions::FeatureState::Kind &, std::ostream *);
 } // end namespace swift
 
 #endif // FEATURE_PARSING_TEST_H