[Parse] Support macCatalyst conditional compilation

Add support for conditional compilation under macCatalyst

Developers can now detect whether they are compiling for macCatalyst at
compile time with:

  #if targetEnvironment(macCatalyst)
    // Code only compiled under macCatalyst.
  #end

Author: devincoughlin

include/swift/AST/DiagnosticsParse.def

@@ -1651,6 +1651,8 @@ ERROR(empty_version_string,none,
 WARNING(unknown_platform_condition_argument,none,
       "unknown %0 for build configuration '%1'",
       (StringRef, StringRef))
+WARNING(renamed_platform_condition_argument,none,
+      "'%0' has been renamed to '%1'", (StringRef, StringRef))
 WARNING(likely_simulator_platform_condition,none,
       "platform condition appears to be testing for simulator environment; "
       "use 'targetEnvironment(simulator)' instead",

include/swift/Basic/LangOptions.h

@@ -413,7 +413,8 @@ namespace swift {
     ///
     /// \param suggestedKind Populated with suggested replacement platform condition
     /// \param suggestedValues Populated with suggested replacement values
-    /// if a match is not found.
+    /// if a match is not found, or if the value has been deprecated
+    /// in favor of a newer one.
     static bool checkPlatformConditionSupported(
       PlatformConditionKind Kind, StringRef Value,
       PlatformConditionKind &suggestedKind,

lib/Basic/LangOptions.cpp

@@ -26,7 +26,18 @@
 
 using namespace swift;
 
-static const StringRef SupportedConditionalCompilationOSs[] = {
+struct SupportedConditionalValue {
+  StringRef value;
+
+  /// If the value has been deprecated, the new value to replace it with.
+  StringRef replacement = "";
+
+  SupportedConditionalValue(const char *value) : value(value) {}
+  SupportedConditionalValue(const char *value, const char *replacement)
+    : value(value), replacement(replacement) {}
+};
+
+static const SupportedConditionalValue SupportedConditionalCompilationOSs[] = {
   "OSX",
   "macOS",
   "tvOS",
@@ -42,7 +53,7 @@ static const StringRef SupportedConditionalCompilationOSs[] = {
   "WASI",
 };
 
-static const StringRef SupportedConditionalCompilationArches[] = {
+static const SupportedConditionalValue SupportedConditionalCompilationArches[] = {
   "arm",
   "arm64",
   "i386",
@@ -53,18 +64,20 @@ static const StringRef SupportedConditionalCompilationArches[] = {
   "wasm32",
 };
 
-static const StringRef SupportedConditionalCompilationEndianness[] = {
+static const SupportedConditionalValue SupportedConditionalCompilationEndianness[] = {
   "little",
   "big"
 };
 
-static const StringRef SupportedConditionalCompilationRuntimes[] = {
+static const SupportedConditionalValue SupportedConditionalCompilationRuntimes[] = {
   "_ObjC",
   "_Native",
 };
 
-static const StringRef SupportedConditionalCompilationTargetEnvironments[] = {
+static const SupportedConditionalValue SupportedConditionalCompilationTargetEnvironments[] = {
   "simulator",
+  { "macabi", "macCatalyst" },
+  "macCatalyst", // A synonym for "macabi" when compiling for iOS
 };
 
 static const PlatformConditionKind AllPublicPlatformConditionKinds[] = {
@@ -73,7 +86,7 @@ static const PlatformConditionKind AllPublicPlatformConditionKinds[] = {
 #include "swift/AST/PlatformConditionKinds.def"
 };
 
-ArrayRef<StringRef> getSupportedConditionalCompilationValues(const PlatformConditionKind &Kind) {
+ArrayRef<SupportedConditionalValue> getSupportedConditionalCompilationValues(const PlatformConditionKind &Kind) {
   switch (Kind) {
   case PlatformConditionKind::OS:
     return SupportedConditionalCompilationOSs;
@@ -97,11 +110,11 @@ PlatformConditionKind suggestedPlatformConditionKind(PlatformConditionKind Kind,
   for (const PlatformConditionKind& candidateKind : AllPublicPlatformConditionKinds) {
     if (candidateKind != Kind) {
       auto supportedValues = getSupportedConditionalCompilationValues(candidateKind);
-      for (const StringRef& candidateValue : supportedValues) {
-        if (candidateValue.lower() == lower) {
+      for (const SupportedConditionalValue& candidateValue : supportedValues) {
+        if (candidateValue.value.lower() == lower) {
           suggestedValues.clear();
-          if (candidateValue != V) {
-            suggestedValues.emplace_back(candidateValue);
+          if (candidateValue.value != V) {
+            suggestedValues.emplace_back(candidateValue.value);
           }
           return candidateKind;
         }
@@ -118,19 +131,21 @@ bool isMatching(PlatformConditionKind Kind, const StringRef &V,
   unsigned minDistance = std::numeric_limits<unsigned>::max();
   std::string lower = V.lower();
   auto supportedValues = getSupportedConditionalCompilationValues(Kind);
-  for (const StringRef& candidate : supportedValues) {
-    if (candidate == V) {
+  for (const SupportedConditionalValue& candidate : supportedValues) {
+    if (candidate.value == V) {
       suggestedKind = Kind;
       suggestions.clear();
+      if (!candidate.replacement.empty())
+        suggestions.push_back(candidate.replacement);
       return true;
     }
-    unsigned distance = StringRef(lower).edit_distance(candidate.lower());
+    unsigned distance = StringRef(lower).edit_distance(candidate.value.lower());
     if (distance < minDistance) {
       suggestions.clear();
       minDistance = distance;
     }
     if (distance == minDistance)
-      suggestions.emplace_back(candidate);
+      suggestions.emplace_back(candidate.value);
   }
   suggestedKind = suggestedPlatformConditionKind(Kind, V, suggestions);
   return false;
@@ -171,6 +186,16 @@ checkPlatformCondition(PlatformConditionKind Kind, StringRef Value) const {
   if (Kind == PlatformConditionKind::OS && Value == "macOS")
     return checkPlatformCondition(Kind, "OSX");
 
+  // When compiling for iOS we consider "macCatalyst" to be a
+  // synonym of "macabi". This enables the use of
+  // #if targetEnvironment(macCatalyst) as a compilation
+  // condition for macCatalyst.
+
+  if (Kind == PlatformConditionKind::TargetEnvironment &&
+      Value == "macCatalyst" && Target.isiOS()) {
+    return checkPlatformCondition(Kind, "macabi");
+  }
+
   for (auto &Opt : llvm::reverse(PlatformConditionValues)) {
     if (Opt.first == Kind)
       if (Opt.second == Value)
@@ -321,6 +346,10 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
     addPlatformConditionValue(PlatformConditionKind::TargetEnvironment,
                               "simulator");
 
+  if (tripleIsMacCatalystEnvironment(Target))
+    addPlatformConditionValue(PlatformConditionKind::TargetEnvironment,
+                              "macabi");
+
   // If you add anything to this list, change the default size of
   // PlatformConditionValues to not require an extra allocation
   // in the common case.

lib/Parse/ParseIfConfig.cpp

@@ -311,6 +311,16 @@ class ValidateIfConfigCondition :
         D.diagnose(Loc, diag::note_typo_candidate, suggestion)
           .fixItReplace(Arg->getSourceRange(), suggestion);
     }
+    else if (!suggestedValues.empty()) {
+      // The value the user gave has been replaced by something newer.
+      assert(suggestedValues.size() == 1 && "only support one replacement");
+      auto replacement = suggestedValues.front();
+
+      auto Loc = Arg->getLoc();
+      D.diagnose(Loc, diag::renamed_platform_condition_argument,
+                 *ArgStr, replacement)
+        .fixItReplace(Arg->getSourceRange(), replacement);
+    }
 
     return E;
   }

test/Parse/ConditionalCompilation/basicParseErrors.swift

@@ -148,7 +148,7 @@ undefinedFunc() // expected-error {{use of unresolved identifier 'undefinedFunc'
 #if _endian(arm64) // expected-warning {{unknown endianness for build configuration '_endian'}} expected-note {{did you mean 'arch'}} {{5-12=arch}}
 #endif
 
-#if targetEnvironment(_ObjC) // expected-warning {{unknown target environment for build configuration 'targetEnvironment'}} expected-note {{did you mean 'simulator'}} {{23-28=simulator}}
+#if targetEnvironment(_ObjC) // expected-warning {{unknown target environment for build configuration 'targetEnvironment'}} expected-note {{did you mean 'macabi'}} {{23-28=macabi}}
 #endif
 
 #if os(iOS) || os(simulator) // expected-warning {{unknown operating system for build configuration 'os'}} expected-note {{did you mean 'targetEnvironment'}} {{16-18=targetEnvironment}}

test/Parse/ConditionalCompilation/macabiTargetEnv.swift

@@ -0,0 +1,36 @@
+// RUN: %swift -swift-version 4 -typecheck %s -verify -target x86_64-apple-ios12.0-macabi -parse-stdlib
+// RUN: %swift-ide-test -swift-version 4 -test-input-complete -source-filename=%s -target x86_64-apple-ios12.0-macabi
+
+// REQUIRES: OS=maccatalyst
+
+#if targetEnvironment(macabi) // expected-warning {{'macabi' has been renamed to 'macCatalyst'}} {{23-29=macCatalyst}}
+func underMacABI() {
+  foo() // expected-error {{use of unresolved identifier 'foo'}}
+}
+#endif
+
+#if !targetEnvironment(macabi) // expected-warning {{'macabi' has been renamed to 'macCatalyst'}} {{24-30=macCatalyst}}
+// This block does not typecheck but the #if prevents it from
+// from being a compiler error.
+let i: SomeType = "SomeString" // no-error
+#endif
+
+#if targetEnvironment(macCatalyst)
+func underTargetEnvironmentMacCatalyst() {
+  foo() // expected-error {{use of unresolved identifier 'foo'}}
+}
+#endif
+
+// Make sure we don't treat the macabi environment as a simulator.
+#if targetEnvironment(simulator)
+// This block does not typecheck but the #if prevents it from
+// from being a compiler error.
+let i: SomeType = "SomeString" // no-error
+#endif
+
+#if os(macCatalyst)
+// expected-warning@-1 {{unknown operating system for build configuration 'os'}}
+// expected-note@-2 *{{did you mean}}
+func underOSMacCatalyst() {
+}
+#endif