basic: introduce the _environment compilation conditional

Windows has multiple environment flavours, each of which are different.  cygwin
provides a glibc based environment, MinGW provides a msvcrt based GNU
environment, itanium provides a msvc environment with an itanium C++ ABI, and
msvc is the pure msvc, msvcprt based environment as vended by Microsoft.  Due to
the differences in the environment, we need a means to differentiate them at the
stdlib level.  Provide the _environment conditional which would allow you to
query what environment is being targeted.

Author: compnerd

include/swift/Basic/LangOptions.h

@@ -242,6 +242,10 @@ namespace swift {
     /// a supported target endianness.
     static bool isPlatformConditionEndiannessSupported(StringRef endianness);
 
+    /// Returns true if the 'environment' platform condition argument represents
+    /// a supported target environment.
+    static bool isPlatformConditionEnvironmentSupported(StringRef Environment);
+
   private:
     llvm::SmallVector<std::pair<std::string, std::string>, 3>
         PlatformConditionValues;

lib/Basic/LangOptions.cpp

@@ -50,6 +50,13 @@ static const StringRef SupportedConditionalCompilationEndianness[] = {
   "big"
 };
 
+static const StringRef SupportedConditionalCompilationEnvironment[] = {
+  "cygnus",
+  "gnu",
+  "msvc",
+  "itanium",
+};
+
 template <typename Type, size_t N>
 bool contains(const Type (&Array)[N], const Type &V) {
   return std::find(std::begin(Array), std::end(Array), V) != std::end(Array);
@@ -69,6 +76,11 @@ LangOptions::isPlatformConditionEndiannessSupported(StringRef Endianness) {
   return contains(SupportedConditionalCompilationEndianness, Endianness);
 }
 
+bool
+LangOptions::isPlatformConditionEnvironmentSupported(StringRef Environment) {
+  return contains(SupportedConditionalCompilationEnvironment, Environment);
+}
+
 StringRef
 LangOptions::getPlatformConditionValue(StringRef Name) const {
   // Last one wins.
@@ -191,6 +203,24 @@ std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
     llvm_unreachable("undefined architecture endianness");
   }
 
+  // Set the "_environment" platform condition.
+  switch (Target.getEnvironment()) {
+  default: break;
+  case llvm::Triple::MSVC:
+    addPlatformConditionValue("_environment", "msvc");
+    break;
+  case llvm::Triple::Itanium:
+    addPlatformConditionValue("_environment", "itanium");
+    break;
+  case llvm::Triple::Cygnus:
+    addPlatformConditionValue("_environment", "cygnus");
+    break;
+  case llvm::Triple::GNU:
+    if (triple.isOSWindows())
+      addPlatformConditionValue("_environment", "gnu");
+    break;
+  }
+
   // Set the "runtime" platform condition.
   if (EnableObjCInterop)
     addPlatformConditionValue("_runtime", "_ObjC");

lib/Parse/ParseStmt.cpp

@@ -1603,9 +1603,8 @@ Parser::evaluateConditionalCompilationExpr(Expr *condition) {
     }
 
     if (!fnName.equals("arch") && !fnName.equals("os") &&
-        !fnName.equals("_endian") &&
-        !fnName.equals("_runtime") &&
-        !fnName.equals("swift") &&
+        !fnName.equals("_endian") && !fnName.equals("_environment") &&
+        !fnName.equals("_runtime") && !fnName.equals("swift") &&
         !fnName.equals("_compiler_version")) {
       diagnose(CE->getLoc(), diag::unsupported_platform_condition_expression);
       return ConditionalCompilationExprState::error();
@@ -1699,6 +1698,11 @@ Parser::evaluateConditionalCompilationExpr(Expr *condition) {
             diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
                      "endianness", fnName);
           }
+        } else if (fnName == "_environment") {
+          if (!LangOptions::isPlatformConditionEnvironmentSupported(argument)) {
+            diagnose(UDRE->getLoc(), diag::unknown_platform_condition_argument,
+                     "environment", fnName);
+          }
         }
         auto target = Context.LangOpts.getPlatformConditionValue(fnName);
         return {target == argument, ConditionalCompilationExprKind::DeclRef};

test/Parse/ConditionalCompilation/cygwinTarget.swift

@@ -0,0 +1,9 @@
+// RUN: %swift -parse %s -target x86_64-unknown-windows-cygnus -parse-as-library -parse-stdlib -verify
+
+#if _environment(cygnus)
+public class cygwin {
+}
+#endif
+
+let instance = cygwin()
+

test/Parse/ConditionalCompilation/mingwTarget.swift

@@ -0,0 +1,9 @@
+// RUN: %swift -parse %s -target i686-unknown-windows-gnu -parse-as-library -parse-stdlib -verify
+
+#if _environment(gnu)
+public class MinGW {
+}
+#endif
+
+let instance = MinGW()
+

test/Parse/ConditionalCompilation/windowsItaniumEnvironment.swift

@@ -0,0 +1,9 @@
+// RUN: %swift -parse %s -target i686-unknown-windows-itanium -parse-as-library -parse-stdlib -verify
+
+#if _environment(itanium)
+public class itanium {
+}
+#endif
+
+let instance = itanium()
+

test/Parse/ConditionalCompilation/windowsMSVCenvironment.swift

@@ -0,0 +1,9 @@
+// RUN: %swift -parse %s -target i686-unknown-windows-msvc -parse-as-library -parse-stdlib -verify
+
+#if _environment(msvc)
+public class msvc {
+}
+#endif
+
+let instance = msvc()
+