[NFC] Basic: Use scoped enum for feature states

To prevent unexpected implicit conversions to integral types.

Author: AnthonyLatsis

include/swift/Basic/LangOptions.h

@@ -814,7 +814,7 @@ namespace swift {
 
     /// A wrapper around the feature state enumeration.
     struct FeatureState {
-      enum Kind : uint8_t { Off, EnabledForAdoption, Enabled };
+      enum class Kind : uint8_t { Off, EnabledForAdoption, Enabled };
 
     private:
       Feature feature;

lib/Basic/LangOptions.cpp

@@ -295,18 +295,18 @@ bool LangOptions::isCustomConditionalCompilationFlagSet(StringRef Name) const {
 }
 
 bool LangOptions::FeatureState::isEnabled() const {
-  return this->state != FeatureState::Off;
+  return this->state != FeatureState::Kind::Off;
 }
 
 bool LangOptions::FeatureState::isEnabledForAdoption() const {
   ASSERT(isFeatureAdoptable(this->feature) &&
          "You forgot to make the feature adoptable!");
 
-  return this->state == FeatureState::EnabledForAdoption;
+  return this->state == FeatureState::Kind::EnabledForAdoption;
 }
 
 LangOptions::FeatureStateStorage::FeatureStateStorage()
-    : states(numFeatures(), FeatureState::Off) {}
+    : states(numFeatures(), FeatureState::Kind::Off) {}
 
 void LangOptions::FeatureStateStorage::setState(Feature feature,
                                                 FeatureState::Kind state) {
@@ -329,7 +329,7 @@ LangOptions::FeatureState LangOptions::getFeatureState(Feature feature) const {
 
   if (auto version = getFeatureLanguageVersion(feature)) {
     if (this->isSwiftVersionAtLeast(*version)) {
-      return FeatureState(feature, FeatureState::Enabled);
+      return FeatureState(feature, FeatureState::Kind::Enabled);
     }
   }
 
@@ -361,14 +361,15 @@ bool LangOptions::hasFeature(llvm::StringRef featureName) const {
 void LangOptions::enableFeature(Feature feature, bool forAdoption) {
   if (forAdoption) {
     ASSERT(isFeatureAdoptable(feature));
-    this->featureStates.setState(feature, FeatureState::EnabledForAdoption);
+    this->featureStates.setState(feature,
+                                 FeatureState::Kind::EnabledForAdoption);
   } else {
-    this->featureStates.setState(feature, FeatureState::Enabled);
+    this->featureStates.setState(feature, FeatureState::Kind::Enabled);
   }
 }
 
 void LangOptions::disableFeature(Feature feature) {
-  this->featureStates.setState(feature, FeatureState::Off);
+  this->featureStates.setState(feature, FeatureState::Kind::Off);
 }
 
 void LangOptions::setHasAtomicBitWidth(llvm::Triple triple) {

unittests/Frontend/FeatureParsingTest.cpp

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

unittests/Frontend/IsFeatureEnabledTests.cpp

@@ -23,10 +23,10 @@ static const FeatureWrapper adoptableUpcomingF(Feature::ExistentialAny);
 static const FeatureWrapper experimentalF(Feature::StructLetDestructuring);
 static const FeatureWrapper strictConcurrencyF(Feature::StrictConcurrency);
 
-using FeatureState = LangOptions::FeatureState;
+using FeatureState = LangOptions::FeatureState::Kind;
 
 using IsFeatureEnabledTestCase =
-    ArgParsingTestCase<std::map<Feature, FeatureState::Kind>>;
+    ArgParsingTestCase<std::map<Feature, FeatureState>>;
 
 class IsFeatureEnabledTest
     : public FeatureParsingTest,