Print @abi into module interface (suppressibly)

Author: beccadax

include/swift/AST/PrintOptions.h

@@ -237,6 +237,10 @@ struct PrintOptions {
   /// Use the original module name to qualify a symbol.
   bool UseOriginallyDefinedInModuleNames = false;
 
+  /// Add a `@_silgen_name` attribute to each function that
+  /// is compatible with one that specifies its mangled name.
+  bool PrintSyntheticSILGenName = false;
+
   /// Print Swift.Array and Swift.Optional with sugared syntax
   /// ([] and ?), even if there are no sugar type nodes.
   bool SynthesizeSugarOnTypes = false;

include/swift/Basic/Features.def

@@ -433,7 +433,7 @@ EXPERIMENTAL_FEATURE(GenerateForceToMainActorThunks, false)
 EXPERIMENTAL_FEATURE(AddressableParameters, true)
 
 /// Allow the @abi attribute.
-EXPERIMENTAL_FEATURE(ABIAttribute, true)
+SUPPRESSIBLE_EXPERIMENTAL_FEATURE(ABIAttribute, true)
 
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE

lib/AST/ASTPrinter.cpp

@@ -1230,6 +1230,18 @@ static bool hasLessAccessibleSetter(const AbstractStorageDecl *ASD) {
   return ASD->getSetterFormalAccess() < ASD->getFormalAccess();
 }
 
+bool canPrintSyntheticSILGenName(const Decl *D) {
+  ASSERT(!D->getAttrs().hasAttribute<SILGenNameAttr>());
+
+  // Only print on functions, and only those functions with no barriers to use.
+  if (auto FD = dyn_cast<AbstractFunctionDecl>(D); !FD
+        || FD->getAttrs().hasAttribute<BackDeployedAttr>()
+        || FD->getOpaqueResultTypeDecl())
+    return false;
+
+  return true;
+}
+
 void PrintAST::printAttributes(const Decl *D) {
   if (Options.SkipAttributes)
     return;
@@ -1247,6 +1259,27 @@ void PrintAST::printAttributes(const Decl *D) {
   // for each decl They cannot be shared across different decls.
   assert(Options.ExcludeCustomAttrList.empty());
 
+  if (Options.PrintSyntheticSILGenName
+        && !D->getAttrs().hasAttribute<SILGenNameAttr>()) {
+    if (canPrintSyntheticSILGenName(D)) {
+      auto mangledName = Mangle::ASTMangler(D->getASTContext())
+                            .mangleAnyDecl(cast<ValueDecl>(D), /*prefix=*/true,
+                                           /*respectOriginallyDefinedIn=*/true);
+      Printer.printAttrName("@_silgen_name");
+      Printer << "(";
+      Printer.printEscapedStringLiteral(mangledName);
+      Printer << ")\n";
+    }
+    else {
+      Printer.printAttrName("@available");
+      Printer << "(*, unavailable, message: ";
+      Printer.printEscapedStringLiteral(
+          "this compiler cannot match the ABI specified by the @abi attribute");
+      Printer << ")\n";
+      Options.ExcludeAttrList.push_back(DeclAttrKind::Available);
+    }
+  }
+
   if (Options.PrintImplicitAttrs) {
 
     // Don't print a redundant 'final' if we are printing a 'static' decl.
@@ -3139,6 +3172,16 @@ suppressingFeatureCoroutineAccessors(PrintOptions &options,
   action();
 }
 
+static void
+suppressingFeatureABIAttribute(PrintOptions &options,
+                               llvm::function_ref<void()> action) {
+  llvm::SaveAndRestore<bool> scope(options.PrintSyntheticSILGenName, true);
+  unsigned originalExcludeAttrCount = options.ExcludeAttrList.size();
+  options.ExcludeAttrList.push_back(DeclAttrKind::ABI);
+  action();
+  options.ExcludeAttrList.resize(originalExcludeAttrCount);
+}
+
 /// Suppress the printing of a particular feature.
 static void suppressingFeature(PrintOptions &options, Feature feature,
                                llvm::function_ref<void()> action) {
@@ -3910,6 +3953,8 @@ void PrintAST::printOneParameter(const ParamDecl *param,
 void PrintAST::printParameterList(ParameterList *PL,
                                   ArrayRef<AnyFunctionType::Param> params,
                                   bool isAPINameByDefault) {
+  llvm::SaveAndRestore<bool> scope(Options.PrintSyntheticSILGenName, false);
+
   Printer.printStructurePre(PrintStructureKind::FunctionParameterList);
   SWIFT_DEFER {
     Printer.printStructurePost(PrintStructureKind::FunctionParameterList);

lib/AST/Attr.cpp

@@ -786,7 +786,7 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
   AttributeVector attributes;
   AttributeVector modifiers;
   bool libraryLevelAPI =
-      D->getASTContext().LangOpts.LibraryLevel == LibraryLevel::API;
+      D && D->getASTContext().LangOpts.LibraryLevel == LibraryLevel::API;
 
   for (auto DA : llvm::reverse(FlattenedAttrs)) {
     // Don't skip implicit custom attributes. Custom attributes like global
@@ -1600,7 +1600,13 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     auto *attr = cast<ABIAttr>(this);
     Printer << "@abi(";
     ASSERT(!attr->isInverse() && "should be skipped above");
-    if (attr->abiDecl)
+    Decl *abiDecl = attr->abiDecl;
+    if (abiDecl && Options.ExplodePatternBindingDecls
+          && isa<PatternBindingDecl>(abiDecl) && D && isa<VarDecl>(D))
+      abiDecl = cast<PatternBindingDecl>(abiDecl)
+                    ->getVarAtSimilarStructuralPosition(
+                                      const_cast<VarDecl *>(cast<VarDecl>(D)));
+    if (abiDecl)
       attr->abiDecl->print(Printer, Options);
     Printer << ")";
 

lib/AST/FeatureSet.cpp

@@ -319,9 +319,18 @@ static bool usesFeatureAllowUnsafeAttribute(Decl *decl) {
   return decl->getAttrs().hasAttribute<UnsafeAttr>();
 }
 
+static ABIAttr *getABIAttr(Decl *decl) {
+  if (auto pbd = dyn_cast<PatternBindingDecl>(decl))
+    for (auto i : range(pbd->getNumPatternEntries()))
+      if (auto anchorVar = pbd->getAnchoringVarDecl(i))
+        return getABIAttr(anchorVar);
+  // FIXME: EnumCaseDecl/EnumElementDecl
+
+  return decl->getAttrs().getAttribute<ABIAttr>();
+}
+
 static bool usesFeatureABIAttribute(Decl *decl) {
-  auto abiAttr = decl->getAttrs().getAttribute<ABIAttr>();
-  return abiAttr && !abiAttr->isInverse();
+  return getABIAttr(decl) != nullptr;
 }
 
 UNINTERESTING_FEATURE(WarnUnsafe)
@@ -425,26 +434,40 @@ static bool allowFeatureSuppression(StringRef featureName, Decl *decl) {
 /// Go through all the features used by the given declaration and
 /// either add or remove them to this set.
 void FeatureSet::collectFeaturesUsed(Decl *decl, InsertOrRemove operation) {
+  // Count feature usage in an ABI decl as feature usage by the API, not itself,
+  // since we can't use `#if` inside an @abi attribute.
+  Decl *abiDecl = nullptr;
+  if (auto abiAttr = getABIAttr(decl)) {
+    if (abiAttr->isInverse())
+      return;
+    abiDecl = abiAttr->abiDecl;
+  }
+
+#define CHECK(Function) (Function(decl) || (abiDecl && Function(abiDecl)))
+#define CHECK_ARG(Function, Arg) (Function(Arg, decl) || (abiDecl && Function(Arg, abiDecl)))
+
   // Go through each of the features, checking whether the
   // declaration uses that feature.
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description)                   \
-  if (usesFeature##FeatureName(decl))                                          \
+  if (CHECK(usesFeature##FeatureName))                                         \
     collectRequiredFeature(Feature::FeatureName, operation);
 #define SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description)      \
-  if (usesFeature##FeatureName(decl)) {                                        \
-    if (disallowFeatureSuppression(#FeatureName, decl))                        \
+  if (CHECK(usesFeature##FeatureName)) {                                       \
+    if (CHECK_ARG(disallowFeatureSuppression, #FeatureName))                   \
       collectRequiredFeature(Feature::FeatureName, operation);                 \
     else                                                                       \
       collectSuppressibleFeature(Feature::FeatureName, operation);             \
   }
 #define CONDITIONALLY_SUPPRESSIBLE_LANGUAGE_FEATURE(FeatureName, SENumber, Description)      \
-  if (usesFeature##FeatureName(decl)) {                                        \
-    if (allowFeatureSuppression(#FeatureName, decl))                           \
+  if (CHECK(usesFeature##FeatureName)) {                                       \
+    if (CHECK_ARG(allowFeatureSuppression, #FeatureName))                      \
       collectSuppressibleFeature(Feature::FeatureName, operation);             \
     else                                                                       \
       collectRequiredFeature(Feature::FeatureName, operation);                 \
   }
 #include "swift/Basic/Features.def"
+#undef CHECK
+#undef CHECK_ARG
 }
 
 FeatureSet swift::getUniqueFeaturesUsed(Decl *decl) {

test/ModuleInterface/attrs.swift

@@ -1,6 +1,8 @@
-// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name attrs
+// RUN: %target-swift-emit-module-interface(%t.swiftinterface) %s -module-name attrs -enable-experimental-feature ABIAttribute
 // RUN: %target-swift-typecheck-module-from-interface(%t.swiftinterface) -module-name attrs
-// RUN: %FileCheck %s < %t.swiftinterface
+// RUN: %FileCheck %s --input-file %t.swiftinterface
+
+// REQUIRES: swift_feature_ABIAttribute
 
 // CHECK: @_transparent public func glass() -> Swift.Int { return 0 }{{$}}
 @_transparent public func glass() -> Int { return 0 }
@@ -27,3 +29,23 @@ public func someGenericFunction<T>(_ t: T) -> Int { return 0 }
 internal func __specialize_someGenericFunction<T>(_ t: T) -> Int {
     fatalError("don't call")
 }
+
+@abi(public func __abi__abiAttrOnFunction(param: Int))
+public func abiAttrOnFunction(param: Int) {}
+// CHECK: #if {{.*}} $ABIAttribute
+// CHECK: @abi(public func __abi__abiAttrOnFunction(param: Swift.Int))
+// CHECK: public func abiAttrOnFunction(param: Swift.Int)
+// CHECK: #else
+// CHECK: @_silgen_name("$s5attrs07__abi__B14AttrOnFunction5paramySi_tF")
+// CHECK: public func abiAttrOnFunction(param: Swift.Int)
+// CHECK: #endif
+
+@abi(public let __abi__abiAttrOnVar: Int)
+public var abiAttrOnVar: Int = 42
+// CHECK: #if {{.*}} $ABIAttribute
+// CHECK: @abi(public var __abi__abiAttrOnVar: Swift.Int)
+// CHECK: public var abiAttrOnVar: Swift.Int
+// CHECK: #else
+// CHECK: @available(*, unavailable, message: "this compiler cannot match the ABI specified by the @abi attribute")
+// CHECK: public var abiAttrOnVar: Swift.Int
+// CHECK: #endif