Remove TokenList as an option for attribute arguments

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/AttributeNodes.swift

@@ -114,10 +114,7 @@ public let ATTRIBUTE_NODES: [Node] = [
                  Child(name: "ExposeAttributeArguments",
                        kind: "ExposeAttributeArguments"),
                  Child(name: "OriginallyDefinedInArguments",
-                       kind: "OriginallyDefinedInArguments"),
-                 Child(name: "TokenList",
-                       kind: "TokenList",
-                       collectionElementName: "Token")
+                       kind: "OriginallyDefinedInArguments")
                ]),
          Child(name: "RightParen",
                kind: "RightParenToken",

Sources/SwiftParser/Attributes.swift

@@ -213,51 +213,41 @@ extension Parser {
       return parseAttribute(hasRequiredArguments: true) { parser in
         return .originallyDefinedInArguments(parser.parseOriginallyDefinedInArguments())
       }
-    case .__objc_bridged, .__raw_doc_comment, ._alwaysEmitConformanceMetadata, ._alwaysEmitIntoClient, ._assemblyVision, ._borrowed, ._compilerInitialized, ._custom, ._disfavoredOverload, ._eagerMove, ._exported, ._fixed_layout, ._frozen, ._hasInitialValue, ._hasMissingDesignatedInitializers, ._hasStorage, ._implementationOnly, ._implicitSelfCapture, ._inheritActorContext, ._inheritsConvenienceInitializers, ._marker, ._moveOnly, ._noAllocation, ._noEagerMove, ._noImplicitCopy, ._noLocks, ._noMetadata, ._nonEphemeral, ._nonoverride, ._objc_non_lazy_realization, ._show_in_interface, ._specializeExtension, ._spiOnly, ._staticInitializeObjCMetadata, ._transparent, ._unsafeInheritExecutor, ._weakLinked, .atReasync, .atRethrows, .discardableResult, .dynamicCallable, .dynamicMemberLookup, .frozen, .GKInspectable, .globalActor, .IBAction, .IBDesignable, .IBInspectable, .IBOutlet, .IBSegueAction, .inlinable, .LLDBDebuggerFunction, .main, .noDerivative, .nonobjc, .NSApplicationMain, .NSCopying,
-      .NSManaged, .objcMembers, .preconcurrency, .propertyWrapper, .requires_stored_property_inits, .resultBuilder, .runtimeMetadata, .Sendable, .testable, .typeWrapper, .typeWrapperIgnored, .UIApplicationMain, .unsafe_no_objc_tagged_pointer, .usableFromInline, .warn_unqualified_access:
-      // No arguments
-      break
-    case .__synthesized_protocol, ._clangImporterSynthesizedType, ._forbidSerializingReference, ._restatedObjCConformance:
-      // Virtual attributes that should not be parsed
-      break
-    // MARK: - Other
     case ._unavailableFromAsync:
-      // @_unavailableFromAsync(message: "Use Task.runInline from a sync context to begin an async context.")
-      break
-    }
-
-    let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
-    let (unexpectedBeforeIdent, ident) = self.expectIdentifierOrRethrows()
-    let leftParen = self.consume(if: .leftParen)
-    let arg: RawAttributeSyntax.Argument?
-    let unexpectedBeforeRightParen: RawUnexpectedNodesSyntax?
-    let rightParen: RawTokenSyntax?
-    if leftParen != nil {
-      var args = [RawTokenSyntax]()
-      var loopProgress = LoopProgressCondition()
-      while !self.at(any: [.eof, .rightParen]) && loopProgress.evaluate(currentToken) {
-        args.append(self.consumeAnyToken())
+      return parseAttribute(hasRequiredArguments: false) { parser in
+        let (unexpectedBeforeLabel, label) = parser.expectContextualKeyword("message")
+        let (unexpectedBeforeColon, colon) = parser.expect(.colon)
+        let (unexpectedBeforeMessage, message) = parser.expect(.stringLiteral)
+        return .namedAttributeString(
+          RawNamedAttributeStringArgumentSyntax(
+            unexpectedBeforeLabel,
+            nameTok: label,
+            unexpectedBeforeColon,
+            colon: colon,
+            unexpectedBeforeMessage,
+            stringOrDeclname: .string(message),
+            arena: parser.arena
+          )
+        )
       }
-      arg = .tokenList(RawTokenListSyntax(elements: args, arena: self.arena))
-      (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-    } else {
-      arg = nil
-      unexpectedBeforeRightParen = nil
-      rightParen = nil
-    }
-    return .attribute(
-      RawAttributeSyntax(
-        unexpectedBeforeAtSign,
-        atSignToken: atSign,
-        unexpectedBeforeIdent,
-        attributeName: ident,
-        leftParen: leftParen,
-        argument: arg,
-        unexpectedBeforeRightParen,
-        rightParen: rightParen,
-        arena: self.arena
+    case .__objc_bridged, .__raw_doc_comment, ._alwaysEmitConformanceMetadata, ._alwaysEmitIntoClient, ._assemblyVision, ._borrowed, ._compilerInitialized, ._custom, ._disfavoredOverload, ._eagerMove, ._exported, ._fixed_layout, ._frozen, ._hasInitialValue, ._hasMissingDesignatedInitializers, ._hasStorage, ._implementationOnly, ._implicitSelfCapture, ._inheritActorContext, ._inheritsConvenienceInitializers, ._marker, ._moveOnly, ._noAllocation, ._noEagerMove, ._noImplicitCopy, ._noLocks, ._noMetadata, ._nonEphemeral, ._nonoverride, ._objc_non_lazy_realization, ._show_in_interface, ._specializeExtension, ._spiOnly, ._staticInitializeObjCMetadata, ._transparent, ._unsafeInheritExecutor, ._weakLinked, .atReasync, .atRethrows, .discardableResult, .dynamicCallable, .dynamicMemberLookup, .frozen, .GKInspectable, .globalActor, .IBAction, .IBDesignable, .IBInspectable, .IBOutlet, .IBSegueAction, .inlinable, .LLDBDebuggerFunction, .main, .noDerivative, .nonobjc, .NSApplicationMain, .NSCopying,
+      .NSManaged, .objcMembers, .preconcurrency, .propertyWrapper, .requires_stored_property_inits, .resultBuilder, .runtimeMetadata, .Sendable, .testable, .typeWrapper, .typeWrapperIgnored, .UIApplicationMain, .unsafe_no_objc_tagged_pointer, .usableFromInline, .warn_unqualified_access,
+      .__synthesized_protocol, ._clangImporterSynthesizedType, ._forbidSerializingReference, ._restatedObjCConformance:
+      let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
+      let (unexpectedBeforeAttributeName, attributeName) = self.expectIdentifierOrRethrows()
+      return .attribute(
+        RawAttributeSyntax(
+          unexpectedBeforeAtSign,
+          atSignToken: atSign,
+          unexpectedBeforeAttributeName,
+          attributeName: attributeName,
+          leftParen: nil,
+          argument: nil,
+          rightParen: nil,
+          arena: self.arena
+        )
       )
-    )
+    }
   }
 
   mutating func parseCustomAttribute() -> RawCustomAttributeSyntax {

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -10546,10 +10546,9 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
     case `opaqueReturnTypeOfAttributeArguments`(RawOpaqueReturnTypeOfAttributeArgumentsSyntax)
     case `exposeAttributeArguments`(RawExposeAttributeArgumentsSyntax)
     case `originallyDefinedInArguments`(RawOriginallyDefinedInArgumentsSyntax)
-    case `tokenList`(RawTokenListSyntax)
 
     public static func isKindOf(_ raw: RawSyntax) -> Bool {
-      return RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilitySpecListSyntax.isKindOf(raw) || RawSpecializeAttributeSpecListSyntax.isKindOf(raw) || RawObjCSelectorSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeRegistrationAttributeArgumentsSyntax.isKindOf(raw) || RawNamedAttributeStringArgumentSyntax.isKindOf(raw) || RawBackDeployAttributeSpecListSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInArgumentsSyntax.isKindOf(raw) || RawTokenListSyntax.isKindOf(raw)
+      return RawTokenSyntax.isKindOf(raw) || RawStringLiteralExprSyntax.isKindOf(raw) || RawAvailabilitySpecListSyntax.isKindOf(raw) || RawSpecializeAttributeSpecListSyntax.isKindOf(raw) || RawObjCSelectorSyntax.isKindOf(raw) || RawImplementsAttributeArgumentsSyntax.isKindOf(raw) || RawDifferentiableAttributeArgumentsSyntax.isKindOf(raw) || RawDerivativeRegistrationAttributeArgumentsSyntax.isKindOf(raw) || RawNamedAttributeStringArgumentSyntax.isKindOf(raw) || RawBackDeployAttributeSpecListSyntax.isKindOf(raw) || RawConventionAttributeArgumentsSyntax.isKindOf(raw) || RawConventionWitnessMethodAttributeArgumentsSyntax.isKindOf(raw) || RawOpaqueReturnTypeOfAttributeArgumentsSyntax.isKindOf(raw) || RawExposeAttributeArgumentsSyntax.isKindOf(raw) || RawOriginallyDefinedInArgumentsSyntax.isKindOf(raw)
     }
 
     public var raw: RawSyntax {
@@ -10569,7 +10568,6 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
       case .opaqueReturnTypeOfAttributeArguments(let node): return node.raw
       case .exposeAttributeArguments(let node): return node.raw
       case .originallyDefinedInArguments(let node): return node.raw
-      case .tokenList(let node): return node.raw
       }
     }
 
@@ -10634,10 +10632,6 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         self = .originallyDefinedInArguments(node)
         return
       }
-      if let node = RawTokenListSyntax(other) {
-        self = .tokenList(node)
-        return
-      }
       return nil
     }
   }

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -1586,7 +1586,6 @@ func validateLayout(layout: RawSyntaxBuffer, as kind: SyntaxKind) {
       verify(layout[7], as: RawSyntax?.self),
       verify(layout[7], as: RawSyntax?.self),
       verify(layout[7], as: RawSyntax?.self),
-      verify(layout[7], as: RawSyntax?.self),
     ])
     assertNoError(kind, 8, verify(layout[8], as: RawUnexpectedNodesSyntax?.self))
     assertNoError(kind, 9, verify(layout[9], as: RawTokenSyntax?.self))

