AST: Introduce the @_backDeploy function attribute:

tshortli · tshortli · commit b860e762b2f0 · 2022-02-08T10:11:04.000-08:00
- Parse the attribute and diagnose parsing issues
- Serialize the attribute
diff --git a/docs/ReferenceGuides/UnderscoredAttributes.md b/docs/ReferenceGuides/UnderscoredAttributes.md
@@ -39,6 +39,15 @@ Most notably, default argument expressions are implicitly
 `@_alwaysEmitIntoClient`, which means that adding a default argument to a
 function which did not have one previously does not break ABI.
 
+## `@_backDeploy(availabilitySpec ...)`
+
+Causes the body of a function to be emitted into the module interface to be
+available for inlining in clients with deployment targets lower than the formal
+availability of the function. When inlined, the body of the function is
+transformed such that it calls the library's copy of the function if it is
+available at runtime. Otherwise, the copy of the original function body is
+executed.
+
 ## `@_assemblyVision`
 
 Forces emission of assembly vision remarks for a function or method, showing
diff --git a/include/swift/AST/Attr.def b/include/swift/AST/Attr.def
@@ -713,6 +713,12 @@ DECL_ATTR(exclusivity, Exclusivity,
   ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
   128)
 
+DECL_ATTR(_backDeploy, BackDeploy,
+  OnAbstractFunction |
+  AllowMultipleAttributes | LongAttribute | UserInaccessible |
+  ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIBreakingToRemove,
+  129)
+
 // If you're adding a new underscored attribute here, please document it in
 // docs/ReferenceGuides/UnderscoredAttributes.md.
 
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -2172,6 +2172,30 @@ class UnavailableFromAsyncAttr : public DeclAttribute {
   }
 };
 
+/// The @_backDeploy(...) attribute, used to make function declarations available
+/// for back deployment to older OSes via emission into the client binary.
+class BackDeployAttr: public DeclAttribute {
+public:
+  BackDeployAttr(SourceLoc AtLoc, SourceRange Range,
+                 PlatformKind Platform,
+                 const llvm::VersionTuple Version,
+                 bool Implicit)
+    : DeclAttribute(DAK_BackDeploy, AtLoc, Range, Implicit),
+      Platform(Platform),
+      Version(Version) {}
+
+  /// The platform the symbol is available for back deployment on.
+  const PlatformKind Platform;
+
+  /// The earliest platform version that may use the back deployed implementation.
+  const llvm::VersionTuple Version;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_BackDeploy;
+  }
+};
+
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.
diff --git a/include/swift/AST/DiagnosticsParse.def b/include/swift/AST/DiagnosticsParse.def
@@ -1531,6 +1531,15 @@ WARNING(attr_availability_nonspecific_platform_unexpected_version,none,
       "unexpected version number in '%0' attribute for non-specific platform "
       "'*'", (StringRef))
 
