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 parseSpecializeAttributeArgumentList() -> RawSpecializeAttributeArgumentListSyntax {
     var elements = [RawSpecializeAttributeArgumentListSyntax.Element]()
     // Parse optional "exported" and "kind" labeled parameters.
     var loopProgress = LoopProgressCondition()
-    while !self.at(.endOfFile, .rightParen, .keyword(.where)) && self.hasProgressed(&loopProgress) {
-      switch self.at(anyIn: SpecializeParameter.self) {
+    LOOP: while !self.at(.endOfFile, .rightParen, .keyword(.where)) && self.hasProgressed(&loopProgress) {
+      switch self.at(anyIn: LabeledSpecializeArgumentSyntax.LabelOptions.self) {
       case (.target, let handle)?:
-        let ident = self.eat(handle)
+        let label = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let (targetFunction, args) = self.parseDeclNameRef([.zeroArgCompoundNames, .keywordsUsingSpecialNames, .operators])
         let declName = RawDeclNameSyntax(
@@ -691,7 +657,7 @@ extension Parser {
         elements.append(
           .specializeTargetFunctionArgument(
             RawSpecializeTargetFunctionArgumentSyntax(
-              targetLabel: ident,
+              targetLabel: label,
               unexpectedBeforeColon,
               colon: colon,
               declName: declName,
@@ -701,14 +667,14 @@ extension Parser {
           )
         )
       case (.availability, let handle)?:
-        let ident = self.eat(handle)
+        let label = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let availability = self.parseAvailabilitySpecList()
         let (unexpectedBeforeSemi, semi) = self.expect(.semicolon)
         elements.append(
           .specializeAvailabilityArgument(
             RawSpecializeAvailabilityArgumentSyntax(
-              availabilityLabel: ident,
+              availabilityLabel: label,
               unexpectedBeforeColon,
               colon: colon,
               availabilityArguments: availability,
@@ -719,7 +685,7 @@ extension Parser {
           )
         )
       case (.available, let handle)?:
-        let ident = self.eat(handle)
+        let 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 +694,7 @@ extension Parser {
         elements.append(
           .labeledSpecializeArgument(
             RawLabeledSpecializeArgumentSyntax(
-              label: ident,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: available,
@@ -738,14 +704,14 @@ extension Parser {
           )
         )
       case (.exported, let handle)?:
-        let ident = self.eat(handle)
+        let 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(
           .labeledSpecializeArgument(
             RawLabeledSpecializeArgumentSyntax(
-              label: ident,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               unexpectedBeforeValue,
@@ -756,14 +722,14 @@ extension Parser {
           )
         )
       case (.kind, let handle)?:
-        let ident = self.eat(handle)
+        let label = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let valueLabel = self.parseAnyIdentifier()
         let comma = self.consume(if: .comma)
         elements.append(
           .labeledSpecializeArgument(
             RawLabeledSpecializeArgumentSyntax(
-              label: ident,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: valueLabel,
@@ -774,14 +740,14 @@ extension Parser {
         )
       case (.spiModule, let handle)?,
         (.spi, let handle)?:
-        let ident = self.eat(handle)
+        let label = self.eat(handle)
         let (unexpectedBeforeColon, colon) = self.expect(.colon)
         let valueLabel = self.consumeAnyToken()
         let comma = self.consume(if: .comma)
         elements.append(
           .labeledSpecializeArgument(
             RawLabeledSpecializeArgumentSyntax(
-              label: ident,
+              label: label,
               unexpectedBeforeColon,
               colon: colon,
               value: valueLabel,
@@ -791,22 +757,7 @@ extension Parser {
           )
         )
       case nil:
-        let ident = self.consumeAnyToken()
-        let (unexpectedBeforeColon, colon) = self.expect(.colon)
-        let valueLabel = self.consumeAnyToken()
-        let comma = self.consume(if: .comma)
-        elements.append(
-          .labeledSpecializeArgument(
-            RawLabeledSpecializeArgumentSyntax(
-              label: ident,
-              unexpectedBeforeColon,
-              colon: colon,
-              value: valueLabel,
-              trailingComma: comma,
-              arena: self.arena
-            )
-          )
-        )
+        break LOOP
       }
     }
 

Sources/SwiftParserDiagnostics/ParseDiagnosticsGenerator.swift

@@ -1226,6 +1226,25 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     return .visitChildren
   }
 
+  public override func visit(_ node: LabeledSpecializeArgumentSyntax) -> SyntaxVisitorContinueKind {
+    if shouldSkip(node) {
+      return .skipChildren
+    }
+
+    if let unexpectedIdentifier = node.unexpectedBeforeLabel?.onlyPresentToken(where: { $0.tokenKind.isIdentifier }) {
+      addDiagnostic(
+        unexpectedIdentifier,
+        UnknownParameterError(
+          parameter: unexpectedIdentifier,
+          validParameters: LabeledSpecializeArgumentSyntax.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

@@ -524,6 +524,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,19 +73,27 @@ 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"]
         ),
@@ -99,12 +107,29 @@ final class AttributeTests: XCTestCase {
   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#>