Merge pull request swiftlang#22198 from brentdax/im-on-the-case

Guard returns of limited-availability cases in init(rawValue:)

Author: beccadax

include/swift/AST/Attr.h

@@ -1446,6 +1446,11 @@ class DeclAttributes {
   bool
   isUnavailableInSwiftVersion(const version::Version &effectiveVersion) const;
 
+  /// Returns the first @available attribute that indicates
+  /// a declaration is unavailable, or the first one that indicates it's
+  /// potentially unavailable, or null otherwise.
+  const AvailableAttr *getPotentiallyUnavailable(const ASTContext &ctx) const;
+
   /// Returns the first @available attribute that indicates
   /// a declaration is unavailable, or null otherwise.
   const AvailableAttr *getUnavailable(const ASTContext &ctx) const;

lib/AST/Attr.cpp

@@ -131,6 +131,48 @@ DeclAttributes::isUnavailableInSwiftVersion(
   return false;
 }
 
+const AvailableAttr *
+DeclAttributes::getPotentiallyUnavailable(const ASTContext &ctx) const {
+  const AvailableAttr *potential = nullptr;
+  const AvailableAttr *conditional = nullptr;
+
+  for (auto Attr : *this)
+    if (auto AvAttr = dyn_cast<AvailableAttr>(Attr)) {
+      if (AvAttr->isInvalid())
+        continue;
+
+      if (!AvAttr->isActivePlatform(ctx) &&
+          !AvAttr->isLanguageVersionSpecific() &&
+          !AvAttr->isPackageDescriptionVersionSpecific())
+        continue;
+
+      // Definitely not available.
+      if (AvAttr->isUnconditionallyUnavailable())
+        return AvAttr;
+
+      switch (AvAttr->getVersionAvailability(ctx)) {
+      case AvailableVersionComparison::Available:
+        // Doesn't limit the introduced version.
+        break;
+
+      case AvailableVersionComparison::PotentiallyUnavailable:
+        // We'll return this if we don't see something that proves it's
+        // not available in this version.
+        potential = AvAttr;
+        break;
+
+      case AvailableVersionComparison::Unavailable:
+      case AvailableVersionComparison::Obsoleted:
+        conditional = AvAttr;
+        break;
+      }
+    }
+
+  if (conditional)
+    return conditional;
+  return potential;
+}
+
 const AvailableAttr *DeclAttributes::getUnavailable(
                           const ASTContext &ctx) const {
   const AvailableAttr *conditional = nullptr;

lib/Sema/DerivedConformanceRawRepresentable.cpp

@@ -188,17 +188,101 @@ 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(const 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.
+  assert(attr->getPlatformAgnosticAvailability() ==
+             PlatformAgnosticAvailabilityKind::None &&
+         "can only express #available(somePlatform version) checks");
+  versionCheck.emplace(attr->Platform, *attr->Introduced);
+
+  return true;
+}
+
 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 +318,15 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
   SmallVector<ASTNode, 4> cases;
   unsigned Idx = 0;
   for (auto elt : enumDecl->getAllElements()) {
+    // 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
@@ -245,23 +338,36 @@ deriveBodyRawRepresentable_init(AbstractFunctionDecl *initDecl, void *) {
                                       nullptr, nullptr);
     litPat->setImplicit();
 
-    auto labelItem = CaseLabelItem(litPat);
+    /// Statements in the body of this case.
+    SmallVector<ASTNode, 2> stmts;
 
+    // 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);
 
+    // assignment = "self = \(valueExpr)"
     auto selfRef = new (C) DeclRefExpr(selfDecl, DeclNameLoc(),
                                        /*implicit*/true,
                                        AccessSemantics::DirectToStorage);
-
     auto assignment = new (C) AssignExpr(selfRef, SourceLoc(), valueExpr,
                                          /*implicit*/ true);
+
+    stmts.push_back(ASTNode(assignment));
 
+    // body = "{ \(stmts) }" (the braces are silent)
     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++;

lib/Sema/TypeCheckAvailability.cpp

@@ -2280,6 +2280,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() ==
+                   TC.Context.Id_rawValue;
+  }
+
 public:
   AvailabilityWalker(
       TypeChecker &TC, DeclContext *DC) : TC(TC), DC(DC) {
@@ -2299,8 +2312,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)) {
@@ -2347,9 +2372,7 @@ class AvailabilityWalker : public ASTWalker {
 
   bool diagAvailability(const ValueDecl *D, SourceRange R,
                         const ApplyExpr *call = nullptr,
-                        bool AllowPotentiallyUnavailableProtocol = false,
-                        bool SignalOnPotentialUnavailability = true,
-                        bool ForInout = false);
+                        DeclAvailabilityFlags flags = None);
 
 private:
   bool diagnoseIncDecRemoval(const ValueDecl *D, SourceRange R,
@@ -2483,46 +2506,45 @@ class AvailabilityWalker : public ASTWalker {
     switch (AccessContext) {
     case MemberAccessContext::Getter:
       diagAccessorAvailability(D->getGetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/false);
+                               None);
       break;
 
     case MemberAccessContext::Setter:
       diagAccessorAvailability(D->getSetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/false);
+                               None);
       break;
 
     case MemberAccessContext::InOut:
       diagAccessorAvailability(D->getGetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/true);
+                               DeclAvailabilityFlag::ForInout);
 
       diagAccessorAvailability(D->getSetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/true);
+                               DeclAvailabilityFlag::ForInout);
       break;
     }
   }
 
   /// Emit a diagnostic, if necessary for a potentially unavailable accessor.
   void diagAccessorAvailability(AccessorDecl *D, SourceRange ReferenceRange,
                                 const DeclContext *ReferenceDC,
-                                bool ForInout) const {
+                                DeclAvailabilityFlags Flags) const {
+    Flags &= DeclAvailabilityFlag::ForInout;
+    Flags |= DeclAvailabilityFlag::ContinueOnPotentialUnavailability;
     if (diagnoseDeclAvailability(D, TC,
                                  const_cast<DeclContext*>(ReferenceDC),
                                  ReferenceRange,
-                                 /*AllowPotentiallyUnavailableProtocol*/false,
-                                 /*SignalOnPotentialUnavailability*/false,
-                                 ForInout))
+                                 Flags))
       return;
   }
 };
 } // end anonymous namespace
 
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic
 /// was emitted.
