Add #available guards to init(rawValue:)

beccadax · beccadax · commit a6c23790f92f · 2019-01-28T17:34:54.000-08:00
When a case has an @available(currentPlatform, introduced: x.y) attribute, the auto-derived init(rawValue:) will now include a “guard #available(currentPlatform x.y, *) else { return nil }” check to prevent the new case from being returned. This requires a targeted hack to disable @available(introduced:) checks in auto-derived init(rawValue:) implementations; the availability checker is SourceLoc-based, so it can’t tell that the synthesized `guard` covers the use of the case. I’m not happy about that, but fixing the deeper problem is a much larger task than I can take on in one day.
diff --git a/lib/Sema/DerivedConformanceRawRepresentable.cpp b/lib/Sema/DerivedConformanceRawRepresentable.cpp
@@ -192,13 +192,17 @@ static void
 deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
   // enum SomeEnum : SomeType {
   //   case A = 111, B = 222
+  //   @available(iOS 10, *) case C = 333
   //   @derived
   //   init?(rawValue: SomeType) {
   //     switch rawValue {
   //     case 111:
   //       self = .A
   //     case 222:
   //       self = .B
+  //     case 333:
+  //       guard #available(iOS 10, *) else { return nil }
+  //       self = .C
   //     default:
   //       return nil
   //     }
@@ -234,6 +238,7 @@ 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
     LiteralExpr *litExpr = cloneRawLiteralExpr(C, elt->getRawValueExpr());
     if (isStringEnum) {
       // In case of a string enum we are calling the _findStringSwitchCase
@@ -245,23 +250,78 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
                                       nullptr, nullptr);
     litPat->setImplicit();
 
-    auto labelItem = CaseLabelItem(litPat);
+    // Will collect any preliminary guards, plus the final assignment.
+    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);
+      }
+    }
 
+    // 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"
     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")
     auto body = BraceStmt::create(C, SourceLoc(),
-                                  ASTNode(assignment), SourceLoc());
+                                  stmts, SourceLoc());
 
-    cases.push_back(CaseStmt::create(C, SourceLoc(), labelItem,
+    // cases.append("case \(litPat): \(body)")
+    cases.push_back(CaseStmt::create(C, SourceLoc(), CaseLabelItem(litPat),
                                      /*HasBoundDecls=*/false, SourceLoc(),
                                      SourceLoc(), body));
     Idx++;
diff --git a/lib/Sema/TypeCheckAvailability.cpp b/lib/Sema/TypeCheckAvailability.cpp
@@ -2301,6 +2301,19 @@ class AvailabilityWalker : public ASTWalker {
   Optional<TypeChecker::FragileFunctionKind> FragileKind;
   bool TreatUsableFromInlineAsPublic = false;
 
+  /// Returns true if DC is an \c init(rawValue:) declaration and it is marked
+  /// implicit.
+  bool inSynthesizedInitRawValue() {
+    auto init = dyn_cast_or_null<ConstructorDecl>(
+                    DC->getInnermostDeclarationDeclContext());
+
+    return init &&
+           init->isImplicit() &&
+           init->getParameters()->size() == 1 &&
+           init->getParameters()->get(0)->getArgumentName() ==
+                   DC->getASTContext().Id_rawValue;
+  }
+
 public:
   AvailabilityWalker(
       TypeChecker &TC, DeclContext *DC) : TC(TC), DC(DC) {
@@ -2320,8 +2333,20 @@ class AvailabilityWalker : public ASTWalker {
     };
 
     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
+      DeclAvailabilityFlags flags = None;
+      if (inSynthesizedInitRawValue())
+        // HACK: If a raw-value enum has cases with `@available(introduced:)`
+        // attributes, the auto-derived `init(rawValue:)` will contain
+        // DeclRefExprs which reference those cases. It will also contain
+        // appropriate `guard #available` statements to keep them from running
+        // on older versions, but the availability checker can't verify that
+        // because the synthesized code uses invalid SourceLocs. Don't diagnose
+        // these errors; instead, take it on faith that
+        // DerivedConformanceRawRepresentable will do the right thing.
+        flags |= DeclAvailabilityFlag::AllowPotentiallyUnavailable;
+
       diagAvailability(DR->getDecl(), DR->getSourceRange(),
-                       getEnclosingApplyExpr());
+                       getEnclosingApplyExpr(), flags);
       maybeDiagStorageAccess(DR->getDecl(), DR->getSourceRange(), DC);
     }
     if (auto MR = dyn_cast<MemberRefExpr>(E)) {
@@ -2583,6 +2608,9 @@ AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
         && isa<ProtocolDecl>(D))
     return false;
 
+  if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailable))
+    return false;
+
   // Diagnose (and possibly signal) for potential unavailability
   auto maybeUnavail = TC.checkDeclarationAvailability(D, R.Start, DC);
   if (maybeUnavail.hasValue()) {
diff --git a/lib/Sema/TypeCheckAvailability.h b/lib/Sema/TypeCheckAvailability.h
@@ -38,6 +38,7 @@ enum class DeclAvailabilityFlag : uint8_t {
   AllowPotentiallyUnavailableProtocol = 1 << 0,
   ContinueOnPotentialUnavailability = 1 << 1,
   ForInout = 1 << 2,
+  AllowPotentiallyUnavailable = 1 << 3,
 };
 using DeclAvailabilityFlags = OptionSet<DeclAvailabilityFlag>;
 
diff --git a/test/SILGen/enum_raw_representable_available.swift b/test/SILGen/enum_raw_representable_available.swift
@@ -0,0 +1,21 @@
+// 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
+
+public enum E: Int {
+  case a, b
+  @available(macOS 500, iOS 500, watchOS 500, tvOS 500, *)
+  case c
+}
+
+// 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_available1EO0B5ValueSivg
+// CHECK: switch_enum %0 : $E
+// CHECK: end sil function '$s32enum_raw_representable_available1EO0B5ValueSivg'
+
+
+// CHECK-RESILIENT-DAG: sil [ossa] @$s32enum_raw_representable_available1EO0B5ValueACSgSi_tcfC
+// CHECK-RESILIENT-DAG: sil [ossa] @$s32enum_raw_representable_available1EO0B5ValueSivg
