Merge Attribute and CustomAttribute

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/AttributeNodes.swift

@@ -24,39 +24,6 @@ public let ATTRIBUTE_NODES: [Node] = [
        element: "Token",
        omitWhenEmpty: true),
 
-  Node(name: "CustomAttribute",
-       nameForDiagnostics: "attribute",
-       description: "A custom `@` attribute.",
-       kind: "Syntax",
-       children: [
-         Child(name: "AtSignToken",
-               kind: "AtSignToken",
-               description: "The `@` sign.",
-               tokenChoices: [
-                 "AtSign"
-               ]),
-         Child(name: "AttributeName",
-               kind: "Type",
-               description: "The name of the attribute.",
-               classification: "Attribute"),
-         Child(name: "LeftParen",
-               kind: "LeftParenToken",
-               isOptional: true,
-               tokenChoices: [
-                 "LeftParen"
-               ]),
-         Child(name: "ArgumentList",
-               kind: "TupleExprElementList",
-               isOptional: true,
-               collectionElementName: "Argument"),
-         Child(name: "RightParen",
-               kind: "RightParenToken",
-               isOptional: true,
-               tokenChoices: [
-                 "RightParen"
-               ])
-       ]),
-
   Node(name: "Attribute",
        nameForDiagnostics: "attribute",
        description: "An `@` attribute.",
@@ -70,7 +37,7 @@ public let ATTRIBUTE_NODES: [Node] = [
                  "AtSign"
                ]),
          Child(name: "AttributeName",
-               kind: "Token",
+               kind: "Type",
                description: "The name of the attribute.",
                classification: "Attribute"),
          Child(name: "LeftParen",
@@ -85,6 +52,8 @@ public let ATTRIBUTE_NODES: [Node] = [
                description: "The arguments of the attribute. In case the attributetakes multiple arguments, they are gather in theappropriate takes first.",
                isOptional: true,
                nodeChoices: [
+                 Child(name: "ArgumentList",
+                       kind: "TupleExprElementList"),
                  Child(name: "Token",
                        kind: "Token"),
                  Child(name: "Availability",
@@ -132,7 +101,7 @@ public let ATTRIBUTE_NODES: [Node] = [
        kind: "SyntaxCollection",
        element: "Syntax",
        elementName: "Attribute",
-       elementChoices: ["Attribute", "CustomAttribute", "IfConfigDecl"],
+       elementChoices: ["Attribute", "IfConfigDecl"],
        omitWhenEmpty: true),
 
   Node(name: "SpecializeAttributeSpecList",

Sources/IDEUtils/generated/SyntaxClassification.swift

@@ -89,8 +89,6 @@ extension SyntaxClassification {
     // Separate checks for token nodes (most common checks) versus checks for layout nodes.
     if childKind == .token {
       switch (parentKind, indexInParent) {
-      case (.attribute, 3): 
-        return (.attribute, false)
       case (.availabilityVersionRestriction, 1): 
         return (.keyword, false)
       case (.constrainedSugarType, 1): 
@@ -122,10 +120,10 @@ extension SyntaxClassification {
       }
     } else {
       switch (parentKind, indexInParent) {
+      case (.attribute, 3): 
+        return (.attribute, false)
       case (.availabilityVersionRestrictionListEntry, 1): 
         return (.keyword, false)
-      case (.customAttribute, 3): 
-        return (.attribute, false)
       case (.ifConfigClause, 3): 
         return (.buildConfigId, false)
       case (.operatorDecl, 3): 

Sources/SwiftParser/Attributes.swift

@@ -29,18 +29,48 @@ extension Parser {
 }
 
 extension Parser {
-  mutating func parseAttribute(hasRequiredArguments: Bool, parseArguments: (inout Parser) -> RawAttributeSyntax.Argument) -> RawAttributeListSyntax.Element {
+  mutating func parseAttributeWithoutArguments() -> RawAttributeListSyntax.Element {
     let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
-    let (unexpectedBeforeAttributeName, attributeName) = self.expect(.identifier, remapping: .contextualKeyword)
-    if hasRequiredArguments {
+    let attributeName = self.parseType()
+    return .attribute(
+      RawAttributeSyntax(
+        unexpectedBeforeAtSign,
+        atSignToken: atSign,
+        attributeName: attributeName,
+        leftParen: nil,
+        argument: nil,
+        rightParen: nil,
+        arena: self.arena
+      )
+    )
+  }
+
+  enum AttributeArgumentMode {
+    case required
+    case customAttribute
+    case optional
+  }
+
+  mutating func parseAttribute(argumentMode: AttributeArgumentMode, parseArguments: (inout Parser) -> RawAttributeSyntax.Argument) -> RawAttributeListSyntax.Element {
+    let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
+    let attributeName = self.parseType()
+    let shouldParseArgument: Bool
+    switch argumentMode {
+    case .required:
+      shouldParseArgument = true
+    case .customAttribute:
+      shouldParseArgument = self.lookahead().isCustomAttributeArgument() && self.at(.leftParen, where: { !$0.isAtStartOfLine })
+    case .optional:
+      shouldParseArgument = self.at(.leftParen)
+    }
+    if shouldParseArgument {
       let (unexpectedBeforeLeftParen, leftParen) = self.expect(.leftParen)
       let argument = parseArguments(&self)
       let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
       return .attribute(
         RawAttributeSyntax(
           unexpectedBeforeAtSign,
           atSignToken: atSign,
-          unexpectedBeforeAttributeName,
           attributeName: attributeName,
           unexpectedBeforeLeftParen,
           leftParen: leftParen,
@@ -50,28 +80,11 @@ extension Parser {
           arena: self.arena
         )
       )
-    } else if let leftParen = self.consume(if: .leftParen) {
-      let argument = parseArguments(&self)
-      let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-      return .attribute(
-        RawAttributeSyntax(
-          unexpectedBeforeAtSign,
-          atSignToken: atSign,
-          unexpectedBeforeAttributeName,
-          attributeName: attributeName,
-          leftParen: leftParen,
-          argument: argument,
-          unexpectedBeforeRightParen,
-          rightParen: rightParen,
-          arena: self.arena
-        )
-      )
     } else {
       return .attribute(
         RawAttributeSyntax(
           unexpectedBeforeAtSign,
           atSignToken: atSign,
-          unexpectedBeforeAttributeName,
           attributeName: attributeName,
           leftParen: nil,
           argument: nil,
@@ -93,13 +106,11 @@ extension Parser {
       )
     }
 
-    guard let declAttr = DeclarationAttribute(rawValue: self.peek().tokenText) else {
-      return .customAttribute(self.parseCustomAttribute())
-    }
+    let declAttr = DeclarationAttribute(rawValue: self.peek().tokenText)
 
     switch declAttr {
     case .available, ._spi_available:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         if parser.peek().tokenKind == .integerLiteral {
           return .availability(parser.parseAvailabilitySpecList(from: .available))
         } else if parser.peek().tokenKind == .floatingLiteral {
@@ -109,27 +120,27 @@ extension Parser {
         }
       }
     case .differentiable:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .differentiableArguments(parser.parseDifferentiableAttributeArguments())
       }
     case .derivative, .transpose:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .derivativeRegistrationArguments(parser.parseDerivativeAttributeArguments())
       }
     case .objc:
-      return parseAttribute(hasRequiredArguments: false) { parser in
+      return parseAttribute(argumentMode: .optional) { parser in
         return .objCName(parser.parseObjectiveCSelector())
       }
     case ._specialize:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .specializeArguments(parser.parseSpecializeAttributeSpecList())
       }
     case ._private:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .underscorePrivateAttributeArguments(parser.parseUnderscorePrivateAttributeArguments())
       }
     case ._dynamicReplacement:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .dynamicReplacementArguments(parser.parseDynamicReplacementArguments())
       }
     case ._spi, ._effects, ._objcRuntimeName, ._projectedValueProperty, ._swift_native_objc_runtime_base, ._typeEraser, ._documentation, ._optimize, ._nonSendable, .exclusivity, .inline, ._alignment:
@@ -139,7 +150,7 @@ extension Parser {
       //  - Keywords (e.g. `@_documentation(public)`)
       //
       //  Because there seem to be very little restrictions on these parameters (they could be keywords instead of identifeirs), we just allow any token.
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         if !parser.at(.rightParen) {
           return .token(parser.consumeAnyToken())
         } else {
@@ -148,96 +159,71 @@ extension Parser {
       }
     case ._objcImplementation:
       // Similar to the above but the argument is optional
-      return parseAttribute(hasRequiredArguments: false) { parser in
+      return parseAttribute(argumentMode: .optional) { parser in
         if !parser.at(.rightParen) {
           return .token(parser.consumeAnyToken())
         } else {
           return .token(parser.missingToken(.identifier))
         }
       }
     case ._cdecl, ._silgen_name:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .token(parser.consume(if: .stringLiteral) ?? parser.missingToken(.stringLiteral))
       }
     case ._implements:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .implementsArguments(parser.parseImplementsAttributeArguments())
       }
     case ._semantics:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         if let value = parser.consume(if: .stringLiteral) {
           return .token(value)
         } else {
           return .token(parser.missingToken(.stringLiteral))
         }
       }
     case ._backDeploy:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .backDeployArguments(parser.parseBackDeployArguments())
       }
     case ._expose:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .exposeAttributeArguments(parser.parseExposeArguments())
       }
     case ._originallyDefinedIn:
-      return parseAttribute(hasRequiredArguments: true) { parser in
+      return parseAttribute(argumentMode: .required) { parser in
         return .originallyDefinedInArguments(parser.parseOriginallyDefinedInArguments())
       }
     case ._unavailableFromAsync:
-      return parseAttribute(hasRequiredArguments: false) { parser in
+      return parseAttribute(argumentMode: .optional) { parser in
         return .unavailableFromAsyncArguments(parser.parseUnavailableFromAsyncArguments())
       }
-    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:
+    case .atRethrows:
       let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
-      let (unexpectedBeforeAttributeName, attributeName) = self.expectIdentifierOrRethrows()
+      let (unexpectedBeforeAttributeName, attributeName) = self.expect(.rethrowsKeyword, remapping: .identifier)
       return .attribute(
         RawAttributeSyntax(
           unexpectedBeforeAtSign,
           atSignToken: atSign,
           unexpectedBeforeAttributeName,
-          attributeName: attributeName,
+          attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: attributeName, genericArgumentClause: nil, arena: self.arena)),
           leftParen: nil,
           argument: nil,
           rightParen: nil,
           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, .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:
+      return parseAttributeWithoutArguments()
+    case nil:
+      return parseAttribute(argumentMode: .customAttribute) { parser in
+        let arguments = parser.parseArgumentListElements(pattern: .none)
+        return .argumentList(RawTupleExprElementListSyntax(elements: arguments, arena: parser.arena))
+      }
     }
   }
-
-  mutating func parseCustomAttribute() -> RawCustomAttributeSyntax {
-    let (unexpectedBeforeAtSign, atSign) = self.expect(.atSign)
-    let attrName = self.parseType()
-
-    // Custom attributes are stricter than normal attributes about their
-    // argument lists "immediately" following the attribute name.
-    guard self.lookahead().isCustomAttributeArgument(),
-      let leftParen = self.consume(if: .leftParen, where: { !$0.isAtStartOfLine })
-    else {
-      return RawCustomAttributeSyntax(
-        atSignToken: atSign,
-        attributeName: attrName,
-        leftParen: nil,
-        argumentList: nil,
-        rightParen: nil,
-        arena: self.arena
-      )
-    }
-    let arguments = self.parseArgumentListElements(pattern: .none)
-    let (unexpectedBeforeRightParen, rightParen) = self.expect(.rightParen)
-    return RawCustomAttributeSyntax(
-      unexpectedBeforeAtSign,
-      atSignToken: atSign,
-      attributeName: attrName,
-      leftParen: leftParen,
-      argumentList: RawTupleExprElementListSyntax(elements: arguments, arena: self.arena),
-      unexpectedBeforeRightParen,
-      rightParen: rightParen,
-      arena: self.arena
-    )
-  }
 }
 
 extension Parser {
@@ -253,7 +239,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSignToken: atSign,
       unexpectedBeforeDifferentiable,
-      attributeName: differentiable,
+      attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: differentiable, genericArgumentClause: nil, arena: self.arena)),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       argument: .differentiableArguments(argument),
@@ -424,7 +410,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSignToken: atSign,
       unexpectedBeforeDerivative,
-      attributeName: derivative,
+      attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: derivative, genericArgumentClause: nil, arena: self.arena)),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       argument: .derivativeRegistrationArguments(argument),
@@ -446,7 +432,7 @@ extension Parser {
       unexpectedBeforeAtSign,
       atSignToken: atSign,
       unexpectedBeforeTranspose,
-      attributeName: transpose,
+      attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: transpose, genericArgumentClause: nil, arena: self.arena)),
       unexpectedBeforeLeftParen,
       leftParen: leftParen,
       argument: .derivativeRegistrationArguments(argument),

Sources/SwiftParser/Statements.swift

@@ -837,7 +837,7 @@ extension Parser {
       unknownAttr = RawAttributeSyntax(
         atSignToken: at,
         unexpectedBeforeIdent,
-        attributeName: ident,
+        attributeName: RawTypeSyntax(RawSimpleTypeIdentifierSyntax(name: ident, genericArgumentClause: nil, arena: self.arena)),
         leftParen: nil,
         argument: nil,
         rightParen: nil,