Refactor availability-checking code to handle more cases

beccadax · beccadax · commit 5da6668b8a5c · 2019-02-04T15:54:23.000-08:00
Moves a lot of it into helper functions and types so it doesn’t disrupt the main flow of the code so much. Also makes it handle always-unavailable and obsolete cases (by skipping them).
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -147,7 +147,7 @@ const AvailableAttr *DeclAttributes::getPotentiallyUnavailable(
         continue;
 
       // Definitely not available.
-      if (AvAttr->isUnconditionallyDeprecated())
+      if (AvAttr->isUnconditionallyUnavailable())
         return AvAttr;
 
       switch (AvAttr->getVersionAvailability(ctx)) {
@@ -164,6 +164,7 @@ const AvailableAttr *DeclAttributes::getPotentiallyUnavailable(
         case AvailableVersionComparison::Unavailable:
         case AvailableVersionComparison::Obsoleted:
           conditional = AvAttr;
+          break;
       }
     }
 
diff --git a/lib/Sema/DerivedConformanceRawRepresentable.cpp b/lib/Sema/DerivedConformanceRawRepresentable.cpp
@@ -188,6 +188,83 @@ static VarDecl *deriveRawRepresentable_raw(DerivedConformance &derived) {
   return propDecl;
 }
 
+/// Contains information needed to synthesize a runtime version check.
+struct RuntimeVersionCheck {
+  PlatformKind Platform;
+  llvm::VersionTuple Version;
+
+  RuntimeVersionCheck(PlatformKind Platform, llvm::VersionTuple Version)
+    : Platform(Platform), Version(Version)
+  { }
+
+  VersionRange getVersionRange() const {
+    return VersionRange::allGTE(Version);
+  }
+
+  /// Synthesizes a statement which returns nil if the runtime version check
+  /// fails, e.g. "guard #available(iOS 10, *) else { return nil }".
+  Stmt *createEarlyReturnStmt(ASTContext &C) const {
+    // platformSpec = "\(attr.platform) \(attr.introduced)"
+    auto platformSpec = new (C) PlatformVersionConstraintAvailabilitySpec(
+                            Platform, SourceLoc(),
+                            Version, SourceLoc()
+                        );
+
+    // otherSpec = "*"
+    auto otherSpec = new (C) OtherPlatformAvailabilitySpec(SourceLoc());
+
+    // availableInfo = "#available(\(platformSpec), \(otherSpec))"
+    auto availableInfo = PoundAvailableInfo::create(C, SourceLoc(),
+                                              { platformSpec, otherSpec },
+                                                    SourceLoc());
+
+    // This won't be filled in by TypeCheckAvailability because we have
+    // invalid SourceLocs in this area of the AST.
+    availableInfo->setAvailableRange(getVersionRange());
+
+    // earlyReturnBody = "{ return nil }"
+    auto earlyReturn = new (C) FailStmt(SourceLoc(), SourceLoc());
+    auto earlyReturnBody = BraceStmt::create(C, SourceLoc(),
+                                             ASTNode(earlyReturn),
+                                             SourceLoc(), /*implicit=*/true);
+
+    // guardStmt = "guard \(availableInfo) else \(earlyReturnBody)"
+    StmtConditionElement conds[1] = { availableInfo };
+    auto guardStmt = new (C) GuardStmt(SourceLoc(), C.AllocateCopy(conds),
+                                       earlyReturnBody, /*implicit=*/true);
+
+    return guardStmt;
+  }
+};
+
+/// Checks if the case will be available at runtime given the current target
+/// platform. If it will never be available, returns false. If it will always
+/// be available, returns true. If it will sometimes be available, adds
+/// information about the runtime check needed to ensure it is available to
+/// \c versionCheck and returns true.
+static bool checkAvailability(EnumElementDecl* elt, ASTContext &C,
+                              Optional<RuntimeVersionCheck> &versionCheck) {
+  auto *attr = elt->getAttrs().getPotentiallyUnavailable(C);
+
+  // Is it always available?
+  if (!attr)
+    return true;
+
+  AvailableVersionComparison availability = attr->getVersionAvailability(C);
+
+  assert(availability != AvailableVersionComparison::Available &&
+         "DeclAttributes::getPotentiallyUnavailable() shouldn't "
+         "return an available attribute");
+
+  // Is it never available?
+  if (availability != AvailableVersionComparison::PotentiallyUnavailable)
+    return false;
+
+  // It's conditionally available; create a version constraint and return true.
+  versionCheck.emplace(attr->Platform, *attr->Introduced);
+  return true;
+}
+
 static void
 deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
   // enum SomeEnum : SomeType {
@@ -238,7 +315,15 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
   SmallVector<ASTNode, 4> cases;
   unsigned Idx = 0;
   for (auto elt : enumDecl->getAllElements()) {
-    // litPat = "\(elt.rawValueExpr)", e.g. "42" as a pattern
+    // First, check case availability. If the case will definitely be
+    // unavailable, skip it. If it might be unavailable at runtime, save
+    // information about that check in versionCheck and keep processing this
+    // element.
+    Optional<RuntimeVersionCheck> versionCheck(None);
+    if (!checkAvailability(elt, C, versionCheck))
+      continue;
+
+    // litPat = elt.rawValueExpr as a pattern
     LiteralExpr *litExpr = cloneRawLiteralExpr(C, elt->getRawValueExpr());
     if (isStringEnum) {
       // In case of a string enum we are calling the _findStringSwitchCase
@@ -250,73 +335,31 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
                                       nullptr, nullptr);
     litPat->setImplicit();
 
-    // Will collect any preliminary guards, plus the final assignment.
+    /// Statements in the body of this case.
     SmallVector<ASTNode, 2> stmts;
 
-    // If there's an @available attribute specifying when the case was
-    // introduced, generate an early return on unavailability, e.g.
-    // "guard #available(iOS 9, *) else { return nil }"
-    for (auto *attr : elt->getAttrs().getAttributes<AvailableAttr>()) {
-      // We only care about attributes which have an "introduced" version for
-      // the platform we're building for. We don't care about language version
-      // because we may be compiling in an older language mode, but writing APIs
-      // for a newer one.
-      if (attr->Introduced.hasValue() && attr->hasPlatform() &&
-          attr->isActivePlatform(C) &&
-          *attr->Introduced > C.LangOpts.getMinPlatformVersion()) {
-        // platformSpec = "\(attr.platform) \(attr.introduced)"
-        auto platformSpec =
-          new (C) PlatformVersionConstraintAvailabilitySpec(
-            attr->Platform, SourceLoc(),
-            *attr->Introduced, SourceLoc()
-          );
-
-        // otherSpec = "*"
-        auto otherSpec = new (C) OtherPlatformAvailabilitySpec(SourceLoc());
-
-        // availableInfo = "#available(\(platformSpec), \(otherSpec))"
-        auto availableInfo = PoundAvailableInfo::create(C, SourceLoc(),
-                                                { platformSpec, otherSpec },
-                                                        SourceLoc());
-
-        // This won't be filled in by TypeCheckAvailability because we have
-        // invalid SourceLocs in this area of the AST.
-        auto versionRange = VersionRange::allGTE(*attr->Introduced);
-        availableInfo->setAvailableRange(versionRange);
-
-        // earlyReturnBody = "{ return nil }"
-        auto earlyReturn = new (C) FailStmt(SourceLoc(), SourceLoc());
-        auto earlyReturnBody = BraceStmt::create(C, SourceLoc(),
-                                                 ASTNode(earlyReturn),
-                                                 SourceLoc(), /*implicit=*/true);
-
-        // guardStmt = "guard \(vailableInfo) else \(earlyReturnBody)"
-        SmallVector<StmtConditionElement, 1>
-        conds{StmtConditionElement(availableInfo)};
-        auto guardStmt = new (C) GuardStmt(SourceLoc(), C.AllocateCopy(conds),
-                                           earlyReturnBody, /*implicit=*/true);
-
-        stmts.push_back(guardStmt);
-      }
-    }
+    // If checkAvailability() discovered we need a runtime version check,
+    // add it now.
+    if (versionCheck.hasValue())
+      stmts.push_back(ASTNode(versionCheck->createEarlyReturnStmt(C)));
+
+    // Create a statement which assigns the case to self.
 
     // valueExpr = "\(enumType).\(elt)"
     auto eltRef = new (C) DeclRefExpr(elt, DeclNameLoc(), /*implicit*/true);
     auto metaTyRef = TypeExpr::createImplicit(enumType, C);
     auto valueExpr = new (C) DotSyntaxCallExpr(eltRef, SourceLoc(), metaTyRef);
     
-    // selfRef = "self"
+    // assignment = "self = \(valueExpr)"
     auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(),
                                        /*implicit*/true,
                                        AccessSemantics::DirectToStorage);
-
-    // assignment = "\(selfRef) = \(valueExpr)"
     auto assignment = new (C) AssignExpr(selfRef, SourceLoc(), valueExpr,
                                          /*implicit*/ true);
 
     stmts.push_back(ASTNode(assignment));
     
-    // body = stmts.joined(separator: "\n")
+    // body = "{ \(stmts) }" (the braces are silent)
     auto body = BraceStmt::create(C, SourceLoc(),
                                   stmts, SourceLoc());
 
diff --git a/test/SILGen/enum_raw_representable_available.swift b/test/SILGen/enum_raw_representable_available.swift
@@ -1,24 +1,67 @@
 // RUN: %target-typecheck-verify-swift
 // RUN: %target-swift-emit-silgen -emit-sorted-sil %s | %FileCheck %s
-// RUN: %target-swift-emit-silgen -emit-sorted-sil -enable-resilience %s | %FileCheck -check-prefix=CHECK-RESILIENT %s
+// RUN: %target-swift-emit-silgen -emit-sorted-sil -enable-resilience %s | %FileCheck %s
 
 // Really just requires a platform with meaningful runtime #available() tests.
 // REQUIRES: objc_interop
 
 public enum E: Int {
-  case a, b
-  @available(macOS 500, iOS 500, watchOS 500, tvOS 500, *)
-  case c
+  // For some reason, we generate strange SIL for the first case that's
+  // difficult to validate. This just gets that out of the way.
+  case sacrificial = -500
+
+  case normal = -1000
+  @available(macOS 10.8, iOS 8, watchOS 1, tvOS 8, *)
+  case alwaysAvailable = -2000
+  @available(macOS 500.600.700, iOS 500.600.700, watchOS 500.600.700, tvOS 500.600.700, *)
+  case potentiallyUnavailable = -3000
+  @available(macOS, unavailable) @available(iOS, unavailable)
+  @available(watchOS, unavailable)  @available(tvOS, unavailable)
+  case neverAvailable = -4000
 }
 
-// CHECK-LABEL: sil [serialized] [ossa] @$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC
-// CHECK: integer_literal $Builtin.Word, 500
-// CHECK: end sil function '$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC'
+// CHECK-LABEL: sil {{(\[serialized\] )?}}[ossa] @$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC
 
-// CHECK-LABEL: sil [serialized] [ossa] @$s32enum_raw_representable_available1EO0B5ValueSivg
-// CHECK: switch_enum %0 : $E
-// CHECK: end sil function '$s32enum_raw_representable_available1EO0B5ValueSivg'
+// CHECK-NOT: integer_literal $Builtin.IntLiteral, -4000
+
+// CHECK: integer_literal $Builtin.IntLiteral, -1000
+// CHECK: cond_br {{[^,]+}}, [[normal:bb[0-9]+]]
+
+// CHECK-NOT: integer_literal $Builtin.IntLiteral, -4000
+
+// CHECK: integer_literal $Builtin.IntLiteral, -2000
+// CHECK: cond_br {{[^,]+}}, [[alwaysAvailable:bb[0-9]+]]
+
+// CHECK-NOT: integer_literal $Builtin.IntLiteral, -4000
+
+// CHECK: integer_literal $Builtin.IntLiteral, -3000
+// CHECK: cond_br {{[^,]+}}, [[potentiallyUnavailable:bb[0-9]+]]
 
+// CHECK-NOT: integer_literal $Builtin.IntLiteral, -4000
 
-// CHECK-RESILIENT-DAG: sil [ossa] @$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC
-// CHECK-RESILIENT-DAG: sil [ossa] @$s32enum_raw_representable_available1EO0B5ValueSivg
+// CHECK: [[potentiallyUnavailable]]:
+// CHECK-NEXT: integer_literal $Builtin.Word, 500
+// CHECK-NEXT: integer_literal $Builtin.Word, 600
+// CHECK-NEXT: integer_literal $Builtin.Word, 700
+// CHECK: function_ref @$ss26_stdlib_isOSVersionAtLeastyBi1_Bw_BwBwtF
+// CHECK: cond_br {{[^,]+}}, [[potentiallyUnavailable_newEnough:bb[0-9]+]],
+
+// CHECK-NOT: integer_literal $Builtin.IntLiteral, -4000
+
+// CHECK: [[potentiallyUnavailable_newEnough]]:
+// CHECK: {{enum \$E|inject_enum_addr %[0-9]+ : \$\*E}}, #E.potentiallyUnavailable!enumelt
+
+// CHECK: [[alwaysAvailable]]:
+// CHECK-NOT: function_ref @$ss26_stdlib_isOSVersionAtLeastyBi1_Bw_BwBwtF
+// CHECK: {{enum \$E|inject_enum_addr %[0-9]+ : \$\*E}}, #E.alwaysAvailable!enumelt
+
+// CHECK: [[normal]]:
+// CHECK-NOT: function_ref @$ss26_stdlib_isOSVersionAtLeastyBi1_Bw_BwBwtF
+// CHECK: {{enum \$E|inject_enum_addr %[0-9]+ : \$\*E}}, #E.normal!enumelt
+
+// CHECK: end sil function '$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC'
+
+// CHECK-LABEL: sil {{(\[serialized\] )?}}[ossa] @$s32enum_raw_representable_available1EO0B5ValueSivg
+// CHECK: {{switch_enum %0 : \$E|switch_enum_addr %2 : \$\*E}}
+// CHECK-NOT: function_ref @$ss26_stdlib_isOSVersionAtLeastyBi1_Bw_BwBwtF
+// CHECK: end sil function '$s32enum_raw_representable_available1EO0B5ValueSivg'

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ const AvailableAttr *DeclAttributes::getPotentiallyUnavailable(`
`147`	`147`	`continue;`
`148`	`148`
`149`	`149`	`// Definitely not available.`
`150`		`- if (AvAttr->isUnconditionallyDeprecated())`
	`150`	`+ if (AvAttr->isUnconditionallyUnavailable())`
`151`	`151`	`return AvAttr;`
`152`	`152`
`153`	`153`	`switch (AvAttr->getVersionAvailability(ctx)) {`
`@@ -164,6 +164,7 @@ const AvailableAttr *DeclAttributes::getPotentiallyUnavailable(`
`164`	`164`	`case AvailableVersionComparison::Unavailable:`
`165`	`165`	`case AvailableVersionComparison::Obsoleted:`
`166`	`166`	`conditional = AvAttr;`
	`167`	`+ break;`
`167`	`168`	`}`
`168`	`169`	`}`
`169`	`170`