1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#if swift(>=6)
public import SwiftDiagnostics
internal import SwiftParser
internal import SwiftSyntax
#else
import SwiftDiagnostics
import SwiftParser
import SwiftSyntax
#endif
extension OperatorError: DiagnosticMessage {
public var severity: DiagnosticSeverity {
.error
}
public var message: String {
switch self {
case .groupAlreadyExists(let existing, _):
return "redefinition of precedence group '\(existing.name)'"
case .missingGroup(let groupName, _):
return "unknown precedence group '\(groupName)'"
case .operatorAlreadyExists(let existing, _):
return "redefinition of \(existing.kind) operator '\(existing.name)'"
case .missingOperator(let operatorName, _):
return "unknown infix operator '\(operatorName)'"
case .incomparableOperators(_, let leftGroup, _, let rightGroup):
if leftGroup == rightGroup {
return "adjacent operators are in non-associative precedence group '\(leftGroup)'"
}
return "adjacent operators are in unordered precedence groups '\(leftGroup)' and '\(rightGroup)'"
}
}
public var diagnosticID: MessageID {
MessageID(domain: "SwiftOperators", id: "\(self)")
}
}
extension OperatorError {
/// Produce the syntax node at which a diagnostic should be displayed.
var diagnosticDisplayNode: Syntax {
switch self {
case .incomparableOperators(let leftOperator, _, _, _):
return Syntax(leftOperator)
case .missingOperator(_, let node):
return node
case .operatorAlreadyExists(_, let newOperator):
return Syntax(newOperator.syntax ?? newOperator.synthesizedSyntax())
case .missingGroup(_, let node):
return node
case .groupAlreadyExists(_, let newGroup):
return Syntax(newGroup.syntax ?? newGroup.synthesizedSyntax())
}
}
/// Produce a diagnostic for a given operator-precedence error.
public var asDiagnostic: Diagnostic {
.init(node: diagnosticDisplayNode, message: self)
}
}
|
