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/Attr.h

@@ -201,6 +201,10 @@ class DeclAttribute : public AttributeBase {
 
       NumFeatures : 31
     );
+
+    SWIFT_INLINE_BITFIELD(ABIAttr, DeclAttribute, 1,
+      isInverse : 1
+    );
   } Bits;
   // clang-format on
 
@@ -3303,6 +3307,39 @@ class IsolatedTypeAttr : public SimpleTypeAttrWithArgs<TypeAttrKind::Isolated> {
   void printImpl(ASTPrinter &printer, const PrintOptions &options) const;
 };
 
+/// Defines the @abi attribute.
+class ABIAttr : public DeclAttribute {
+public:
+  ABIAttr(Decl *abiDecl, SourceLoc AtLoc, SourceRange Range,
+          bool IsInverse, bool Implicit)
+      : DeclAttribute(DeclAttrKind::ABI, AtLoc, Range, Implicit),
+        abiDecl(abiDecl)
+  {
+    Bits.ABIAttr.isInverse = IsInverse;
+  }
+
+  ABIAttr(Decl *abiDecl, bool IsInverse, bool Implicit)
+      : ABIAttr(abiDecl, SourceLoc(), SourceRange(), IsInverse, 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;
+
+  /// Is this attribute attached to the ABI declaration and pointing back to
+  /// the original? Inverse \c ABIAttr s are always implicit and result in an
+  /// \c ABIRole with \c providesAPI() but not \c providesABI() .
+  bool isInverse() const { return Bits.ABIAttr.isInverse; }
+
+  void connectToInverse(Decl *owner) const;
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DeclAttrKind::ABI;
+  }
+};
+
 using TypeOrCustomAttr =
   llvm::PointerUnion<CustomAttr*, TypeAttribute*>;
 

include/swift/AST/Decl.h

@@ -2604,6 +2604,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

@@ -513,7 +513,11 @@ DECL_ATTR(lifetime, Lifetime,
   OnAccessor | OnConstructor | OnFunc | OnSubscript | LongAttribute | ABIBreakingToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   161)
 
-LAST_DECL_ATTR(Lifetime)
+DECL_ATTR(abi, ABI,
+  OnAbstractFunction | OnVar /* will eventually add types */ | LongAttribute | ABIStableToAdd | ABIStableToRemove | APIStableToAdd | APIStableToRemove,
+  162)
+
+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

@@ -423,6 +423,9 @@ EXPERIMENTAL_FEATURE(UnspecifiedMeansMainActorIsolated, false)
 /// modify/read single-yield coroutines
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(CoroutineAccessors, 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

@@ -943,7 +943,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,
@@ -954,6 +954,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.
@@ -964,19 +965,23 @@ class Parser {
   ParserStatus parseDecl(bool IsAtStartOfLineOrPreviousHadSemi,
                          bool IfConfigsAreDeclAttrs,
                          llvm::function_ref<void(Decl *)> Handler,
-                         bool fromASTGen = false);
+                         bool fromASTGen = false,
+                         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 &HasNestedClassDeclarations,
+                                 ParseDeclOptions Flags);
 
-  bool canDelayFunctionBodyParsing(bool &HasNestedTypeDeclarations);
+  bool canDelayFunctionBodyParsing(bool &HasNestedTypeDeclarations,
+                                   ParseDeclOptions Flags);
 
   bool delayParsingDeclList(SourceLoc LBLoc, SourceLoc &RBLoc,
                             IterableDeclContext *IDC);
@@ -1342,7 +1347,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/Attr.cpp

@@ -1041,6 +1041,11 @@ void DeclAttributes::print(ASTPrinter &Printer, const PrintOptions &Options,
     if (Options.excludeAttr(DA))
       continue;
 
+    // Skip inverse ABIAttrs--these are an implementation detail.
+    if (auto abiAttr = dyn_cast<ABIAttr>(DA))
+      if (abiAttr->isInverse())
+        continue;
+
     // In the public interfaces of -library-level=api modules, skip attributes
     // that reference SPI platforms.
     if (Options.printPublicInterface() && libraryLevelAPI &&
@@ -1258,6 +1263,13 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     }
     break;
   }
+
+  case DeclAttrKind::ABI:
+    // Inverse attributes should never be printed.
+    if (cast<ABIAttr>(this)->isInverse())
+      return false;
+    break;
+
   default:
     break;
   }
