Remove stringExpr as attribute kind

Author: ahoppen

CodeGeneration/Sources/SyntaxSupport/gyb_generated/AttributeNodes.swift

@@ -87,8 +87,6 @@ public let ATTRIBUTE_NODES: [Node] = [
                nodeChoices: [
                  Child(name: "Token",
                        kind: "Token"),
-                 Child(name: "StringExpr",
-                       kind: "StringLiteralExpr"),
                  Child(name: "Availability",
                        kind: "AvailabilitySpecList"),
                  Child(name: "SpecializeArguments",

Sources/SwiftParser/Attributes.swift

@@ -199,7 +199,11 @@ extension Parser {
       }
     case ._semantics:
       return parseAttribute(hasRequiredArguments: true) { parser in
-        return .stringExpr(parser.parseStringLiteral())
+        if let value = parser.consume(if: .stringLiteral) {
+          return .token(value)
+        } else {
+          return .token(parser.missingToken(.stringLiteral))
+        }
       }
     case ._backDeploy:
       return parseAttribute(hasRequiredArguments: true) { parser in

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxNodes.swift

@@ -10532,7 +10532,6 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
   @frozen // FIXME: Not actually stable, works around a miscompile
   public enum Argument: RawSyntaxNodeProtocol {
     case `token`(RawTokenSyntax)
-    case `stringExpr`(RawStringLiteralExprSyntax)
     case `availability`(RawAvailabilitySpecListSyntax)
     case `specializeArguments`(RawSpecializeAttributeSpecListSyntax)
     case `objCName`(RawObjCSelectorSyntax)
@@ -10548,13 +10547,12 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
     case `originallyDefinedInArguments`(RawOriginallyDefinedInArgumentsSyntax)
 
     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)
+      return RawTokenSyntax.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 {
       switch self {
       case .token(let node): return node.raw
-      case .stringExpr(let node): return node.raw
       case .availability(let node): return node.raw
       case .specializeArguments(let node): return node.raw
       case .objCName(let node): return node.raw
@@ -10576,10 +10574,6 @@ public struct RawAttributeSyntax: RawSyntaxNodeProtocol {
         self = .token(node)
         return
       }
-      if let node = RawStringLiteralExprSyntax(other) {
-        self = .stringExpr(node)
-        return
-      }
       if let node = RawAvailabilitySpecListSyntax(other) {
         self = .availability(node)
         return

Sources/SwiftSyntax/Raw/gyb_generated/RawSyntaxValidation.swift

@@ -1585,7 +1585,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

@@ -12391,7 +12391,6 @@ extension CustomAttributeSyntax: CustomReflectable {
 public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
   public enum Argument: SyntaxChildChoices {
     case `token`(TokenSyntax)
-    case `stringExpr`(StringLiteralExprSyntax)
     case `availability`(AvailabilitySpecListSyntax)
     case `specializeArguments`(SpecializeAttributeSpecListSyntax)
     case `objCName`(ObjCSelectorSyntax)
@@ -12408,7 +12407,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     public var _syntaxNode: Syntax {
       switch self {
       case .token(let node): return node._syntaxNode
-      case .stringExpr(let node): return node._syntaxNode
       case .availability(let node): return node._syntaxNode
       case .specializeArguments(let node): return node._syntaxNode
       case .objCName(let node): return node._syntaxNode
@@ -12428,9 +12426,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     public init(_ node: TokenSyntax) {
       self = .token(node)
     }
-    public init(_ node: StringLiteralExprSyntax) {
-      self = .stringExpr(node)
-    }
     public init(_ node: AvailabilitySpecListSyntax) {
       self = .availability(node)
     }
@@ -12475,10 +12470,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
         self = .token(node)
         return
       }
-      if let node = node.as(StringLiteralExprSyntax.self) {
-        self = .stringExpr(node)
-        return
-      }
       if let node = node.as(AvailabilitySpecListSyntax.self) {
         self = .availability(node)
         return
@@ -12537,7 +12528,6 @@ public struct AttributeSyntax: SyntaxProtocol, SyntaxHashable {
     public static var structure: SyntaxNodeStructure {
       return .choices([
         .node(TokenSyntax.self),
-        .node(StringLiteralExprSyntax.self),
         .node(AvailabilitySpecListSyntax.self),
         .node(SpecializeAttributeSpecListSyntax.self),
         .node(ObjCSelectorSyntax.self),

Tests/SwiftParserTest/DeclarationTests.swift

@@ -1334,6 +1334,16 @@ final class DeclarationTests: XCTestCase {
       ]
     )
   }
+
+  func testFoo() {
+    AssertParse(
+      """
+      struct Properties {
+        class private(set) var privateSetterCustomNames: Bool
+      }
+      """
+    )
+  }
 }
 
 extension Parser.DeclAttributes {

gyb_syntax_support/AttributeNodes.py

@@ -56,7 +56,6 @@
              Child('Argument', kind='Syntax', is_optional=True,
                    node_choices=[
                        Child('Token', kind='Token'),
-                       Child('StringExpr', kind='StringLiteralExpr'),
                        Child('Availability', kind='AvailabilitySpecList'),
                        Child('SpecializeArguments',
                              kind='SpecializeAttributeSpecList'),