Sources/SwiftSyntax/gyb_generated/syntax_nodes/SyntaxNodes.swift

@@ -12405,7 +12405,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     case `opaqueReturnTypeOfAttributeArguments`(OpaqueReturnTypeOfAttributeArgumentsSyntax)
     case `exposeAttributeArguments`(ExposeAttributeArgumentsSyntax)
     case `originallyDefinedInArguments`(OriginallyDefinedInArgumentsSyntax)
-    case `tokenList`(TokenListSyntax)
     public var _syntaxNode: Syntax {
       switch self {
       case .token(let node): return node._syntaxNode
@@ -12423,7 +12422,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
       case .opaqueReturnTypeOfAttributeArguments(let node): return node._syntaxNode
       case .exposeAttributeArguments(let node): return node._syntaxNode
       case .originallyDefinedInArguments(let node): return node._syntaxNode
-      case .tokenList(let node): return node._syntaxNode
       }
     }
     init(_ data: SyntaxData) { self.init(Syntax(data))! }
@@ -12472,9 +12470,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     public init(_ node: OriginallyDefinedInArgumentsSyntax) {
       self = .originallyDefinedInArguments(node)
     }
-    public init(_ node: TokenListSyntax) {
-      self = .tokenList(node)
-    }
     public init?<S: SyntaxProtocol>(_ node: S) {
       if let node = node.as(TokenSyntax.self) {
         self = .token(node)
@@ -12536,10 +12531,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
         self = .originallyDefinedInArguments(node)
         return
       }
-      if let node = node.as(TokenListSyntax.self) {
-        self = .tokenList(node)
-        return
-      }
       return nil
     }
 
