Allow leading dot syntax for StaticParserError

Convert StaticParserError into a struct, and
define the diagnostics in a
`DiagnosticMessage where Self == StaticParserError`
extension. This allows us to use leading dot syntax
to pass a StaticParserError anywhere a DiagnosticMessage
is expected.

To compute the diagnostic ID, we can (ab)use
`#function` to pick up the name of the property.

Author: hamishknight

Sources/SwiftParser/Diagnostics/ParseDiagnosticsGenerator.swift

@@ -65,27 +65,6 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     self.handledNodes.append(contentsOf: handledNodes)
   }
 
-  /// Produce a diagnostic.
-  func addDiagnostic<T: SyntaxProtocol>(
-    _ node: T,
-    position: AbsolutePosition? = nil,
-    _ message: StaticParserError,
-    highlights: [Syntax] = [],
-    notes: [Note] = [],
-    fixIts: [FixIt] = [],
-    handledNodes: [SyntaxIdentifier] = []
-  ) {
-    addDiagnostic(
-      node,
-      position: position,
-      message as DiagnosticMessage,
-      highlights: highlights,
-      notes: notes,
-      fixIts: fixIts,
-      handledNodes: handledNodes
-    )
-  }
-
   /// Whether the node should be skipped for diagnostic emission.
   /// Every visit method must check this at the beginning.
   func shouldSkip<T: SyntaxProtocol>(_ node: T) -> Bool {
@@ -99,11 +78,11 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
   ///
   /// If `incorrectContainer` contains only tokens that satisfy `unexpectedTokenCondition`, emit a diagnostic with message `message` that marks this token as misplaced.
   /// If `correctTokens` contains missing tokens, also emit a Fix-It with message `fixIt` that marks the unexpected token as missing and instead inserts `correctTokens`.
-  public func exchangeTokens(
+  public func exchangeTokens<Message: DiagnosticMessage>(
     unexpected: UnexpectedNodesSyntax?,
     unexpectedTokenCondition: (TokenSyntax) -> Bool,
     correctTokens: [TokenSyntax?],
-    message: (_ misplacedTokens: [TokenSyntax]) -> DiagnosticMessage,
+    message: (_ misplacedTokens: [TokenSyntax]) -> Message,
     moveFixIt: (_ misplacedTokens: [TokenSyntax]) -> FixItMessage,
     removeRedundantFixIt: (_ misplacedTokens: [TokenSyntax]) -> FixItMessage? = { _ in nil }
   ) {
@@ -147,10 +126,10 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
 
   /// If `unexpected` only contains a single token that satisfies `predicate`,
   /// emits a diagnostic with `message` that removes this token.
-  public func removeToken(
+  public func removeToken<Message: DiagnosticMessage>(
     _ unexpected: UnexpectedNodesSyntax?,
     where predicate: (TokenSyntax) -> Bool,
-    message: (TokenSyntax) -> DiagnosticMessage
+    message: (TokenSyntax) -> Message
   ) {
     guard let unexpected = unexpected,
           let misplacedToken = unexpected.onlyToken(where: predicate)
@@ -486,7 +465,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       unexpected: node.output?.unexpectedBetweenArrowAndReturnType,
       unexpectedTokenCondition: { $0.tokenKind == .throwsKeyword },
       correctTokens: [node.throwsOrRethrowsKeyword],
-      message: { _ in StaticParserError.throwsInReturnPosition },
+      message: { _ in .throwsInReturnPosition },
       moveFixIt: { MoveTokensInFrontOfFixIt(movedTokens: $0, inFrontOf: .arrow) }
     )
     return .visitChildren
@@ -538,7 +517,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
         unexpected: node.unexpectedBeforeReturnKeyword,
         unexpectedTokenCondition: { $0.tokenKind == .tryKeyword },
         correctTokens: [node.expression?.as(TryExprSyntax.self)?.tryKeyword],
-        message: { _ in StaticParserError.tryMustBePlacedOnReturnedExpr },
+        message: { _ in .tryMustBePlacedOnReturnedExpr },
         moveFixIt: { MoveTokensAfterFixIt(movedTokens: $0, after: .returnKeyword) }
       )
     }
@@ -577,7 +556,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       unexpected: node.unexpectedBeforeThrowKeyword,
       unexpectedTokenCondition: { $0.tokenKind == .tryKeyword },
       correctTokens: [node.expression.as(TryExprSyntax.self)?.tryKeyword],
-      message: { _ in StaticParserError.tryMustBePlacedOnThrownExpr },
+      message: { _ in .tryMustBePlacedOnThrownExpr },
       moveFixIt: { MoveTokensAfterFixIt(movedTokens: $0, after: .throwKeyword) }
     )
     return .visitChildren
@@ -647,7 +626,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
     removeToken(
       node.unexpectedBetweenIdentifierAndInheritanceClause,
       where: { $0.tokenKind == .ellipsis },
-      message: { _ in StaticParserError.associatedTypeCannotUsePack }
+      message: { _ in .associatedTypeCannotUsePack }
     )
     return .visitChildren
   }
@@ -663,7 +642,7 @@ public class ParseDiagnosticsGenerator: SyntaxAnyVisitor {
       unexpected: node.unexpectedBetweenModifiersAndLetOrVarKeyword,
       unexpectedTokenCondition: { $0.tokenKind == .tryKeyword },
       correctTokens: missingTries,
-      message: { _ in StaticParserError.tryOnInitialValueExpression },
+      message: { _ in .tryOnInitialValueExpression },
       moveFixIt: { MoveTokensAfterFixIt(movedTokens: $0, after: .equal) },
       removeRedundantFixIt: { RemoveRedundantFixIt(removeTokens: $0) }
     )

