Parse and serialize @abi attribute

This attribute will allow you to specify an alternate version of the declaration used for mangling. It will allow minor adjustments to be made to declarations so long as they’re still compatible at the calling convention level, such as refining isolation or sendability, renaming without breaking ABI, etc.

The attribute is behind the experimental feature flag `ABIAttribute`.

Author: beccadax

include/swift/AST/ASTContext.h

@@ -67,6 +67,7 @@ namespace llvm {
 }
 
 namespace swift {
+  class ABIAttr;
   class AbstractFunctionDecl;
   class ASTContext;
   enum class Associativity : unsigned char;
@@ -414,6 +415,19 @@ class ASTContext final {
       llvm::SmallPtrSet<DerivativeAttr *, 1>>
       DerivativeAttrs;
 
+  /// For each ABI-only declaration (created with the `@abi` attribute), points
+  /// to its API-only counterpart. That is, this table maps each
+  /// `ABIAttr::abiDecl` to the declaration the `ABIAttr` is attached to.
+  ///
+  /// \seeAlso \c recordABIAttr()
+  llvm::DenseMap<Decl *, Decl *> ABIDeclCounterparts;
+
+  /// Register \c this->abiDecl 's  relationship with \p owner in
+  /// `ABIDeclCounterparts` . This is necessary for
+  /// \c ABIRoleInfo::ABIRoleInfo() to determine that \c this->abiDecl
+  /// is ABI-only and locate its API counterpart.
+  void recordABIAttr(ABIAttr *attr, Decl *owner);
+
   /// The Swift module currently being compiled.
   ModuleDecl *MainModule = nullptr;
 

include/swift/AST/Attr.h

@@ -2914,6 +2914,31 @@ class AllowFeatureSuppressionAttr final
   UNIMPLEMENTED_CLONE(AllowFeatureSuppressionAttr)
 };
 
+/// Defines the @abi attribute.
+class ABIAttr : public DeclAttribute {
+public:
+  ABIAttr(Decl *abiDecl, SourceLoc AtLoc, SourceRange Range, bool Implicit)
+      : DeclAttribute(DeclAttrKind::ABI, AtLoc, Range, Implicit),
+        abiDecl(abiDecl)
+  { }
+
+  ABIAttr(Decl *abiDecl, bool Implicit)
+      : ABIAttr(abiDecl, SourceLoc(), SourceRange(), Implicit) {}
+
+  /// The declaration which will be used to compute a mangled name.
+  ///
+  /// \note For a \c VarDecl with a parent \c PatternBindingDecl , this should
+  /// point to the parent \c PatternBindingDecl . (That accommodates the way
+  /// sibling \c VarDecl s share attributes.)
+  Decl *abiDecl;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::ABI;
+  }
+
+  UNIMPLEMENTED_CLONE(ABIAttr)
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/Decl.h

@@ -2662,6 +2662,11 @@ class PatternBindingDecl final : public Decl,
   /// Returns \c true if this pattern binding was created by the debugger.
   bool isDebuggerBinding() const { return Bits.PatternBindingDecl.IsDebugger; }
 
+  /// Returns the \c VarDecl in this PBD at the same offset in the same
+  /// pattern entry as \p otherVar is in its PBD, or \c nullptr if this PBD is
+  /// too different from \p otherVar 's to find an equivalent variable.
+  VarDecl *getVarAtSimilarStructuralPosition(VarDecl *otherVar);
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::PatternBinding;
   }

include/swift/AST/DeclAttr.def

@@ -523,7 +523,11 @@ DECL_ATTR(safe, Safe,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   163)
 
-LAST_DECL_ATTR(Safe)
+DECL_ATTR(abi, ABI,
+  OnAbstractFunction | OnVar /* will eventually add types */ | LongAttribute | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  164)
+
+LAST_DECL_ATTR(ABI)
 
 #undef DECL_ATTR_ALIAS
 #undef CONTEXTUAL_DECL_ATTR_ALIAS

include/swift/AST/DiagnosticsParse.def

