-
Notifications
You must be signed in to change notification settings - Fork 254
/
FoldingRange.swift
255 lines (230 loc) · 8.67 KB
/
FoldingRange.swift
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
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
import LSPLogging
import LanguageServerProtocol
import SwiftSyntax
fileprivate final class FoldingRangeFinder: SyntaxAnyVisitor {
private let snapshot: DocumentSnapshot
/// Some ranges might occur multiple times.
/// E.g. for `print("hi")`, `"hi"` is both the range of all call arguments and the range the first argument in the call.
/// It doesn't make sense to report them multiple times, so use a `Set` here.
private var ranges: Set<FoldingRange>
/// The client-imposed limit on the number of folding ranges it would
/// prefer to receive from the LSP server. If the value is `nil`, there
/// is no preset limit.
private var rangeLimit: Int?
/// If `true`, the client is only capable of folding entire lines. If
/// `false` the client can handle folding ranges.
private var lineFoldingOnly: Bool
init(snapshot: DocumentSnapshot, rangeLimit: Int?, lineFoldingOnly: Bool) {
self.snapshot = snapshot
self.ranges = []
self.rangeLimit = rangeLimit
self.lineFoldingOnly = lineFoldingOnly
super.init(viewMode: .sourceAccurate)
}
override func visit(_ node: TokenSyntax) -> SyntaxVisitorContinueKind {
// Index comments, so we need to see at least '/*', or '//'.
if node.leadingTriviaLength.utf8Length > 2 {
self.addTrivia(from: node, node.leadingTrivia)
}
if node.trailingTriviaLength.utf8Length > 2 {
self.addTrivia(from: node, node.trailingTrivia)
}
return .visitChildren
}
private func addTrivia(from node: TokenSyntax, _ trivia: Trivia) {
let pieces = trivia.pieces
var start = node.position
/// The index of the trivia piece we are currently inspecting.
var index = 0
while index < pieces.count {
let piece = pieces[index]
defer {
start = start.advanced(by: pieces[index].sourceLength.utf8Length)
index += 1
}
switch piece {
case .blockComment:
_ = self.addFoldingRange(
start: start,
end: start.advanced(by: piece.sourceLength.utf8Length),
kind: .comment
)
case .docBlockComment:
_ = self.addFoldingRange(
start: start,
end: start.advanced(by: piece.sourceLength.utf8Length),
kind: .comment
)
case .lineComment, .docLineComment:
let lineCommentBlockStart = start
// Keep scanning the upcoming trivia pieces to find the end of the
// block of line comments.
// As we find a new end of the block comment, we set `index` and
// `start` to `lookaheadIndex` and `lookaheadStart` resp. to
// commit the newly found end.
var lookaheadIndex = index
var lookaheadStart = start
var hasSeenNewline = false
LOOP: while lookaheadIndex < pieces.count {
let piece = pieces[lookaheadIndex]
defer {
lookaheadIndex += 1
lookaheadStart = lookaheadStart.advanced(by: piece.sourceLength.utf8Length)
}
switch piece {
case .newlines(let count), .carriageReturns(let count), .carriageReturnLineFeeds(let count):
if count > 1 || hasSeenNewline {
// More than one newline is separating the two line comment blocks.
// We have reached the end of this block of line comments.
break LOOP
}
hasSeenNewline = true
case .spaces, .tabs:
// We allow spaces and tabs because the comments might be indented
continue
case .lineComment, .docLineComment:
// We have found a new line comment in this block. Commit it.
index = lookaheadIndex
start = lookaheadStart
hasSeenNewline = false
default:
// We assume that any other trivia piece terminates the block
// of line comments.
break LOOP
}
}
_ = self.addFoldingRange(
start: lineCommentBlockStart,
end: start.advanced(by: pieces[index].sourceLength.utf8Length),
kind: .comment
)
default:
break
}
}
}
override func visitAny(_ node: Syntax) -> SyntaxVisitorContinueKind {
if let braced = node.asProtocol(BracedSyntax.self) {
return self.addFoldingRange(
start: braced.leftBrace.endPositionBeforeTrailingTrivia,
end: braced.rightBrace.positionAfterSkippingLeadingTrivia
)
}
if let parenthesized = node.asProtocol(ParenthesizedSyntax.self) {
return self.addFoldingRange(
start: parenthesized.leftParen.endPositionBeforeTrailingTrivia,
end: parenthesized.rightParen.positionAfterSkippingLeadingTrivia
)
}
return .visitChildren
}
override func visit(_ node: ArrayExprSyntax) -> SyntaxVisitorContinueKind {
return self.addFoldingRange(
start: node.leftSquare.endPositionBeforeTrailingTrivia,
end: node.rightSquare.positionAfterSkippingLeadingTrivia
)
}
override func visit(_ node: DictionaryExprSyntax) -> SyntaxVisitorContinueKind {
return self.addFoldingRange(
start: node.leftSquare.endPositionBeforeTrailingTrivia,
end: node.rightSquare.positionAfterSkippingLeadingTrivia
)
}
override func visit(_ node: FunctionCallExprSyntax) -> SyntaxVisitorContinueKind {
if let leftParen = node.leftParen, let rightParen = node.rightParen {
return self.addFoldingRange(
start: leftParen.endPositionBeforeTrailingTrivia,
end: rightParen.positionAfterSkippingLeadingTrivia
)
}
return .visitChildren
}
override func visit(_ node: SubscriptCallExprSyntax) -> SyntaxVisitorContinueKind {
return self.addFoldingRange(
start: node.leftSquare.endPositionBeforeTrailingTrivia,
end: node.rightSquare.positionAfterSkippingLeadingTrivia
)
}
override func visit(_ node: SwitchCaseSyntax) -> SyntaxVisitorContinueKind {
return self.addFoldingRange(
start: node.label.endPositionBeforeTrailingTrivia,
end: node.statements.endPosition
)
}
__consuming func finalize() -> Set<FoldingRange> {
return self.ranges
}
private func addFoldingRange(
start: AbsolutePosition,
end: AbsolutePosition,
kind: FoldingRangeKind? = nil
) -> SyntaxVisitorContinueKind {
if let limit = self.rangeLimit, self.ranges.count >= limit {
return .skipChildren
}
if start == end {
// Don't report empty ranges
return .visitChildren
}
let start = snapshot.positionOf(utf8Offset: start.utf8Offset)
let end = snapshot.positionOf(utf8Offset: end.utf8Offset)
let range: FoldingRange
if lineFoldingOnly {
// Since the client cannot fold less than a single line, if the
// fold would span 1 line there's no point in reporting it.
guard end.line > start.line else {
return .visitChildren
}
// If the client only supports folding full lines, don't report
// the end of the range since there's nothing they could do with it.
range = FoldingRange(
startLine: start.line,
startUTF16Index: nil,
endLine: end.line,
endUTF16Index: nil,
kind: kind
)
} else {
range = FoldingRange(
startLine: start.line,
startUTF16Index: start.utf16index,
endLine: end.line,
endUTF16Index: end.utf16index,
kind: kind
)
}
ranges.insert(range)
return .visitChildren
}
}
extension SwiftLanguageService {
public func foldingRange(_ req: FoldingRangeRequest) async throws -> [FoldingRange]? {
let foldingRangeCapabilities = capabilityRegistry.clientCapabilities.textDocument?.foldingRange
let snapshot = try self.documentManager.latestSnapshot(req.textDocument.uri)
let sourceFile = await syntaxTreeManager.syntaxTree(for: snapshot)
try Task.checkCancellation()
// If the limit is less than one, do nothing.
if let limit = foldingRangeCapabilities?.rangeLimit, limit <= 0 {
return []
}
let rangeFinder = FoldingRangeFinder(
snapshot: snapshot,
rangeLimit: foldingRangeCapabilities?.rangeLimit,
lineFoldingOnly: foldingRangeCapabilities?.lineFoldingOnly ?? false
)
rangeFinder.walk(sourceFile)
let ranges = rangeFinder.finalize()
return ranges.sorted()
}
}