+WARNING(attr_availability_wildcard_ignored,none,
+        "* as platform name has no effect in '%0' attribute", (StringRef))
+
+ERROR(attr_availability_need_platform_version,none,
+     "expected at least one platform version in in '%0' attribute", (StringRef))
+
+WARNING(attr_availability_platform_version_major_minor_only,none,
+        "'%0' only uses major and minor version number", (StringRef))
+
 // availability macro
 ERROR(attr_availability_wildcard_in_macro, none,
       "future platforms identified by '*' cannot be used in "
@@ -1548,12 +1557,15 @@ ERROR(attr_availability_duplicate,none,
       (StringRef, StringRef))
 
 // originallyDefinedIn
+// FIXME: Refactor to share between attributes
 ERROR(originally_defined_in_missing_rparen,none,
       "expected ')' in @_originallyDefinedIn argument list", ())
 
+// FIXME: Refactor to share between attributes
 ERROR(originally_defined_in_unrecognized_platform,none,
       "unrecognized platform name in @_originallyDefinedIn argument list", ())
 
+// FIXME: This is unused and can be removed
 ERROR(originally_defined_in_unrecognized_property,none,
       "unrecognized property in @_originallyDefinedIn argument list", ())
 
@@ -1564,15 +1576,19 @@ ERROR(originally_defined_in_need_original_module_name,none,
 ERROR(originally_defined_in_need_nonempty_module_name,none,
       "original module name cannot be empty in @_originallyDefinedIn", ())
 
+// FIXME: Refactor to share between attributes
 ERROR(originally_defined_in_need_platform_version,none,
      "expected at least one platform version in @_originallyDefinedIn", ())
 
+// FIXME: Refactor to share between attributes
 WARNING(originally_defined_in_major_minor_only,none,
         "@_originallyDefinedIn only uses major and minor version number", ())
 
+// FIXME: Refactor to share between attributes
 WARNING(originally_defined_in_missing_platform_name,none,
         "* as platform name has no effect", ())
 
+// FIXME: Refactor to share between attributes
 WARNING(originally_defined_in_swift_version, none,
         "Swift language version checks has no effect "
         "in @_originallyDefinedIn", ())
@@ -1581,6 +1597,10 @@ WARNING(originally_defined_in_package_description, none,
         "PackageDescription version checks has no effect "
         "in @_originallyDefinedIn", ())
 
+// backDeploy
+ERROR(attr_back_deploy_missing_rparen,none,
+      "expected ')' in '@_backDeploy' argument list", ())
+
 // convention
 ERROR(convention_attribute_expected_lparen,none,
       "expected '(' after 'convention' attribute", ())
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -1597,18 +1597,21 @@ WARNING(option_set_zero_constant,none,
 NOTE(option_set_empty_set_init,none,
      "use [] to silence this warning", ())
 
+// FIXME: Refactor to share between attributes
 ERROR(originally_defined_in_dupe_platform,none,
       "duplicate version number for platform %0", (StringRef))
 
 ERROR(originally_definedin_topleve_decl,none,
       "@%0 is only applicable to top-level decl", (StringRef))
 
+// FIXME: Refactor to share between attributes
 ERROR(originally_definedin_need_available,none,
       "need @available attribute for @%0", (StringRef))
 
 ERROR(originally_definedin_must_not_before_available_version,none,
       "symbols are moved to the current module before they were available in the OSs", (StringRef))
 
+// FIXME: Refactor to share between attributes
 WARNING(originally_defined_in_on_non_public,
        none, "@%0 does not have any effect on "
        "%select{private|fileprivate|internal|%error|%error}1 declarations",
diff --git a/lib/AST/Attr.cpp b/lib/AST/Attr.cpp
@@ -1188,6 +1188,16 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DAK_BackDeploy: {
+    Printer.printAttrName("@_backDeploy");
+    Printer << "(";
+    auto Attr = cast<BackDeployAttr>(this);
+    Printer << platformString(Attr->Platform) << " " <<
+      Attr->Version.getAsString();
+    Printer << ")";
+    break;
+  }
+
   case DAK_Count:
     llvm_unreachable("exceed declaration attribute kinds");
 
@@ -1356,6 +1366,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "_typeSequence";
   case DAK_UnavailableFromAsync:
     return "_unavailableFromAsync";
+  case DAK_BackDeploy:
+    return "_backDeploy";
   }
   llvm_unreachable("bad DeclAttrKind");
 }
diff --git a/lib/Parse/ParseDecl.cpp b/lib/Parse/ParseDecl.cpp
@@ -2855,6 +2855,85 @@ bool Parser::parseNewDeclAttribute(DeclAttributes &Attributes, SourceLoc AtLoc,
         message, AtLoc, SourceRange(Loc, Tok.getLoc()), false));
     break;
   }
