[LangOptions] Introduce a new enum class for platform conditions (#7843)

rintaro · web-flow · commit 1f3c66226c20 · 2017-03-02T01:58:20.000+09:00
diff --git a/include/swift/Basic/LangOptions.h b/include/swift/Basic/LangOptions.h
@@ -29,6 +29,20 @@
 #include <vector>
 
 namespace swift {
+
+  /// Kind of implicit platform conditions.
+  enum class PlatformConditionKind {
+    /// The active os target (OSX, iOS, Linux, etc.)
+    OS,
+    /// The active arch target (x86_64, i386, arm, arm64, etc.)
+    Arch,
+    /// The active endianness target (big or little)
+    Endianness,
+    /// Runtime support (_ObjC or _Native)
+    Runtime,
+  };
+  enum { NumPlatformConditionKind = 4 };
+
   /// \brief A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions {
@@ -202,14 +216,9 @@ namespace swift {
     }
 
     /// Sets an implicit platform condition.
-    ///
-    /// There are currently three supported platform conditions:
-    /// - os: The active os target (OSX or iOS)
-    /// - arch: The active arch target (x86_64, i386, arm, arm64)
-    /// - _runtime: Runtime support (_ObjC or _Native)
-    void addPlatformConditionValue(StringRef Name, StringRef Value) {
-      assert(!Name.empty() && !Value.empty());
-      PlatformConditionValues.emplace_back(Name, Value);
+    void addPlatformConditionValue(PlatformConditionKind Kind, StringRef Value) {
+      assert(!Value.empty());
+      PlatformConditionValues.emplace_back(Kind, Value);
     }
 
     /// Removes all values added with addPlatformConditionValue.
@@ -218,7 +227,7 @@ namespace swift {
     }
     
     /// Returns the value for the given platform condition or an empty string.
-    StringRef getPlatformConditionValue(StringRef Name) const;
+    StringRef getPlatformConditionValue(PlatformConditionKind Kind) const;
 
     /// Explicit conditional compilation flags, initialized via the '-D'
     /// compiler flag.
@@ -230,7 +239,7 @@ namespace swift {
     /// Determines if a given conditional compilation flag has been set.
     bool isCustomConditionalCompilationFlagSet(StringRef Name) const;
 
-    ArrayRef<std::pair<std::string, std::string>>
+    ArrayRef<std::pair<PlatformConditionKind, std::string>>
     getPlatformConditionValues() const {
       return PlatformConditionValues;
     }
@@ -244,35 +253,18 @@ namespace swift {
       return EffectiveLanguageVersion.isVersion3();
     }
 
-    /// Returns true if the 'os' platform condition argument represents
+    /// Returns true if the given platform condition argument represents
     /// a supported target operating system.
     ///
-    /// Note that this also canonicalizes the OS name if the check returns
-    /// true.
-    ///
-    /// \param suggestions Populated with suggested replacements
-    /// if a match is not found.
-    static bool checkPlatformConditionOS(
-      StringRef &OSName, std::vector<StringRef> &suggestions);
-
-    /// Returns true if the 'arch' platform condition argument represents
-    /// a supported target architecture.
-    ///
-    /// \param suggestions Populated with suggested replacements
-    /// if a match is not found.
-    static bool isPlatformConditionArchSupported(
-      StringRef ArchName, std::vector<StringRef> &suggestions);
-
-    /// Returns true if the 'endian' platform condition argument represents
-    /// a supported target endianness.
-    ///
     /// \param suggestions Populated with suggested replacements
     /// if a match is not found.
-    static bool isPlatformConditionEndiannessSupported(
-      StringRef endianness, std::vector<StringRef> &suggestions);
+    static bool checkPlatformConditionSupported(
+      PlatformConditionKind Kind, StringRef Value,
+      std::vector<StringRef> &suggestions);
 
   private:
-    llvm::SmallVector<std::pair<std::string, std::string>, 3>
+    llvm::SmallVector<std::pair<PlatformConditionKind, std::string>,
+                      NumPlatformConditionKind>
         PlatformConditionValues;
     llvm::SmallVector<std::string, 2> CustomConditionalCompilationFlags;
   };
diff --git a/lib/Basic/LangOptions.cpp b/lib/Basic/LangOptions.cpp
@@ -52,6 +52,11 @@ static const StringRef SupportedConditionalCompilationEndianness[] = {
   "big"
 };
 
+static const StringRef SupportedConditionalCompilationRuntimes[] = {
+  "_ObjC",
+  "_Native",
+};
+
 template <size_t N>
 bool contains(const StringRef (&Array)[N], const StringRef &V,
               std::vector<StringRef> &suggestions) {
@@ -75,36 +80,31 @@ bool contains(const StringRef (&Array)[N], const StringRef &V,
   return false;
 }
 
-bool LangOptions::checkPlatformConditionOS(
-  StringRef &OSName, std::vector<StringRef> &suggestions) {
-  if (OSName == "macOS")
-    OSName = "OSX";
-  return contains(SupportedConditionalCompilationOSs,
-                  OSName,
-                  suggestions);
-}
-
-bool
-LangOptions::isPlatformConditionArchSupported(
-  StringRef ArchName, std::vector<StringRef> &suggestions) {
-  return contains(SupportedConditionalCompilationArches,
-                  ArchName,
-                  suggestions);
-}
-
-bool
-LangOptions::isPlatformConditionEndiannessSupported(
-  StringRef Endianness, std::vector<StringRef> &suggestions) {
-  return contains(SupportedConditionalCompilationEndianness,
-                  Endianness,
-                  suggestions);
+bool LangOptions::
+checkPlatformConditionSupported(PlatformConditionKind Kind, StringRef Value,
+                                std::vector<StringRef> &suggestions) {
+  switch (Kind) {
+  case PlatformConditionKind::OS:
+    return contains(SupportedConditionalCompilationOSs, Value,
+                    suggestions);
+  case PlatformConditionKind::Arch:
+    return contains(SupportedConditionalCompilationArches, Value,
+                    suggestions);
+  case PlatformConditionKind::Endianness:
+    return contains(SupportedConditionalCompilationEndianness, Value,
+                    suggestions);
+  case PlatformConditionKind::Runtime:
+    return contains(SupportedConditionalCompilationRuntimes, Value,
+                    suggestions);
+  }
+  llvm_unreachable("Unhandled enum value");
 }
 
 StringRef
-LangOptions::getPlatformConditionValue(StringRef Name) const {
+LangOptions::getPlatformConditionValue(PlatformConditionKind Kind) const {
   // Last one wins.
   for (auto &Opt : reversed(PlatformConditionValues)) {
-    if (Opt.first == Name)
+    if (Opt.first == Kind)
       return Opt.second;
   }
   return StringRef();
@@ -141,23 +141,23 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
 
   // Set the "os" platform condition.
   if (Target.isMacOSX())
-    addPlatformConditionValue("os", "OSX");
+    addPlatformConditionValue(PlatformConditionKind::OS, "OSX");
   else if (triple.isTvOS())
-    addPlatformConditionValue("os", "tvOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "tvOS");
   else if (triple.isWatchOS())
-    addPlatformConditionValue("os", "watchOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "watchOS");
   else if (triple.isiOS())
-    addPlatformConditionValue("os", "iOS");
+    addPlatformConditionValue(PlatformConditionKind::OS, "iOS");
   else if (triple.isAndroid())
-    addPlatformConditionValue("os", "Android");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Android");
   else if (triple.isOSLinux())
-    addPlatformConditionValue("os", "Linux");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Linux");
   else if (triple.isOSFreeBSD())
-    addPlatformConditionValue("os", "FreeBSD");
+    addPlatformConditionValue(PlatformConditionKind::OS, "FreeBSD");
   else if (triple.isOSWindows())
-    addPlatformConditionValue("os", "Windows");
+    addPlatformConditionValue(PlatformConditionKind::OS, "Windows");
   else if (triple.isPS4())
-    addPlatformConditionValue("os", "PS4");
+    addPlatformConditionValue(PlatformConditionKind::OS, "PS4");
   else
     UnsupportedOS = true;
 
@@ -167,25 +167,25 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
   switch (Target.getArch()) {
   case llvm::Triple::ArchType::arm:
   case llvm::Triple::ArchType::thumb:
-    addPlatformConditionValue("arch", "arm");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "arm");
     break;
   case llvm::Triple::ArchType::aarch64:
-    addPlatformConditionValue("arch", "arm64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "arm64");
     break;
   case llvm::Triple::ArchType::ppc64:
-    addPlatformConditionValue("arch", "powerpc64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "powerpc64");
     break;
   case llvm::Triple::ArchType::ppc64le:
-    addPlatformConditionValue("arch", "powerpc64le");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "powerpc64le");
     break;
   case llvm::Triple::ArchType::x86:
-    addPlatformConditionValue("arch", "i386");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "i386");
     break;
   case llvm::Triple::ArchType::x86_64:
-    addPlatformConditionValue("arch", "x86_64");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "x86_64");
     break;
   case llvm::Triple::ArchType::systemz:
-    addPlatformConditionValue("arch", "s390x");
+    addPlatformConditionValue(PlatformConditionKind::Arch, "s390x");
     break;
   default:
     UnsupportedArch = true;
@@ -198,35 +198,35 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
   switch (Target.getArch()) {
   case llvm::Triple::ArchType::arm:
   case llvm::Triple::ArchType::thumb:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::aarch64:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::ppc64:
-    addPlatformConditionValue("_endian", "big");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "big");
     break;
   case llvm::Triple::ArchType::ppc64le:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::x86:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::x86_64:
-    addPlatformConditionValue("_endian", "little");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "little");
     break;
   case llvm::Triple::ArchType::systemz:
-    addPlatformConditionValue("_endian", "big");
+    addPlatformConditionValue(PlatformConditionKind::Endianness, "big");
     break;
   default:
     llvm_unreachable("undefined architecture endianness");
   }
 
   // Set the "runtime" platform condition.
   if (EnableObjCInterop)
-    addPlatformConditionValue("_runtime", "_ObjC");
+    addPlatformConditionValue(PlatformConditionKind::Runtime, "_ObjC");
   else
-    addPlatformConditionValue("_runtime", "_Native");
+    addPlatformConditionValue(PlatformConditionKind::Runtime, "_Native");
 
   // If you add anything to this list, change the default size of
   // PlatformConditionValues to not require an extra allocation
diff --git a/lib/Parse/ParseIfConfig.cpp b/lib/Parse/ParseIfConfig.cpp
@@ -16,8 +16,10 @@
 
 #include "swift/Parse/Parser.h"
 #include "swift/Basic/Defer.h"
+#include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Version.h"
 #include "swift/Parse/Lexer.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/SaveAndRestore.h"
 
@@ -356,51 +358,46 @@ Parser::classifyConditionalCompilationExpr(Expr *condition,
         // tolerate extra parens).
         auto argumentIdent = UDRE->getName().getBaseName();
         auto argument = argumentIdent.str();
+        PlatformConditionKind Kind =
+          llvm::StringSwitch<PlatformConditionKind>(fnName)
+          .Case("os", PlatformConditionKind::OS)
+          .Case("arch", PlatformConditionKind::Arch)
+          .Case("_endian", PlatformConditionKind::Endianness)
+          .Case("_runtime", PlatformConditionKind::Runtime);
 
-        // Error for values that don't make sense if there's a clear definition
-        // of the possible values (as there is for _runtime).
-        if (fnName.equals("_runtime") &&
-            !argument.equals("_ObjC") && !argument.equals("_Native")) {
-          D.diagnose(CE->getLoc(),
-                     diag::unsupported_platform_runtime_condition_argument);
-          return ConditionalCompilationExprState::error();
-        }
+        // FIXME: Perform the replacement macOS -> OSX elsewhere.
+        if (Kind == PlatformConditionKind::OS && argument == "macOS")
+          argument = "OSX";
 
         std::vector<StringRef> suggestions;
-        SWIFT_DEFER {
-          for (const StringRef& suggestion : suggestions) {
-            D.diagnose(UDRE->getLoc(), diag::note_typo_candidate,
-                       suggestion)
-            .fixItReplace(UDRE->getSourceRange(), suggestion);
-          }
-        };
-        if (fnName == "os") {
-          if (!LangOptions::checkPlatformConditionOS(argument,
-                                                     suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "operating system", fnName);
+        if (!LangOptions::checkPlatformConditionSupported(Kind, argument,
+                                                          suggestions)) {
+          if (Kind == PlatformConditionKind::Runtime) {
+            // Error for _runtime()
+            D.diagnose(UDRE->getLoc(),
+                       diag::unsupported_platform_runtime_condition_argument);
             return ConditionalCompilationExprState::error();
           }
-        } else if (fnName == "arch") {
-          if (!LangOptions::isPlatformConditionArchSupported(argument,
-                                                             suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "architecture", fnName);
-            return ConditionalCompilationExprState::error();
+          StringRef DiagName;
+          switch (Kind) {
+          case PlatformConditionKind::OS:
+            DiagName = "operating system"; break;
+          case PlatformConditionKind::Arch:
+            DiagName = "architecture"; break;
+          case PlatformConditionKind::Endianness:
+            DiagName = "endianness"; break;
+          case PlatformConditionKind::Runtime:
+            llvm_unreachable("handled above");
           }
-        } else if (fnName == "_endian") {
-          if (!LangOptions::isPlatformConditionEndiannessSupported(argument,
-                                                                   suggestions)) {
-            D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
-                       "endianness", fnName);
+          D.diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
+                     DiagName, fnName);
+          for (const StringRef &suggestion : suggestions) {
+            D.diagnose(UDRE->getLoc(), diag::note_typo_candidate, suggestion)
+              .fixItReplace(UDRE->getSourceRange(), suggestion);
           }
         }
 
-        // FIXME: Perform the replacement macOS -> OSX elsewhere.
-        if (fnName == "os" && argument == "macOS")
-          argument = "OSX";
-
-        auto target = Context.LangOpts.getPlatformConditionValue(fnName);
+        auto target = Context.LangOpts.getPlatformConditionValue(Kind);
         return {target == argument, ConditionalCompilationExprKind::DeclRef};
       } else {
         D.diagnose(CE->getLoc(), diag::unsupported_platform_condition_argument,
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
@@ -96,7 +96,7 @@ findModule(ASTContext &ctx, AccessPathElem moduleID,
   // FIXME: Which name should we be using here? Do we care about CPU subtypes?
   // FIXME: At the very least, don't hardcode "arch".
   llvm::SmallString<16> archFile{
-      ctx.LangOpts.getPlatformConditionValue("arch")};
+      ctx.LangOpts.getPlatformConditionValue(PlatformConditionKind::Arch)};
   llvm::SmallString<16> archDocFile{archFile};
   if (!archFile.empty()) {
     archFile += '.';