-bool AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
-                                          const ApplyExpr *call,
-                                          bool AllowPotentiallyUnavailableProtocol,
-                                          bool SignalOnPotentialUnavailability,
-                                          bool ForInout) {
+bool
+AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
+                                     const ApplyExpr *call,
+                                     DeclAvailabilityFlags Flags) {
   if (!D)
     return false;
 
@@ -2561,20 +2583,25 @@ bool AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
   if (!isAccessorWithDeprecatedStorage)
     TC.diagnoseIfDeprecated(R, DC, D, call);
 
-  if (AllowPotentiallyUnavailableProtocol && isa<ProtocolDecl>(D))
+  if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailable))
+    return false;
+
+  if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol)
+        && isa<ProtocolDecl>(D))
     return false;
 
   // Diagnose (and possibly signal) for potential unavailability
   auto maybeUnavail = TC.checkDeclarationAvailability(D, R.Start, DC);
   if (maybeUnavail.hasValue()) {
     if (accessor) {
+      bool forInout = Flags.contains(DeclAvailabilityFlag::ForInout);
       TC.diagnosePotentialAccessorUnavailability(accessor, R, DC,
                                                  maybeUnavail.getValue(),
-                                                 ForInout);
+                                                 forInout);
     } else {
       TC.diagnosePotentialUnavailability(D, R, DC, maybeUnavail.getValue());
     }
-    if (SignalOnPotentialUnavailability)
+    if (!Flags.contains(DeclAvailabilityFlag::ContinueOnPotentialUnavailability))
       return true;
   }
   return false;
@@ -2748,13 +2775,8 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *Decl,
                                      TypeChecker &TC,
                                      DeclContext *DC,
                                      SourceRange R,
-                                     bool AllowPotentiallyUnavailableProtocol,
-                                     bool SignalOnPotentialUnavailability,
-                                     bool ForInout)
+                                     DeclAvailabilityFlags Flags)
 {
   AvailabilityWalker AW(TC, DC);
-  return AW.diagAvailability(Decl, R, nullptr,
-                             AllowPotentiallyUnavailableProtocol,
-                             SignalOnPotentialUnavailability,
-                             ForInout);
+  return AW.diagAvailability(Decl, R, nullptr, Flags);
 }