@@ -12560,7 +12551,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
         .node(OpaqueReturnTypeOfAttributeArgumentsSyntax.self),
         .node(ExposeAttributeArgumentsSyntax.self),
         .node(OriginallyDefinedInArgumentsSyntax.self),
-        .node(TokenListSyntax.self),
       ])
     }
   }

Tests/SwiftParserTest/AttributeTests.swift

@@ -410,4 +410,54 @@ final class AttributeTests: XCTestCase {
       """
     )
   }
+
+  func testUnavailableFromAsync() {
+    AssertParse(
+      """
+      @_unavailableFromAsync
+      func foo() {}
+      """
+    )
+
+    AssertParse(
+      """
+      @_unavailableFromAsync(message: "abc")
+      func foo() {}
+      """
+    )
+
+    AssertParse(
+      """
+      @_unavailableFromAsync(1️⃣nope: "abc")
+      func foo() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected 'message' in attribute argument"),
+        DiagnosticSpec(message: "unexpected code 'nope' before attribute argument"),
+      ]
+    )
+
+    AssertParse(
+      """
+      @_unavailableFromAsync(message1️⃣= "abc")
+      func foo() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected ':' and value in attribute argument"),
+        DiagnosticSpec(message: #"unexpected code '= "abc"' in attribute"#),
+      ]
+    )
+
+    AssertParse(
+      """
+      @_unavailableFromAsync(message: 1️⃣abc)
+      func foo() {}
+      """,
+      diagnostics: [
+        DiagnosticSpec(message: "expected value in attribute argument"),
+        DiagnosticSpec(message: "unexpected code 'abc' in attribute"),
+      ]
+    )
+
+  }
 }

gyb_syntax_support/AttributeNodes.py

@@ -81,10 +81,6 @@
                              kind='ExposeAttributeArguments'),
                        Child('OriginallyDefinedInArguments',
                              kind='OriginallyDefinedInArguments'),
-                       # TokenList for custom effects which are parsed by
-                       # `FunctionEffects.parse()` in swift.
-                       Child('TokenList', kind='TokenList',
-                             collection_element_name='Token'),
                    ], description='''
                    The arguments of the attribute. In case the attribute
                    takes multiple arguments, they are gather in the