Sources/SwiftParser/Diagnostics/ParserDiagnosticMessages.swift

@@ -64,38 +64,90 @@ public extension ParserFixIt {
 
 // MARK: - Errors (please sort alphabetically)
 
-/// Please order the cases in this enum alphabetically by case name.
-public enum StaticParserError: String, DiagnosticMessage {
-  case allStatmentsInSwitchMustBeCoveredByCase = "all statements inside a switch must be covered by a 'case' or 'default' label"
-  case caseOutsideOfSwitchOrEnum = "'case' can only appear inside a 'switch' statement or 'enum' declaration"
-  case consecutiveDeclarationsOnSameLine = "consecutive declarations on a line must be separated by ';'"
-  case consecutiveStatementsOnSameLine = "consecutive statements on a line must be separated by ';'"
-  case cStyleForLoop = "C-style for statement has been removed in Swift 3"
-  case defaultCannotBeUsedWithWhere = "'default' cannot be used with a 'where' guard expression"
-  case defaultOutsideOfSwitch = "'default' label can only appear inside a 'switch' statement"
-  case editorPlaceholderInSourceFile = "editor placeholder in source file"
-  case expectedExpressionAfterTry = "expected expression after 'try'"
-  case invalidFlagAfterPrecedenceGroupAssignment = "expected 'true' or 'false' after 'assignment'"
-  case missingColonInTernaryExprDiagnostic = "expected ':' after '? ...' in ternary expression"
-  case operatorShouldBeDeclaredWithoutBody = "operator should not be declared with body"
-  case standaloneSemicolonStatement = "standalone ';' statements are not allowed"
-  case subscriptsCannotHaveNames = "subscripts cannot have a name"
-  case throwsInReturnPosition = "'throws' may only occur before '->'"
-  case tryMustBePlacedOnReturnedExpr = "'try' must be placed on the returned expression"
-  case tryMustBePlacedOnThrownExpr = "'try' must be placed on the thrown expression"
-  case tryOnInitialValueExpression = "'try' must be placed on the initial value expression"
-  case unexpectedSemicolon = "unexpected ';' separator"
-  case associatedTypeCannotUsePack = "associated types cannot be variadic"
-
-  public var message: String { self.rawValue }
+/// A parser error with a static message.
+public struct StaticParserError: DiagnosticMessage {
+  public let message: String
+  private let messageID: String
+
+  /// This should only be called within a static var on DiagnosticMessage, such
+  /// as the examples below. This allows us to pick up the messageID from the
+  /// var name.
+  fileprivate init(_ message: String, messageID: String = #function) {
+    self.message = message
+    self.messageID = messageID
+  }
 
   public var diagnosticID: MessageID {
-    MessageID(domain: diagnosticDomain, id: "\(type(of: self)).\(self)")
+    MessageID(domain: diagnosticDomain, id: "\(type(of: self)).\(messageID)")
   }
 
   public var severity: DiagnosticSeverity { .error }
 }
 
+extension DiagnosticMessage where Self == StaticParserError {
+  /// Please order the diagnostics alphabetically by property name.
+  public static var allStatmentsInSwitchMustBeCoveredByCase: Self {
+    .init("all statements inside a switch must be covered by a 'case' or 'default' label")
+  }
+  public static var associatedTypeCannotUsePack: Self {
+    .init("associated types cannot be variadic")
+  }
+  public static var caseOutsideOfSwitchOrEnum: Self {
+    .init("'case' can only appear inside a 'switch' statement or 'enum' declaration")
+  }
+  public static var consecutiveDeclarationsOnSameLine: Self {
+    .init("consecutive declarations on a line must be separated by ';'")
+  }
+  public static var consecutiveStatementsOnSameLine: Self {
+    .init("consecutive statements on a line must be separated by ';'")
+  }
+  public static var cStyleForLoop: Self {
+    .init("C-style for statement has been removed in Swift 3")
+  }
+  public static var defaultCannotBeUsedWithWhere: Self {
+    .init("'default' cannot be used with a 'where' guard expression")
+  }
+  public static var defaultOutsideOfSwitch: Self {
+    .init("'default' label can only appear inside a 'switch' statement")
+  }
+  public static var editorPlaceholderInSourceFile: Self {
+    .init("editor placeholder in source file")
+  }
+  public static var expectedExpressionAfterTry: Self {
+    .init("expected expression after 'try'")
+  }
+  public static var invalidFlagAfterPrecedenceGroupAssignment: Self {
+    .init("expected 'true' or 'false' after 'assignment'")
+  }
+  public static var missingColonInTernaryExprDiagnostic: Self {
+    .init("expected ':' after '? ...' in ternary expression")
+  }
+  public static var operatorShouldBeDeclaredWithoutBody: Self {
+    .init("operator should not be declared with body")
+  }
+  public static var standaloneSemicolonStatement: Self {
+    .init("standalone ';' statements are not allowed")
+  }
+  public static var subscriptsCannotHaveNames: Self {
+    .init("subscripts cannot have a name")
+  }
+  public static var throwsInReturnPosition: Self {
+    .init("'throws' may only occur before '->'")
+  }
+  public static var tryMustBePlacedOnReturnedExpr: Self {
+    .init("'try' must be placed on the returned expression")
+  }
+  public static var tryMustBePlacedOnThrownExpr: Self {
+    .init("'try' must be placed on the thrown expression")
+  }
+  public static var tryOnInitialValueExpression: Self {
+    .init("'try' must be placed on the initial value expression")
+  }
+  public static var unexpectedSemicolon: Self {
+    .init("unexpected ';' separator")
+  }
+}
+
 // MARK: - Diagnostics (please sort alphabetically)
 
 public struct EffectsSpecifierAfterArrow: ParserError {