Merge pull request #39966 from aschwaighofer/feature_specialize_with_availability

Define a feature for _specialize with availability

Author: aschwaighofer

include/swift/AST/ASTPrinter.h

@@ -386,7 +386,9 @@ void getInheritedForPrinting(
 StringRef getAccessorKindString(AccessorKind value);
 
 bool printCompatibilityFeatureChecksPre(ASTPrinter &printer, Decl *decl);
-void printCompatibilityFeatureChecksPost(ASTPrinter &printer);
+void printCompatibilityFeatureChecksPost(
+    ASTPrinter &printer,
+    llvm::function_ref<void()> printElse = []() -> void {});
 
 } // namespace swift
 

include/swift/AST/Attr.h

@@ -1369,7 +1369,7 @@ class SpecializeAttr final
              numSPIGroups };
   }
 
-  ArrayRef<AvailableAttr *> getAvailabeAttrs() const {
+  ArrayRef<AvailableAttr *> getAvailableAttrs() const {
     return {this->template getTrailingObjects<AvailableAttr *>(),
             numAvailableAttrs};
   }

include/swift/AST/PrintOptions.h

@@ -477,6 +477,10 @@ struct PrintOptions {
   /// compilers that might parse the result.
   bool PrintCompatibilityFeatureChecks = false;
 
+  /// Whether to print @_specialize attributes that have an availability
+  /// parameter.
+  bool PrintSpecializeAttributeWithAvailability = true;
+
   /// \see ShouldQualifyNestedDeclarations
   enum class QualifyNestedDeclarations {
     Never,

include/swift/Basic/Features.def

@@ -56,5 +56,6 @@ LANGUAGE_FEATURE(BuiltinBuildMainExecutor, 0, "MainActor executor building built
 LANGUAGE_FEATURE(BuiltinCreateAsyncTaskInGroup, 0, "MainActor executor building builtin", true)
 LANGUAGE_FEATURE(BuiltinMove, 0, "Builtin.move()", true)
 LANGUAGE_FEATURE(BuiltinCopy, 0, "Builtin.copy()", true)
+LANGUAGE_FEATURE(SpecializeAttributeWithAvailability, 0, "@_specialize attribute with availability", true)
 
 #undef LANGUAGE_FEATURE

lib/AST/ASTPrinter.cpp

@@ -534,6 +534,7 @@ static bool willUseTypeReprPrinting(TypeLoc tyLoc,
           (tyLoc.getType().isNull() && tyLoc.getTypeRepr()));
 }
 
+static std::vector<Feature> getUniqueFeaturesUsed(Decl *decl);
 namespace {
 /// AST pretty-printer.
 class PrintAST : public ASTVisitor<PrintAST> {
@@ -1003,7 +1004,22 @@ class PrintAST : public ASTVisitor<PrintAST> {
     ASTVisitor::visit(D);
 
     if (haveFeatureChecks) {
-      printCompatibilityFeatureChecksPost(Printer);
+
+      printCompatibilityFeatureChecksPost(Printer, [&]() -> void {
+        auto features = getUniqueFeaturesUsed(D);
+        assert(!features.empty());
+        if (std::find_if(features.begin(), features.end(),
+                         [](Feature feature) -> bool {
+                           return getFeatureName(feature).equals(
+                               "SpecializeAttributeWithAvailability");
+                         }) != features.end()) {
+          Printer << "#else\n";
+          Options.PrintSpecializeAttributeWithAvailability = false;
+          ASTVisitor::visit(D);
+          Options.PrintSpecializeAttributeWithAvailability = true;
+          Printer.printNewline();
+        }
+      });
     }
 
     if (Synthesize) {
@@ -2818,6 +2834,16 @@ static bool usesFeatureBuiltinMove(Decl *decl) {
 
 static bool usesFeatureBuiltinCopy(Decl *decl) { return false; }
 
+static bool usesFeatureSpecializeAttributeWithAvailability(Decl *decl) {
+  if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
+    for (auto specialize : func->getAttrs().getAttributes<SpecializeAttr>()) {
+      if (!specialize->getAvailableAttrs().empty())
+        return true;
+    }
+  }
+  return false;
+}
+
 static bool usesFeatureInheritActorContext(Decl *decl) {
   if (auto func = dyn_cast<AbstractFunctionDecl>(decl)) {
     for (auto param : *func->getParameters()) {
@@ -2926,12 +2952,13 @@ bool swift::printCompatibilityFeatureChecksPre(
   return true;
 }
 
-void swift::printCompatibilityFeatureChecksPost(ASTPrinter &printer) {
+void swift::printCompatibilityFeatureChecksPost(
+    ASTPrinter &printer, llvm::function_ref<void()> printElse) {
   printer.printNewline();
+  printElse();
   printer << "#endif\n";
 }
 
-
 void PrintAST::visitExtensionDecl(ExtensionDecl *decl) {
   if (Options.TransformContext &&
       Options.TransformContext->isPrintingSynthesizedExtension()) {

lib/AST/Attr.cpp

@@ -982,6 +982,12 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     if (!Options.PrintSPIs && !attr->getSPIGroups().empty())
       return false;
 
+    // Don't print the _specialize attribute if we are asked to skip the ones
+    // with availability parameters.
+    if (!Options.PrintSpecializeAttributeWithAvailability &&
+        !attr->getAvailableAttrs().empty())
+      return false;
+
     Printer << "@" << getAttrName() << "(";
     auto exported = attr->isExported() ? "true" : "false";
     auto kind = attr->isPartialSpecialization() ? "partial" : "full";
@@ -993,7 +999,7 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     Printer << "kind: " << kind << ", ";
     if (target)
       Printer << "target: " << target << ", ";
-    auto availAttrs = attr->getAvailabeAttrs();
+    auto availAttrs = attr->getAvailableAttrs();
     if (!availAttrs.empty()) {
       Printer << "availability: ";
       auto numAttrs = availAttrs.size();

lib/AST/Availability.cpp

@@ -182,7 +182,7 @@ AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr
 
   const AvailableAttr *bestAvailAttr = nullptr;
 
-  for (auto *availAttr : attr->getAvailabeAttrs()) {
+  for (auto *availAttr : attr->getAvailableAttrs()) {
     if (availAttr == nullptr || !availAttr->Introduced.hasValue() ||
         !availAttr->isActivePlatform(ctx) ||
         availAttr->isLanguageVersionSpecific() ||

lib/Serialization/Serialization.cpp

@@ -2611,14 +2611,14 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
       auto numSPIGroups = attr->getSPIGroups().size();
       assert(pieces.size() == numArgs + numSPIGroups ||
              pieces.size() == (numArgs - 1 + numSPIGroups));
-      auto numAvailabilityAttrs = attr->getAvailabeAttrs().size();
+      auto numAvailabilityAttrs = attr->getAvailableAttrs().size();
       SpecializeDeclAttrLayout::emitRecord(
           S.Out, S.ScratchRecord, abbrCode, (unsigned)attr->isExported(),
           (unsigned)attr->getSpecializationKind(),
           S.addGenericSignatureRef(attr->getSpecializedSignature()),
           S.addDeclRef(targetFunDecl), numArgs, numSPIGroups,
           numAvailabilityAttrs, pieces);
-      for (auto availAttr : attr->getAvailabeAttrs()) {
+      for (auto availAttr : attr->getAvailableAttrs()) {
         writeDeclAttribute(D, availAttr);
       }
       return;

test/ModuleInterface/features.swift

@@ -9,6 +9,16 @@
 // the uses of those features are guarded by appropriate #if's that allow older
 // compilers to skip over the uses of newer features.
 
+// CHECK: #if compiler(>=5.3) && $SpecializeAttributeWithAvailability
+// CHECK: @_specialize(exported: true, kind: full, availability: macOS, introduced: 12; where T == Swift.Int)
+// CHECK: public func specializeWithAvailability<T>(_ t: T)
+// CHECK: #else
+// CHECK: public func specializeWithAvailability<T>(_ t: T)
+// CHECK: #endif
+@_specialize(exported: true, availability: macOS 12, *; where T == Int)
+public func specializeWithAvailability<T>(_ t: T) {
+}
+
 // CHECK: #if compiler(>=5.3) && $Actors
 // CHECK-NEXT: public actor MyActor
 // CHECK:        @_semantics("defaultActor") nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor {