Parse the @abi attribute in SwiftSyntax

Matches work in swiftlang/swift#76878.

Author: beccadax

CodeGeneration/Sources/SyntaxSupport/AttributeNodes.swift

@@ -139,6 +139,11 @@ public let ATTRIBUTE_NODES: [Node] = [
             name: "documentationArguments",
             kind: .node(kind: .documentationAttributeArgumentList)
           ),
+          Child(
+            name: "abiArguments",
+            kind: .node(kind: .abiAttributeArguments),
+            experimentalFeature: .abiAttribute
+          )
         ]),
         documentation: """
           The arguments of the attribute.
@@ -267,6 +272,31 @@ public let ATTRIBUTE_NODES: [Node] = [
     ]
   ),
 
+  Node(
+    kind: .abiAttributeArguments,
+    base: .syntax,
+    experimentalFeature: .abiAttribute,
+    nameForDiagnostics: "ABI-providing declaration",
+    documentation: "The arguments of the '@abi' attribute",
+    children: [
+      Child(
+        name: "provider",
+        kind: ChildKind.nodeChoices(choices: [
+          Child(name: "associatedType", kind: .node(kind: .associatedTypeDecl)),
+          Child(name: "declGroup", kind: .node(kind: .declGroupHeader)),
+          Child(name: "deinitializer", kind: .node(kind: .deinitializerDecl)),
+          Child(name: "enumCase", kind: .node(kind: .enumCaseDecl)),
+          Child(name: "function", kind: .node(kind: .functionDecl)),
+          Child(name: "initializer", kind: .node(kind: .initializerDecl)),
+          Child(name: "subscript", kind: .node(kind: .subscriptDecl)),
+          Child(name: "typeAlias", kind: .node(kind: .typeAliasDecl)),
+          Child(name: "variable", kind: .node(kind: .variableDecl)),
+          Child(name: "unsupported", kind: .node(kind: .decl)),
+        ])
+      ),
+    ]
+  ),
+
   Node(
     kind: .conventionAttributeArguments,
     base: .syntax,

CodeGeneration/Sources/SyntaxSupport/ExperimentalFeatures.swift

@@ -19,6 +19,7 @@ public enum ExperimentalFeature: String, CaseIterable {
   case nonescapableTypes
   case trailingComma
   case coroutineAccessors
+  case abiAttribute
 
   /// The name of the feature, which is used in the doc comment.
   public var featureName: String {
@@ -35,6 +36,8 @@ public enum ExperimentalFeature: String, CaseIterable {
       return "trailing comma"
     case .coroutineAccessors:
       return "CoroutineAccessors"
+    case .abiAttribute:
+      return "@abi attribute"
     }
   }
 

CodeGeneration/Sources/SyntaxSupport/KeywordSpec.swift

@@ -131,6 +131,7 @@ public enum Keyword: CaseIterable {
   case _underlyingVersion
   case _UnknownLayout
   case _version
+  case abi
   case accesses
   case actor
   case addressWithNativeOwner
@@ -404,6 +405,8 @@ public enum Keyword: CaseIterable {
       return KeywordSpec("_UnknownLayout")
     case ._version:
       return KeywordSpec("_version")
+    case .abi:
+      return KeywordSpec("abi", experimentalFeature: .abiAttribute)
     case .accesses:
       return KeywordSpec("accesses")
     case .actor:

CodeGeneration/Sources/SyntaxSupport/SyntaxNodeKind.swift

@@ -22,6 +22,7 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
 
   case _canImportExpr
   case _canImportVersionInfo
+  case abiAttributeArguments
   case accessorBlock
   case accessorDecl
   case accessorDeclList
@@ -348,14 +349,23 @@ public enum SyntaxNodeKind: String, CaseIterable, IdentifierConvertible, TypeCon
     return .identifier(rawValue)
   }
 
+  public var uppercasedFirstWordRawValue: String {
+    switch self {
+    case .abiAttributeArguments:
+      "ABIAttributeArguments"
+    default:
+      rawValue.withFirstCharacterUppercased
+    }
+  }
+
   public var syntaxType: TypeSyntax {
     switch self {
     case .syntax:
       return "Syntax"
     case .syntaxCollection:
       return "SyntaxCollection"
     default:
-      return "\(raw: rawValue.withFirstCharacterUppercased)Syntax"
+      return "\(raw: uppercasedFirstWordRawValue)Syntax"
     }
   }
 

CodeGeneration/Sources/Utils/SyntaxBuildableType.swift

@@ -151,7 +151,7 @@ public struct SyntaxBuildableType: Hashable {
   public var resultBuilderType: TypeSyntax {
     switch kind {
     case .node(kind: let kind):
-      return TypeSyntax("\(raw: kind.rawValue.withFirstCharacterUppercased)Builder")
+      return TypeSyntax("\(raw: kind.uppercasedFirstWordRawValue)Builder")
     case .token:
       preconditionFailure("Tokens cannot be constructed using result builders")
     }

CodeGeneration/Sources/generate-swift-syntax/templates/swiftsyntax/SyntaxEnumFile.swift

@@ -60,7 +60,7 @@ let syntaxEnumFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
 
   for base in SYNTAX_NODES where base.kind.isBase {
     let baseKind = base.kind
-    let baseName = baseKind.rawValue.withFirstCharacterUppercased
+    let baseName = baseKind.uppercasedFirstWordRawValue
     let enumType: TypeSyntax = "\(raw: baseName)SyntaxEnum"
 
     try! EnumDeclSyntax(

Sources/SwiftParser/Attributes.swift

@@ -11,9 +11,9 @@
 //===----------------------------------------------------------------------===//
 
 #if swift(>=6)
-@_spi(RawSyntax) internal import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) internal import SwiftSyntax
 #else
-@_spi(RawSyntax) import SwiftSyntax
+@_spi(ExperimentalLanguageFeatures) @_spi(RawSyntax) import SwiftSyntax
 #endif
 
 extension Parser {
@@ -58,6 +58,7 @@ extension Parser {
     case _typeEraser
     case _unavailableFromAsync
     case `rethrows`
+    case abi
     case attached
     case available
     case backDeployed
@@ -95,6 +96,7 @@ extension Parser {
       case TokenSpec(._typeEraser): self = ._typeEraser
       case TokenSpec(._unavailableFromAsync): self = ._unavailableFromAsync
       case TokenSpec(.`rethrows`): self = .rethrows
+      case TokenSpec(.abi) where experimentalFeatures.contains(.abiAttribute): self = .abi
       case TokenSpec(.attached): self = .attached
       case TokenSpec(.available): self = .available
       case TokenSpec(.backDeployed): self = .backDeployed
@@ -136,6 +138,7 @@ extension Parser {
       case ._typeEraser: return .keyword(._typeEraser)
       case ._unavailableFromAsync: return .keyword(._unavailableFromAsync)
       case .`rethrows`: return .keyword(.rethrows)
+      case .abi: return .keyword(.abi)
       case .attached: return .keyword(.attached)
       case .available: return .keyword(.available)
       case .backDeployed: return .keyword(.backDeployed)
@@ -176,9 +179,16 @@ extension Parser {
     case noArgument
   }
 
+  /// Parse the argument of an attribute, if it has one.
+  ///
+  /// - Parameters:
+  ///   - argumentMode: Indicates whether the attribute must, may, or may not have an argument.
+  ///   - parseArguments: Called to parse the argument list. If there is an opening parenthesis, it will have already been consumed.
+  ///   - parseMissingArguments: If provided, called instead of `parseArgument` when an argument list was required but no opening parenthesis was present.
   mutating func parseAttribute(
     argumentMode: AttributeArgumentMode,
-    parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments
+    parseArguments: (inout Parser) -> RawAttributeSyntax.Arguments,
+    parseMissingArguments: ((inout Parser) -> RawAttributeSyntax.Arguments)? = nil
   ) -> RawAttributeListSyntax.Element {
     var (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
     if atSign.trailingTriviaByteLength > 0 || self.currentToken.leadingTriviaByteLength > 0 {
@@ -213,7 +223,11 @@ extension Parser {
         )
         leftParen = leftParen.tokenView.withTokenDiagnostic(tokenDiagnostic: diagnostic, arena: self.arena)
       }
-      let argument = parseArguments(&self)
+      let argument = if let parseMissingArguments, leftParen.presence == .missing {
+        parseMissingArguments(&self)
+      } else {
+        parseArguments(&self)
+      }
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       return .attribute(
         RawAttributeSyntax(
@@ -255,6 +269,12 @@ extension Parser {
     }
 
     switch peek(isAtAnyIn: DeclarationAttributeWithSpecialSyntax.self) {
+    case .abi:
+      return parseAttribute(argumentMode: .required) { parser in
+        return .abiArguments(parser.parseABIAttributeArguments())
+      } parseMissingArguments: { parser in
+        return .abiArguments(parser.parseABIAttributeArguments(missing: true))
+      }
     case .available, ._spi_available:
       return parseAttribute(argumentMode: .required) { parser in
         return .availability(parser.parseAvailabilityArgumentSpecList())
@@ -918,6 +938,75 @@ extension Parser {
   }
 }
 
+extension Parser {
+  mutating func parseABIAttributeArguments(missing: Bool = false) -> RawABIAttributeArgumentsSyntax {
+    let providerDecl: RawABIAttributeArgumentsSyntax.Provider
+    if missing || at(.rightParen) {
+      // There are two situations where the left paren might be missing:
+      //   1. The user just forgot the paren: `@abi var x_abi: Int) var x: Int`
+      //   2. The user forgot the whole argument list: `@abi var x: Int`
+      // Normally, we would distinguish these by seeing if whatever comes after
+      // the attribute parses as an argument. However, for @abi the argument is
+      // a decl, so in #2, we would consume the decl the attribute is attached
+      // to! This leads to a lousy diagnostic in that situation.
+      // Avoid this problem by simply returning a missing decl immediately.
+      // FIXME: Could we look ahead to find an unbalanced parenthesis?
+      providerDecl = .unsupported(
+        RawDeclSyntax(
+          RawMissingDeclSyntax(
+            attributes: self.emptyCollection(RawAttributeListSyntax.self),
+            modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
+            arena: arena
+          )
+        )
+      )
+    } else {
+      switch nextDeclarationKeyword() {
+      case .group?:
+        providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclarationGroupHeader())!
+
+      case .simple?, .binding?, nil:
+        providerDecl = RawABIAttributeArgumentsSyntax.Provider(parseDeclaration(in: .argumentList))!
+      }
+    }
+
+    return RawABIAttributeArgumentsSyntax(provider: providerDecl, arena: arena)
+  }
+
+  mutating func nextDeclarationKeyword() -> DeclarationKeyword? {
+    return self.withLookahead { subparser in
+      // Consume attributes.
+      var attributeProgress = LoopProgressCondition()
+      while subparser.hasProgressed(&attributeProgress) && subparser.at(.atSign) {
+        _ = subparser.consumeAttributeList()
+      }
+
+      // Consume modifiers.
+      if subparser.currentToken.isLexerClassifiedKeyword || subparser.currentToken.rawTokenKind == .identifier {
+        var modifierProgress = LoopProgressCondition()
+        while let (modifierKind, handle) = subparser.at(anyIn: DeclarationModifier.self),
+          subparser.hasProgressed(&modifierProgress)
+        {
+          if modifierKind == .class {
+            // `class` is a modifier only if it's followed by an introducer or modifier.
+            if subparser.peek(isAtAnyIn: DeclarationStart.self) == nil {
+              break
+            }
+          }
+          subparser.eat(handle)
+          if subparser.at(.leftParen) && modifierKind.canHaveParenthesizedArgument {
+            subparser.consumeAnyToken()
+            subparser.consume(to: .rightParen)
+          }
+        }
+      }
+
+      // Is the next thing a declaration introducer?
+      return subparser.at(anyIn: DeclarationKeyword.self)?.spec
+    }
+  }
+}
+
 extension Parser {
   mutating func parseBackDeployedAttributeArguments() -> RawBackDeployedAttributeArgumentsSyntax {
     let (unexpectedBeforeLabel, label) = self.expect(.keyword(.before))