@@ -1826,6 +1838,17 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DeclAttrKind::ABI: {
+    auto *attr = cast<ABIAttr>(this);
+    Printer << "@abi(";
+    ASSERT(!attr->isInverse() && "should be skipped above");
+    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");
@@ -1871,6 +1894,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:
@@ -3071,6 +3096,38 @@ LifetimeAttr *LifetimeAttr::create(ASTContext &context, SourceLoc atLoc,
   return new (mem) LifetimeAttr(atLoc, baseRange, implicit, entries);
 }
 
+void ABIAttr::connectToInverse(Decl *owner) const {
+  if (isInverse())
+    return;
+
+  // If necessary, convert abiDecl's PBD to a specific VarDecl.
+  auto correspondingDecl = abiDecl;
+  if (auto PBD = dyn_cast<PatternBindingDecl>(correspondingDecl)) {
+    if (!isa<VarDecl>(owner))
+      // Invalid code (e.g. `@abi(var x) func x()`). Won't be able to connect.
+      return;
+
+    correspondingDecl =
+        PBD->getVarAtSimilarStructuralPosition(cast<VarDecl>(owner));
+  }
+
+  if (!correspondingDecl)
+    return;
+
+  auto inverseAttr = correspondingDecl->getAttrs().getAttribute<ABIAttr>();
+  ASSERT(inverseAttr && inverseAttr->isInverse());
+
+  // Reverse of the above: If we're trying to connect to a VarDecl, connect to
+  // its PBD instead.
+  auto inverseCorrespondingDecl = owner;
+  if (auto VD = dyn_cast<VarDecl>(inverseCorrespondingDecl))
+    if (auto PBD = VD->getParentPatternBinding())
+      inverseCorrespondingDecl = PBD;
+
+  inverseAttr->abiDecl = inverseCorrespondingDecl;
+}
+
+
 void swift::simple_display(llvm::raw_ostream &out, const DeclAttribute *attr) {
   if (attr)
     attr->print(out);

lib/AST/Decl.cpp

@@ -4168,6 +4168,43 @@ bool ValueDecl::canInferObjCFromRequirement(ValueDecl *requirement) {
   return false;
 }
 
+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

lib/AST/FeatureSet.cpp

@@ -292,6 +292,11 @@ static bool usesFeatureAllowUnsafeAttribute(Decl *decl) {
   return decl->getAttrs().hasAttribute<UnsafeAttr>();
 }
 
+static bool usesFeatureABIAttribute(Decl *decl) {
+  auto abiAttr = decl->getAttrs().getAttribute<ABIAttr>();
+  return abiAttr && !abiAttr->isInverse();
+}
+
 UNINTERESTING_FEATURE(WarnUnsafe)
 UNINTERESTING_FEATURE(SafeInterop)
 

lib/ASTGen/Sources/ASTGen/DeclAttrs.swift

@@ -101,6 +101,8 @@ extension ASTGenVisitor {
       let attrName = identTy.name.rawText
       let attrKind = BridgedDeclAttrKind(from: attrName.bridged)
       switch attrKind {
+      case .ABI:
+        return self.generateABIAttr(attribute: node)?.asDeclAttribute
       case .alignment:
         return self.generateAlignmentAttr(attribute: node)?.asDeclAttribute
       case .available:
@@ -322,6 +324,11 @@ extension ASTGenVisitor {
     return self.generateCustomAttr(attribute: node)?.asDeclAttribute
   }
 
+  func generateABIAttr(attribute node: AttributeSyntax) -> BridgedABIAttr? {
+    #warning("TODO: implement generateABIAttr")
+    fatalError("TODO: implement generateABIAttr")
+  }
+
   func generateAlignmentAttr(attribute node: AttributeSyntax) -> BridgedAlignmentAttr? {
     guard
       let arg = node.arguments?.as(TokenSyntax.self)