@@ -228,6 +228,9 @@ ERROR(let_cannot_be_addressed_property,none,
 ERROR(disallowed_var_multiple_getset,none,
       "'var' declarations with multiple variables cannot have explicit"
       " getters/setters", ())
+ERROR(stub_decl_cannot_have_body,none,
+      "stub %0 cannot have body",
+      (DescriptiveDeclKind))
 
 ERROR(disallowed_init,none,
       "initial value is not allowed here", ())

include/swift/Basic/Features.def

@@ -436,6 +436,9 @@ EXPERIMENTAL_FEATURE(GenerateForceToMainActorThunks, false)
 
 EXPERIMENTAL_FEATURE(AddressableParameters, true)
 
+/// Allow the @abi attribute.
+EXPERIMENTAL_FEATURE(ABIAttribute, true)
+
 #undef EXPERIMENTAL_FEATURE_EXCLUDED_FROM_MODULE_INTERFACE
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE

include/swift/Parse/Parser.h

@@ -933,7 +933,7 @@ class Parser {
   bool isStartOfGetSetAccessor();
 
   /// Flags that control the parsing of declarations.
-  enum ParseDeclFlags {
+  enum ParseDeclFlags : uint16_t {
     PD_Default              = 0,
     PD_AllowTopLevel        = 1 << 1,
     PD_HasContainerType     = 1 << 2,
@@ -944,6 +944,7 @@ class Parser {
     PD_InExtension          = 1 << 7,
     PD_InStruct             = 1 << 8,
     PD_InEnum               = 1 << 9,
+    PD_StubOnly             = 1 << 10,
   };
 
   /// Options that control the parsing of declarations.
@@ -953,20 +954,24 @@ class Parser {
 
   ParserStatus parseDecl(bool IsAtStartOfLineOrPreviousHadSemi,
                          bool IfConfigsAreDeclAttrs,
-                         llvm::function_ref<void(Decl *)> Handler);
+                         llvm::function_ref<void(Decl *)> Handler,
+                         bool stubOnly = false);
 
   std::pair<std::vector<Decl *>, std::optional<Fingerprint>>
   parseDeclListDelayed(IterableDeclContext *IDC);
 
   bool parseMemberDeclList(SourceLoc &LBLoc, SourceLoc &RBLoc,
                            Diag<> LBraceDiag, Diag<> RBraceDiag,
-                           IterableDeclContext *IDC);
+                           IterableDeclContext *IDC,
+                           ParseDeclOptions Flags);
 
   bool canDelayMemberDeclParsing(bool &HasOperatorDeclarations,
                                  bool &HasNestedClassDeclarations,
-                                 bool &HasDerivativeDeclarations);
+                                 bool &HasDerivativeDeclarations,
+                                 ParseDeclOptions Flags);
 
-  bool canDelayFunctionBodyParsing(bool &HasNestedTypeDeclarations);
+  bool canDelayFunctionBodyParsing(bool &HasNestedTypeDeclarations,
+                                   ParseDeclOptions Flags);
 
   bool delayParsingDeclList(SourceLoc LBLoc, SourceLoc &RBLoc,
                             IterableDeclContext *IDC);
@@ -1318,7 +1323,8 @@ class Parser {
                                        bool HasFuncKeyword = true);
   BodyAndFingerprint
   parseAbstractFunctionBodyImpl(AbstractFunctionDecl *AFD);
-  void parseAbstractFunctionBody(AbstractFunctionDecl *AFD);
+  void parseAbstractFunctionBody(AbstractFunctionDecl *AFD,
+                                 ParseDeclOptions Flags);
   BodyAndFingerprint
   parseAbstractFunctionBodyDelayed(AbstractFunctionDecl *AFD);
 

lib/AST/ASTDumper.cpp

@@ -967,9 +967,10 @@ namespace {
     }
 
     /// Print an unnamed field containing a node's name, read from a declaration.
-    void printDeclName(const ValueDecl *D, bool leadingSpace = true) {
-      if (D->getName()) {
-        printName(D->getName(), leadingSpace);
+    void printDeclName(const Decl *D, bool leadingSpace = true) {
+      auto VD = dyn_cast<ValueDecl>(D);
+      if (VD && VD->getName()) {
+        printName(VD->getName(), leadingSpace);
       } else {
         if (leadingSpace)
           OS << ' ';
@@ -979,7 +980,7 @@ namespace {
     }
 
     /// Print a field containing a node's name, read from a declaration.
-    void printDeclNameField(const ValueDecl *D, StringRef name) {
+    void printDeclNameField(const Decl *D, StringRef name) {
       printFieldRaw([&](raw_ostream &os) {
         printDeclName(D, /*leadingSpace=*/false);
       }, name);
@@ -3862,6 +3863,11 @@ class PrintAttribute : public AttributeVisitor<PrintAttribute, void, StringRef>,
 
 #undef TRIVIAL_ATTR_PRINTER
 
+  void visitABIAttr(ABIAttr *Attr, StringRef label) {
+    printCommon(Attr, "abi_attr", label);
+    printRec(Attr->abiDecl, "decl");
+    printFoot();
+  }
   void visitAccessControlAttr(AccessControlAttr *Attr, StringRef label) {
     printCommon(Attr, "access_control_attr", label);
     printField(Attr->getAccess(), "access_level");

lib/AST/Attr.cpp

@@ -1645,6 +1645,16 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DeclAttrKind::ABI: {
+    auto *attr = cast<ABIAttr>(this);
+    Printer << "@abi(";
+    if (attr->abiDecl)
+      attr->abiDecl->print(Printer, Options);
+    Printer << ")";
+
+    break;
+  }
+
 #define SIMPLE_DECL_ATTR(X, CLASS, ...) case DeclAttrKind::CLASS:
 #include "swift/AST/DeclAttr.def"
     llvm_unreachable("handled above");
@@ -1690,6 +1700,8 @@ StringRef DeclAttribute::getAttrName() const {
   case DeclAttrKind::CLASS:                                                    \
     return #NAME;
 #include "swift/AST/DeclAttr.def"
+  case DeclAttrKind::ABI:
+    return "abi";
   case DeclAttrKind::SILGenName:
     return "_silgen_name";
   case DeclAttrKind::Alignment:
@@ -2869,6 +2881,30 @@ LifetimeAttr *LifetimeAttr::create(ASTContext &context, SourceLoc atLoc,
   return new (context) LifetimeAttr(atLoc, baseRange, implicit, entry);
 }
 
+void ASTContext::recordABIAttr(ABIAttr *attr, Decl *owner) {
+  // The ABIAttr on a VarDecl ought to point to its PBD.
+  if (auto VD = dyn_cast<VarDecl>(owner)) {
+    if (auto PBD = VD->getParentPatternBinding()) {
+      owner = PBD;
+    }
+  }
+
+  auto recordABIDecl = [&](Decl *decl) {
+    ABIDeclCounterparts.insert({ decl, owner });
+  };
+
+  if (auto abiPBD = dyn_cast<PatternBindingDecl>(attr->abiDecl)) {
+    // Add to *every* VarDecl in the ABI PBD, even ones that don't properly
+    // match anything in the API PBD.
+    for (auto i : range(abiPBD->getNumPatternEntries())) {
+      abiPBD->getPattern(i)->forEachVariable(recordABIDecl);
+    }
+    return;
+  }
+
+  recordABIDecl(attr->abiDecl);
+}
+
 void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);

lib/AST/Decl.cpp

@@ -414,6 +414,8 @@ void Decl::attachParsedAttrs(DeclAttributes attrs) {
     attr->setOriginalDeclaration(this);
   for (auto *attr : attrs.getAttributes<DerivativeAttr>())
     attr->setOriginalDeclaration(this);
+  for (auto attr : attrs.getAttributes<ABIAttr, /*AllowInvalid=*/true>())
+    this->getASTContext().recordABIAttr(attr, this);
 
   getAttrs() = attrs;
 }
@@ -4268,6 +4270,43 @@ void ValueDecl::setRenamedDecl(const AvailableAttr *attr,
                                                 std::move(renameDecl));
 }
 
+VarDecl *PatternBindingDecl::
+getVarAtSimilarStructuralPosition(VarDecl *otherVar) {
+  auto otherPBD = otherVar->getParentPatternBinding();
+
+  if (!otherPBD)
+    return getSingleVar();
+  if (otherPBD == this)
+    return otherVar;
+
+  // Find the entry index and sibling index for `otherVar` within its PBD.
+  auto entryIndex = otherPBD->getPatternEntryIndexForVarDecl(otherVar);
+  
+  SmallVector<VarDecl *, 16> otherSiblings;
+  otherPBD->getPattern(entryIndex)->collectVariables(otherSiblings);
+  size_t siblingIndex =
+      llvm::find(otherSiblings, otherVar) - otherSiblings.begin();
+
+  ASSERT(siblingIndex != otherSiblings.size()
+            && "otherVar not in its own pattern?");
+
+  // Look up the same entry index and sibling index in this PBD, returning null
+  // if that index doesn't exist.
+
+  // Corresponding PBD has more patterns in it
+  if (entryIndex >= getNumPatternEntries())
+    return nullptr;
+
+  SmallVector<VarDecl *, 16> siblings;
+  getPattern(entryIndex)->collectVariables(siblings);
+
+  // Corresponding pattern has more vars in it
+  if (siblingIndex >= siblings.size())
+    return nullptr;
+
+  return siblings[siblingIndex];
+}
+
 SourceLoc Decl::getAttributeInsertionLoc(bool forModifier) const {
   // Some decls have a parent/child split where the introducer keyword is on the
   // parent, but the attributes are on the children. If this is a child in such