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
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
//===----------------------------------------------------------------------===//
//
// 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)
internal import SwiftSyntax
#else
import SwiftSyntax
#endif
/// Describes the relative precedence of two groups.
enum Precedence: Sendable {
case unrelated
case higherThan
case lowerThan
/// Flip the precedence order around.
var flipped: Precedence {
switch self {
case .unrelated:
return .unrelated
case .higherThan:
return .lowerThan
case .lowerThan:
return .higherThan
}
}
}
/// A graph formed from a set of precedence groups, which can be used to
/// determine the relative precedence of two precedence groups.
struct PrecedenceGraph: Sendable {
/// The known set of precedence groups, found by name.
var precedenceGroups: [PrecedenceGroupName: PrecedenceGroup] = [:]
/// Add a new precedence group
///
/// - throws: If there is already a precedence group with the given name,
/// throws PrecedenceGraphError.groupAlreadyExists.
mutating func add(
_ group: PrecedenceGroup,
errorHandler: OperatorErrorHandler = { throw $0 }
) rethrows {
if let existing = precedenceGroups[group.name] {
try errorHandler(
OperatorError.groupAlreadyExists(
existing: existing,
new: group
)
)
} else {
precedenceGroups[group.name] = group
}
}
/// Look for the precedence group with the given name, or return nil if
/// no such group is known.
func lookupGroup(_ groupName: PrecedenceGroupName) -> PrecedenceGroup? {
return precedenceGroups[groupName]
}
/// Search the precedence-group relationships, starting at the given
/// (fromGroup, fromSyntax) and following precedence groups in the
/// specified direction.
private func searchRelationships(
initialGroupName: PrecedenceGroupName,
initialSyntax: Syntax,
targetGroupName: PrecedenceGroupName,
direction: PrecedenceRelation.Kind,
errorHandler: OperatorErrorHandler
) rethrows -> Precedence? {
// Keep track of all of the groups we have seen during our exploration of
// the graph. This detects cycles and prevents extraneous work.
var groupsSeen: Set<PrecedenceGroupName> = []
var stack: [(PrecedenceGroupName, Syntax)] =
[(initialGroupName, initialSyntax)]
while let (currentGroupName, currentOperatorSyntax) = stack.popLast() {
guard let currentGroup = lookupGroup(currentGroupName) else {
try errorHandler(
.missingGroup(currentGroupName, referencedFrom: currentOperatorSyntax)
)
continue
}
for relation in currentGroup.relations {
if relation.kind == direction {
// If we hit our initial group, we're done.
let otherGroupName = relation.groupName
if otherGroupName == targetGroupName {
switch direction {
case .lowerThan:
return .lowerThan
case .higherThan:
return .higherThan
}
}
if groupsSeen.insert(otherGroupName).inserted {
let relationSyntax: Syntax
if let knownSyntax = relation.syntax {
relationSyntax = Syntax(knownSyntax)
} else {
relationSyntax =
Syntax(relation.synthesizedSyntax().precedenceGroups.first!.name)
}
stack.append((otherGroupName, relationSyntax))
}
}
}
}
return nil
}
/// Determine the precedence relationship between two precedence groups.
///
/// Follow the precedence relationships among the precedence groups to
/// determine the precedence of the start group relative to the end group.
///
/// - Returns: Precedence.lowerThan if startGroupName has lower precedence
/// than endGroupName, Precedence.higherThan if startGroupName has higher
/// precedence than endGroup name, and Precedence.unrelated otherwise.
func precedence(
relating startGroupName: PrecedenceGroupName,
to endGroupName: PrecedenceGroupName,
startSyntax: Syntax,
endSyntax: Syntax,
errorHandler: OperatorErrorHandler = { throw $0 }
) rethrows -> Precedence {
if startGroupName == endGroupName {
return .unrelated
}
// Walk all of the relationships from the end down, then from the beginning
// up, to determine whether there is a relation between the two groups.
return try searchRelationships(
initialGroupName: endGroupName,
initialSyntax: endSyntax,
targetGroupName: startGroupName,
direction: .lowerThan,
errorHandler: errorHandler
) ?? searchRelationships(
initialGroupName: startGroupName,
initialSyntax: startSyntax,
targetGroupName: endGroupName,
direction: .higherThan,
errorHandler: errorHandler
) ?? searchRelationships(
initialGroupName: startGroupName,
initialSyntax: startSyntax,
targetGroupName: endGroupName,
direction: .lowerThan,
errorHandler: errorHandler
).map {
$0.flipped
} ?? searchRelationships(
initialGroupName: endGroupName,
initialSyntax: endSyntax,
targetGroupName: startGroupName,
direction: .higherThan,
errorHandler: errorHandler
).map {
$0.flipped
} ?? .unrelated
}
}
|