+  case DAK_BackDeploy: {
+    auto LeftLoc = Tok.getLoc();
+    if (!consumeIf(tok::l_paren)) {
+      diagnose(Loc, diag::attr_expected_lparen, AttrName,
+               DeclAttribute::isDeclModifier(DK));
+      return false;
+    }
+    SourceLoc RightLoc;
+    bool SuppressLaterDiags = false;
+    llvm::SmallVector<std::pair<PlatformKind, llvm::VersionTuple>, 4>
+      PlatformAndVersions;
+    
+    StringRef AttrName = "@_backDeploy";
+    if (parseList(tok::r_paren, LeftLoc, RightLoc, false,
+                  diag::attr_back_deploy_missing_rparen,
+                  SyntaxKind::Unknown, [&]() -> ParserStatus {
+      // FIXME(backDeploy): Parse availability macros (e.g. SwiftStdlib: 5.1)
+      
+      // Parse a platform and version tuple (e.g. 'macOS 13.13').
+      if ((Tok.is(tok::identifier) || Tok.is(tok::oper_binary_spaced)) &&
+          (peekToken().is(tok::floating_literal) ||
+           peekToken().is(tok::integer_literal))) {
+        PlatformKind Platform;
+        // Parse platform name.
+        auto Plat = platformFromString(Tok.getText());
+        if (!Plat.hasValue()) {
+          diagnose(Tok.getLoc(), diag::attr_availability_unknown_platform,
+                   Tok.getText(), AttrName);
+          SuppressLaterDiags = true;
+          return makeParserError();
+        } else {
+          consumeToken();
+          Platform = *Plat;
+        }
+        // Parse version number
+        llvm::VersionTuple VerTuple;
+        SourceRange VersionRange;
+        if (parseVersionTuple(VerTuple, VersionRange,
+              Diagnostic(diag::attr_availability_expected_version, AttrName))) {
+          SuppressLaterDiags = true;
+          return makeParserError();
+        } else {
+          if (VerTuple.getSubminor().hasValue() ||
+              VerTuple.getBuild().hasValue()) {
+            diagnose(Tok.getLoc(),
+                     diag::attr_availability_platform_version_major_minor_only,
+                     AttrName);
+          }
+          // * as platform name isn't supported.
+          if (Platform == PlatformKind::none) {
+            diagnose(AtLoc, diag::attr_availability_wildcard_ignored, AttrName);
+          } else {
+            PlatformAndVersions.emplace_back(Platform, VerTuple);
+          }
+          return makeParserSuccess();
+        }
+      }
+      diagnose(AtLoc, diag::attr_availability_need_platform_version, AttrName);
+      SuppressLaterDiags = true;
+      return makeParserError();
+    }).isErrorOrHasCompletion() || SuppressLaterDiags) {
+      return false;
+    }
+
+    if (PlatformAndVersions.empty()) {
+      diagnose(AtLoc, diag::attr_availability_need_platform_version, AttrName);
+      return false;
+    }
+    
+    assert(!PlatformAndVersions.empty());
+    AttrRange = SourceRange(Loc, Tok.getLoc());
+    for (auto &Item: PlatformAndVersions) {
+      Attributes.add(new (Context) BackDeployAttr(AtLoc, AttrRange,
+                                                  Item.first,
+                                                  Item.second,
+                                                  /*IsImplicit*/false));
+    }
+    break;
+  }
   }
 
   if (DuplicateAttribute) {
diff --git a/lib/Sema/TypeCheckAttr.cpp b/lib/Sema/TypeCheckAttr.cpp
@@ -118,6 +118,7 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   IGNORED_ATTR(InheritActorContext)
   IGNORED_ATTR(Isolated)
   IGNORED_ATTR(Preconcurrency)
+  IGNORED_ATTR(BackDeploy)
 #undef IGNORED_ATTR
 
   void visitAlignmentAttr(AlignmentAttr *attr) {
@@ -275,6 +276,8 @@ class AttributeChecker : public AttributeVisitor<AttributeChecker> {
   void visitUnavailableFromAsyncAttr(UnavailableFromAsyncAttr *attr);
 
   void visitPrimaryAssociatedTypeAttr(PrimaryAssociatedTypeAttr *attr);
+
+  void checkBackDeployAttrs(Decl *D, ArrayRef<BackDeployAttr *> Attrs);
 };
 
 } // end anonymous namespace
@@ -3460,6 +3463,11 @@ void AttributeChecker::checkOriginalDefinedInAttrs(Decl *D,
   }
 }
 
