Merge pull request swiftlang#22324 from devincoughlin/factor-out-active-target-helper

Author: swift-ci

lib/AST/PlatformKind.cpp

@@ -56,35 +56,43 @@ Optional<PlatformKind> swift::platformFromString(StringRef Name) {
       .Default(Optional<PlatformKind>());
 }
 
-bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts) {
+static bool isPlatformActiveForTarget(PlatformKind Platform,
+                                      const llvm::Triple &Target,
+                                      bool EnableAppExtensionRestrictions) {
   if (Platform == PlatformKind::none)
     return true;
 
   if (Platform == PlatformKind::OSXApplicationExtension ||
       Platform == PlatformKind::iOSApplicationExtension)
-    if (!LangOpts.EnableAppExtensionRestrictions)
+    if (!EnableAppExtensionRestrictions)
       return false;
 
   // FIXME: This is an awful way to get the current OS.
   switch (Platform) {
     case PlatformKind::OSX:
     case PlatformKind::OSXApplicationExtension:
-      return LangOpts.Target.isMacOSX();
+      return Target.isMacOSX();
     case PlatformKind::iOS:
     case PlatformKind::iOSApplicationExtension:
-      return LangOpts.Target.isiOS() && !LangOpts.Target.isTvOS();
+      return Target.isiOS() && !Target.isTvOS();
     case PlatformKind::tvOS:
     case PlatformKind::tvOSApplicationExtension:
-      return LangOpts.Target.isTvOS();
+      return Target.isTvOS();
     case PlatformKind::watchOS:
     case PlatformKind::watchOSApplicationExtension:
-      return LangOpts.Target.isWatchOS();
+      return Target.isWatchOS();
     case PlatformKind::none:
       llvm_unreachable("handled above");
   }
   llvm_unreachable("bad PlatformKind");
 }
 
+bool swift::isPlatformActive(PlatformKind Platform, LangOptions &LangOpts) {
+  llvm::Triple TT = LangOpts.Target;
+  return isPlatformActiveForTarget(Platform, TT,
+                                   LangOpts.EnableAppExtensionRestrictions);
+}
+
 PlatformKind swift::targetPlatform(LangOptions &LangOpts) {
   if (LangOpts.Target.isMacOSX()) {
     return (LangOpts.EnableAppExtensionRestrictions

lib/SILGen/SILGenDecl.cpp

@@ -1194,25 +1194,38 @@ void SILGenFunction::visitVarDecl(VarDecl *D) {
   // We handle emitting the variable storage when we see the pattern binding.
 }
 
-/// Emit a check that returns 1 if the running OS version is in
-/// the specified version range and 0 otherwise. The returned SILValue
-/// (which has type Builtin.Int1) represents the result of this check.
-SILValue SILGenFunction::emitOSVersionRangeCheck(SILLocation loc,
-                                                 const VersionRange &range) {
-  // Emit constants for the checked version range.
-  llvm::VersionTuple Vers = range.getLowerEndpoint();
+/// Emit literals for the major, minor, and subminor components of the version
+/// and return a tuple of SILValues for them.
+static std::tuple<SILValue, SILValue, SILValue>
+emitVersionLiterals(SILLocation loc, SILGenBuilder &B, ASTContext &ctx,
+                    llvm::VersionTuple Vers) {
   unsigned major = Vers.getMajor();
   unsigned minor =
       (Vers.getMinor().hasValue() ? Vers.getMinor().getValue() : 0);
   unsigned subminor =
       (Vers.getSubminor().hasValue() ? Vers.getSubminor().getValue() : 0);
 
-  SILType wordType = SILType::getBuiltinWordType(getASTContext());
+  SILType wordType = SILType::getBuiltinWordType(ctx);
 
   SILValue majorValue = B.createIntegerLiteral(loc, wordType, major);
   SILValue minorValue = B.createIntegerLiteral(loc, wordType, minor);
   SILValue subminorValue = B.createIntegerLiteral(loc, wordType, subminor);
 
+  return std::make_tuple(majorValue, minorValue, subminorValue);
+}
+
+/// Emit a check that returns 1 if the running OS version is in
+/// the specified version range and 0 otherwise. The returned SILValue
+/// (which has type Builtin.Int1) represents the result of this check.
+SILValue SILGenFunction::emitOSVersionRangeCheck(SILLocation loc,
+                                                 const VersionRange &range) {
+  // Emit constants for the checked version range.
+  SILValue majorValue;
+  SILValue minorValue;
+  SILValue subminorValue;
+  std::tie(majorValue, minorValue, subminorValue) =
+      emitVersionLiterals(loc, B, getASTContext(), range.getLowerEndpoint());
+
   // Emit call to _stdlib_isOSVersionAtLeast(major, minor, patch)
   FuncDecl *versionQueryDecl =
       getASTContext().getIsOSVersionAtLeastDecl();