Make sure we're only parsing subscript and deinit as keywords within attributes

Author: DougGregor

Sources/SwiftParser/Attributes.swift

@@ -376,7 +376,7 @@ extension Parser {
       trailingComma: roleTrailingComma,
       arena: self.arena
     )
-    let additionalArgs = self.parseArgumentListElements(pattern: .none, flavor: .attributeArgument)
+    let additionalArgs = self.parseArgumentListElements(pattern: .none, flavor: .attributeArguments)
     return [roleElement] + additionalArgs
   }
 }

Sources/SwiftParser/Expressions.swift

@@ -79,9 +79,9 @@ extension Parser {
     /// We don't allow allow newlines here.
     case poundIfDirective
 
-    /// Parsing an attribute argument, which can contain declaration references
-    /// like `subscript` or `deinit`.
-    case attributeArgument
+    /// Parsing an attribute's arguments, which can contain declaration
+    /// references like `subscript` or `deinit`.
+    case attributeArguments
   }
 
   enum PatternContext {
@@ -1245,7 +1245,7 @@ extension Parser {
     var options: DeclNameOptions = .compoundNames
     switch flavor {
     case .basic, .poundIfDirective, .stmtCondition: break
-    case .attributeArgument: options.insert(.keywords)
+    case .attributeArguments: options.insert(.keywordsUsingSpecialNames)
     }
 
     let declName = self.parseDeclReferenceExpr(options)
@@ -2565,7 +2565,7 @@ private extension Parser.ExprFlavor {
   var callArgumentFlavor: Parser.ExprFlavor {
     switch self {
     case .basic, .poundIfDirective, .stmtCondition: return .basic
-    case .attributeArgument: return .attributeArgument
+    case .attributeArguments: return .attributeArguments
     }
   }
 }

Sources/SwiftParser/Names.swift

@@ -71,7 +71,8 @@ extension Parser {
     } else if flags.contains(.operators), let (_, _) = self.at(anyIn: Operator.self) {
       base = self.consumeAnyToken(remapping: .binaryOperator)
     } else if flags.contains(.keywordsUsingSpecialNames),
-              let special = self.consume(if: .keyword(.`deinit`), .keyword(.`subscript`)) {
+      let special = self.consume(if: .keyword(.`deinit`), .keyword(.`subscript`))
+    {
       base = special
     } else if flags.contains(.keywords) && self.currentToken.isLexerClassifiedKeyword {
       base = self.consumeAnyToken(remapping: .identifier)

Tests/SwiftParserTest/AttributeTests.swift

@@ -692,72 +692,182 @@ final class AttributeTests: ParserTestCase {
   func testMacroRoleNames() {
     assertParse(
       """
-      @attached(member, names: named(deinit))
+      @attached(member, names: named(1️⃣deinit))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`deinit`)),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @attached(member, names: named(init))
+      @attached(member, names: named(1️⃣init))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`init`)),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @attached(member, names: named(init(a:b:)))
+      @attached(member, names: named(1️⃣init(a:b:)))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(
+        baseName: .keyword(.`init`),
+        argumentNames: DeclNameArgumentsSyntax(
+          arguments: [
+            DeclNameArgumentSyntax(name: .identifier("a")),
+            DeclNameArgumentSyntax(name: .identifier("b")),
+          ]
+        )
+      ),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @attached(member, names: named(subscript))
+      @attached(member, names: named(1️⃣subscript))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`subscript`)),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @attached(declaration, names: named(subscript(a:b:)))
+      @attached(declaration, names: named(1️⃣subscript(a:b:)))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(
+        baseName: .keyword(.`subscript`),
+        argumentNames: DeclNameArgumentsSyntax(
+          arguments: [
+            DeclNameArgumentSyntax(name: .identifier("a")),
+            DeclNameArgumentSyntax(name: .identifier("b")),
+          ]
+        )
+      ),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @freestanding(declaration, names: named(deinit))
+      @freestanding(declaration, names: named(1️⃣deinit))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`deinit`)),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @freestanding(declaration, names: named(init))
+      @freestanding(declaration, names: named(1️⃣init))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`init`)),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @freestanding(declaration, names: named(init(a:b:)))
+      @freestanding(declaration, names: named(1️⃣init(a:b:)))
       macro m()
-      """
+      """,
+      substructure: DeclReferenceExprSyntax(
+        baseName: .keyword(.`init`),
+        argumentNames: DeclNameArgumentsSyntax(
+          arguments: [
+            DeclNameArgumentSyntax(name: .identifier("a")),
+            DeclNameArgumentSyntax(name: .identifier("b")),
+          ]
+        )
+      ),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @freestanding(member, names: named(subscript))
+      @freestanding(member, names: named(1️⃣subscript))
       macro m()
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .keyword(.`subscript`)),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    assertParse(
       """
+      @freestanding(member, names: named(1️⃣subscript(a:b:)))
+      macro m()
+      """,
+      substructure: DeclReferenceExprSyntax(
+        baseName: .keyword(.`subscript`),
+        argumentNames: DeclNameArgumentsSyntax(
+          arguments: [
+            DeclNameArgumentSyntax(name: .identifier("a")),
+            DeclNameArgumentSyntax(name: .identifier("b")),
+          ]
+        )
+      ),
+      substructureAfterMarker: "1️⃣"
     )
 
     assertParse(
       """
-      @freestanding(member, names: named(subscript(a:b:)))
+      @attached(member, names: named(1️⃣`class`))
       macro m()
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .identifier("`class`")),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    assertParse(
       """
+      @attached4️⃣(member, names: named(1️⃣class2️⃣))
+      macro m()3️⃣
+      """,
+      diagnostics: [
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected value and ')' to end function call",
+          fixIts: ["insert value and ')'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message: "expected ')' to end attribute",
+          notes: [
+            NoteSpec(
+              locationMarker: "4️⃣",
+              message: "to match this opening '('"
+            )
+          ],
+          fixIts: ["insert ')'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected identifier in class",
+          fixIts: ["insert identifier"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected '{' in class",
+          fixIts: ["insert '{'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "unexpected code '))' before macro"
+        ),
+        DiagnosticSpec(
+          locationMarker: "3️⃣",
+          message: "expected '}' to end class",
+          fixIts: ["insert '}'"]
+        ),
+      ],
+      fixedSource: """
+        @attached(member, names: named(<#expression#>)) class <#identifier#> {))
+        macro m()
+        }
+        """
     )
   }
 

Tests/SwiftParserTest/ExpressionTests.swift

@@ -3005,5 +3005,21 @@ final class StatementExpressionTests: ParserTestCase {
       """,
       substructure: DeclReferenceExprSyntax(baseName: .identifier("subscript"))
     )
+
+    assertParse(
+      """
+      x.1️⃣deinit
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .identifier("deinit")),
+      substructureAfterMarker: "1️⃣"
+    )
+
+    assertParse(
+      """
+      x.1️⃣subscript
+      """,
+      substructure: DeclReferenceExprSyntax(baseName: .identifier("subscript")),
+      substructureAfterMarker: "1️⃣"
+    )
   }
 }