Add diagnostic for wrong LabeledSpecializeEntry label

Author: kimdv

Sources/SwiftParser/Attributes.swift

@@ -638,48 +638,14 @@ extension Parser {
 }
 
 extension Parser {
-  enum SpecializeParameter: TokenSpecSet {
-    case target
-    case availability
-    case exported
-    case kind
-    case spi
-    case spiModule
-    case available
-
-    init?(lexeme: Lexer.Lexeme) {
-      switch PrepareForKeywordMatch(lexeme) {
-      case TokenSpec(.target): self = .target
-      case TokenSpec(.availability): self = .availability
-      case TokenSpec(.exported): self = .exported
-      case TokenSpec(.kind): self = .kind
-      case TokenSpec(.spi): self = .spi
-      case TokenSpec(.spiModule): self = .spiModule
-      case TokenSpec(.available): self = .available
-      default: return nil
-      }
-    }
-
-    var spec: TokenSpec {
-      switch self {
-      case .target: return .keyword(.target)
-      case .availability: return .keyword(.availability)
-      case .exported: return .keyword(.exported)
-      case .kind: return .keyword(.kind)
-      case .spi: return .keyword(.spi)
-      case .spiModule: return .keyword(.spiModule)
-      case .available: return .keyword(.available)
-      }
-    }
-  }
   mutating func parseSpecializeAttributeSpecList() -> RawSpecializeAttributeSpecListSyntax {
     var elements = [RawSpecializeAttributeSpecListSyntax.Element]()
     // Parse optional "exported" and "kind" labeled parameters.
     var loopProgress = LoopProgressCondition()
     while !self.at(.eof, .rightParen, .keyword(.where)) && loopProgress.evaluate(currentToken) {
-      switch self.at(anyIn: SpecializeParameter.self) {
+      switch self.canRecoverTo(anyIn: LabeledSpecializeEntrySyntax.LabelOptions.self) {
       case (.target, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let (targetFunction, args) = self.parseDeclNameRef([.zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators])
         let declName = RawDeclNameSyntax(
@@ -691,7 +657,8 @@ extension Parser {
         elements.append(
           .targetFunctionEntry(
             RawTargetFunctionEntrySyntax(
-              targetLabel: ident,
+              unexpectedBeforeLabel,
+              targetLabel: label,
               unexpectedBeforeColon,
               colon: colon,
               declname: declName,
@@ -701,7 +668,7 @@ extension Parser {
           )
         )
       case (.availability, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let availability = self.parseAvailabilitySpecList()
         let (unexpectedBeforeSemi, semi) = self.expect(.semicolon)
@@ -719,7 +686,7 @@ extension Parser {
           )
         )
       case (.available, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         // FIXME: I have no idea what this is supposed to be, but the Syntax
         // tree only allows us to insert a token so we'll take anything.
@@ -728,7 +695,8 @@ extension Parser {
         elements.append(
           .labeledSpecializeEntry(
             RawLabeledSpecializeEntrySyntax(
-              label: ident,
+              unexpectedBeforeLabel,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: available,
@@ -738,14 +706,15 @@ extension Parser {
           )
         )
       case (.exported, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let (unexpectedBeforeValue, value) = self.expect(.keyword(.true), .keyword(.false), default: .keyword(.false))
         let comma = self.consume(if: .comma)
         elements.append(
           .labeledSpecializeEntry(
             RawLabeledSpecializeEntrySyntax(
-              label: ident,
+              unexpectedBeforeLabel,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               unexpectedBeforeValue,
@@ -756,14 +725,15 @@ extension Parser {
           )
         )
       case (.kind, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let valueLabel = self.parseAnyIdentifier()
         let comma = self.consume(if: .comma)
         elements.append(
           .labeledSpecializeEntry(
             RawLabeledSpecializeEntrySyntax(
-              label: ident,
+              unexpectedBeforeLabel,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: valueLabel,
@@ -774,14 +744,15 @@ extension Parser {
         )
       case (.spiModule, let handle)?,
         (.spi, let handle)?:
-        let ident = self.eat(handle)
+        let (unexpectedBeforeLabel, label) = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let valueLabel = self.consumeAnyToken()
         let comma = self.consume(if: .comma)
         elements.append(
           .labeledSpecializeEntry(
             RawLabeledSpecializeEntrySyntax(
-              label: ident,
+              unexpectedBeforeLabel,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: valueLabel,
@@ -798,7 +769,8 @@ extension Parser {
         elements.append(
           .labeledSpecializeEntry(
             RawLabeledSpecializeEntrySyntax(
-              label: ident,
+              RawUnexpectedNodesSyntax([ident], arena: self.arena),
+              label: RawTokenSyntax(missing: .identifier, arena: self.arena),
               unexpectedBeforeColon,
               colon: colon,
               value: valueLabel,

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1226,6 +1226,25 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: LabeledSpecializeEntrySyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let unexpectedIdentifier = node.unexpectedBeforeLabel?.onlyPresentToken(where: { $0.tokenKind.isIdentifier }) {
+      addDiagnostic(
+        unexpectedIdentifier,
+        UnknownParameterError(
+          parameter: unexpectedIdentifier,
+          validParameters: LabeledSpecializeEntrySyntax.LabelOptions.allCases.map { $0.tokenSyntax }
+        ),
+        handledNodes: [unexpectedIdentifier.id, node.label.id]
+      )
+    }
+
+    return .visitChildren
+  }
+
   public override func visit(_ node: MacroExpansionDeclSyntax) -> SyntaxVisitorContinueKind {
     if shouldSkip(node) {
       return .skipChildren

Sources/SwiftParserDiagnostics/ParserDiagnosticMessages.swift

@@ -518,6 +518,23 @@ public struct UnknownDirectiveError: ParserError {
   }
 }
 
+public struct UnknownParameterError: ParserError {
+  public let parameter: TokenSyntax
+  public let validParameters: [TokenSyntax]
+
+  public var message: String {
+    var message = "unknown parameter '\(parameter.text)'"
+
+    if let parentTypeName = parameter.parent?.ancestorOrSelf(mapping: { $0.nodeTypeNameForDiagnostics(allowBlockNames: false) }) {
+      message += " in \(parentTypeName)"
+    }
+
+    message += "; valid parameters are \(nodesDescription(validParameters, format: true))"
+
+    return message
+  }
+}
+
 // MARK: - Notes (please sort alphabetically)
 
 public struct EffectSpecifierDeclaredHere: ParserNote {

Tests/SwiftParserTest/AttributeTests.swift

@@ -73,41 +73,66 @@ final class AttributeTests: XCTestCase {
   func testMissingClosingParenToAttribute() {
     assertParse(
       """
-      @_specializeℹ️(e1️⃣
+      @_specializeℹ️(1️⃣e2️⃣
       """,
       diagnostics: [
         DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message:
+            "unknown parameter 'e' in attribute argument; valid parameters are 'target', 'availability', 'exported', 'kind', 'spi', 'spiModule', and 'available'"
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
           message: "expected ':' in attribute argument",
           fixIts: ["insert ':'"]
         ),
         DiagnosticSpec(
+          locationMarker: "2️⃣",
           message: "expected ')' to end attribute",
           notes: [NoteSpec(message: "to match this opening '('")],
           fixIts: ["insert ')'"]
         ),
         DiagnosticSpec(
+          locationMarker: "2️⃣",
           message: "expected declaration after attribute",
           fixIts: ["insert declaration"]
         ),
       ],
       fixedSource: """
-        @_specialize(e:) <#declaration#>
+        @_specialize(e  <#identifier#>:) <#declaration#>
         """
     )
   }
 
   func testMultipleInvalidSpecializeParams() {
     assertParse(
       """
-      @_specialize(e1️⃣, exported2️⃣)3️⃣
+      @_specialize(1️⃣e2️⃣, exported3️⃣)4️⃣
       """,
       diagnostics: [
-        DiagnosticSpec(locationMarker: "1️⃣", message: "expected ':' in attribute argument", fixIts: ["insert ':'"]),
-        DiagnosticSpec(locationMarker: "2️⃣", message: "expected ': false' in attribute argument", fixIts: ["insert ': false'"]),
-        DiagnosticSpec(locationMarker: "3️⃣", message: "expected declaration after attribute", fixIts: ["insert declaration"]),
+        DiagnosticSpec(
+          locationMarker: "1️⃣",
+          message:
+            "unknown parameter 'e' in attribute argument; valid parameters are 'target', 'availability', 'exported', 'kind', 'spi', 'spiModule', and 'available'"
+        ),
+        DiagnosticSpec(
+          locationMarker: "2️⃣",
+          message: "expected ':' in attribute argument",
+          fixIts: ["insert ':'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "3️⃣",
+          message: "expected ': false' in attribute argument",
+          fixIts: ["insert ': false'"]
+        ),
+        DiagnosticSpec(
+          locationMarker: "4️⃣",
+          message: "expected declaration after attribute",
+          fixIts: ["insert declaration"]
+        ),
       ],
       fixedSource: """
-        @_specialize(e:, exported: false)  <#declaration#>
+        @_specialize(e  <#identifier#>:, exported: false)  <#declaration#>
         """
     )
   }