+void AttributeChecker::checkBackDeployAttrs(Decl *D,
+    ArrayRef<BackDeployAttr *> Attrs) {
+  // FIXME(backDeploy): Diagnose incompatible uses of `@_backDeploy
+}
+
 Type TypeChecker::checkReferenceOwnershipAttr(VarDecl *var, Type type,
                                               ReferenceOwnershipAttr *attr) {
   auto &Diags = var->getASTContext().Diags;
diff --git a/lib/Sema/TypeCheckDeclOverride.cpp b/lib/Sema/TypeCheckDeclOverride.cpp
@@ -1567,6 +1567,8 @@ namespace  {
 
     UNINTERESTING_ATTR(PrimaryAssociatedType)
 
+    UNINTERESTING_ATTR(BackDeploy)
+
 #undef UNINTERESTING_ATTR
 
     void visitAvailableAttr(AvailableAttr *attr) {
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -4772,6 +4772,21 @@ llvm::Error DeclDeserializer::deserializeDeclCommon() {
         break;
       }
 
+      case decls_block::BackDeploy_DECL_ATTR: {
+        bool isImplicit;
+        unsigned Platform;
+        DEF_VER_TUPLE_PIECES(Version);
+        serialization::decls_block::BackDeployDeclAttrLayout::readRecord(
+            scratch, isImplicit, LIST_VER_TUPLE_PIECES(Version), Platform);
+        llvm::VersionTuple Version;
+        DECODE_VER_TUPLE(Version)
+        Attr = new (ctx) BackDeployAttr(SourceLoc(), SourceRange(),
+                                        (PlatformKind)Platform,
+                                        Version,
+                                        isImplicit);
+        break;
+      }
+
 #define SIMPLE_DECL_ATTR(NAME, CLASS, ...) \
       case decls_block::CLASS##_DECL_ATTR: { \
         bool isImplicit; \
diff --git a/lib/Serialization/ModuleFormat.h b/lib/Serialization/ModuleFormat.h
@@ -56,7 +56,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 666; // mark_must_check initial
+const uint16_t SWIFTMODULE_VERSION_MINOR = 667; // @_backDeploy
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -2043,6 +2043,13 @@ namespace decls_block {
     BCFixed<1>, // Implicit flag
     BCBlob      // Message
   >;
+
+  using BackDeployDeclAttrLayout = BCRecordLayout<
+    BackDeploy_DECL_ATTR,
+    BCFixed<1>,     // implicit flag
+    BC_AVAIL_TUPLE, // OS version
+    BCVBR<5>        // platform
+  >;
 }
 
 /// Returns the encoding kind for the given decl.
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -2581,6 +2581,18 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       return;
     }
 
+    case DAK_BackDeploy: {
+      auto *theAttr = cast<BackDeployAttr>(DA);
+      ENCODE_VER_TUPLE(Version, llvm::Optional<llvm::VersionTuple>(theAttr->Version));
+      auto abbrCode = S.DeclTypeAbbrCodes[BackDeployDeclAttrLayout::Code];
+      BackDeployDeclAttrLayout::emitRecord(
+          S.Out, S.ScratchRecord, abbrCode,
+          theAttr->isImplicit(),
+          LIST_VER_TUPLE_PIECES(Version),
+          static_cast<unsigned>(theAttr->Platform));
+      return;
+    }
+
     case DAK_ObjC: {
       auto *theAttr = cast<ObjCAttr>(DA);
       SmallVector<IdentifierID, 4> pieces;
diff --git a/test/ModuleInterface/back-deploy-attr.swift b/test/ModuleInterface/back-deploy-attr.swift
@@ -0,0 +1,40 @@
+// RUN: %empty-directory(%t)
+
+// Ensure @_backDeploy attributes and function bodies are printed in
+// swiftinterface files.
+// RUN: %target-swift-frontend -emit-module -o %t/Test.swiftmodule -emit-module-interface-path %t/Test.swiftinterface -module-name Test %s
+// RUN: %FileCheck %s --check-prefix FROMSOURCE --check-prefix CHECK < %t/Test.swiftinterface
+
+// Ensure @_backDeploy attributes and function bodies are present after
+// deserializing .swiftmodule files.
+// RUN: %target-swift-frontend -emit-module -o /dev/null -merge-modules %t/Test.swiftmodule -disable-objc-attr-requires-foundation-module -emit-module-interface-path %t/TestFromModule.swiftinterface -module-name Test
+// RUN: %FileCheck %s --check-prefix FROMMODULE --check-prefix CHECK < %t/TestFromModule.swiftinterface
+
+// FIXME(backDeploy): Verify that function bodies are emitted
+
+public struct TopLevelStruct {
+  // CHECK: @_backDeploy(macOS 11.0)
+  // CHECK: public func backDeployedFunc1_SinglePlatform() -> Swift.Int
+  @available(macOS 12.0, *)
+  @_backDeploy(macOS 11.0)
+  public func backDeployedFunc1_SinglePlatform() -> Int {
+    return 42
+  }
+  
+  // CHECK: @_backDeploy(macOS 11.0)
+  // CHECK: @_backDeploy(iOS 14.0)
+  // CHECK: public func backDeployedFunc2_MultiPlatform() -> Swift.Int
+  @available(macOS 12.0, *)
+  @_backDeploy(macOS 11.0, iOS 14.0)
+  public func backDeployedFunc2_MultiPlatform() -> Int {
+    return 43
+  }
+}
+
+// CHECK: @_backDeploy(macOS 11.0)
+// CHECK: public func backDeployTopLevelFunc() -> Swift.Int
+@available(macOS 12.0, *)
+@_backDeploy(macOS 11.0)
+public func backDeployTopLevelFunc() -> Int {
+  return 42
+}
diff --git a/test/ModuleInterface/inlinable-function.swift b/test/ModuleInterface/inlinable-function.swift
diff --git a/test/attr/backDeploy.swift b/test/attr/backDeploy.swift
