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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2024 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 LanguageServerProtocol
import SwiftRefactor
import SwiftSyntax
/// Protocol that adapts a SyntaxRefactoringProvider (that comes from
/// swift-syntax) into a SyntaxCodeActionProvider.
protocol SyntaxRefactoringCodeActionProvider: SyntaxCodeActionProvider, EditRefactoringProvider {
static var title: String { get }
/// Returns the node that the syntax refactoring should be performed on, if code actions are requested for the given
/// scope.
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input?
}
/// SyntaxCodeActionProviders with a \c Void context can automatically be
/// adapted provide a code action based on their refactoring operation.
extension SyntaxRefactoringCodeActionProvider where Self.Context == Void {
static func codeActions(in scope: SyntaxCodeActionScope) -> [CodeAction] {
guard let node = nodeToRefactor(in: scope) else {
return []
}
let sourceEdits = Self.textRefactor(syntax: node)
let textEdits = sourceEdits.compactMap { (edit) -> TextEdit? in
let edit = TextEdit(
range: scope.snapshot.range(of: edit.range),
newText: edit.replacement
)
if edit.isNoOp(in: scope.snapshot) {
return nil
}
return edit
}
if textEdits.isEmpty {
return []
}
return [
CodeAction(
title: Self.title,
kind: .refactorInline,
edit: WorkspaceEdit(changes: [scope.snapshot.uri: textEdits])
)
]
}
}
// Adapters for specific refactoring provides in swift-syntax.
extension AddSeparatorsToIntegerLiteral: SyntaxRefactoringCodeActionProvider {
public static var title: String { "Add digit separators" }
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input? {
return scope.innermostNodeContainingRange?.findParentOfSelf(
ofType: IntegerLiteralExprSyntax.self,
stoppingIf: { $0.is(CodeBlockSyntax.self) || $0.is(MemberBlockSyntax.self) }
)
}
}
extension FormatRawStringLiteral: SyntaxRefactoringCodeActionProvider {
public static var title: String {
"Convert string literal to minimal number of '#'s"
}
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input? {
return scope.innermostNodeContainingRange?.findParentOfSelf(
ofType: StringLiteralExprSyntax.self,
stoppingIf: {
$0.is(CodeBlockSyntax.self) || $0.is(MemberBlockSyntax.self)
|| $0.keyPathInParent == \ExpressionSegmentSyntax.expressions
}
)
}
}
extension MigrateToNewIfLetSyntax: SyntaxRefactoringCodeActionProvider {
public static var title: String { "Migrate to shorthand 'if let' syntax" }
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input? {
return scope.innermostNodeContainingRange?.findParentOfSelf(
ofType: IfExprSyntax.self,
stoppingIf: { $0.is(CodeBlockSyntax.self) || $0.is(MemberBlockSyntax.self) }
)
}
}
extension OpaqueParameterToGeneric: SyntaxRefactoringCodeActionProvider {
public static var title: String { "Expand 'some' parameters to generic parameters" }
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input? {
return scope.innermostNodeContainingRange?.findParentOfSelf(
ofType: DeclSyntax.self,
stoppingIf: { $0.is(CodeBlockSyntax.self) || $0.is(MemberBlockSyntax.self) }
)
}
}
extension RemoveSeparatorsFromIntegerLiteral: SyntaxRefactoringCodeActionProvider {
public static var title: String { "Remove digit separators" }
static func nodeToRefactor(in scope: SyntaxCodeActionScope) -> Input? {
return scope.innermostNodeContainingRange?.findParentOfSelf(
ofType: IntegerLiteralExprSyntax.self,
stoppingIf: { $0.is(CodeBlockSyntax.self) || $0.is(MemberBlockSyntax.self) }
)
}
}
extension SyntaxProtocol {
/// Finds the innermost parent of the given type while not walking outside of nodes that satisfy `stoppingIf`.
func findParentOfSelf<ParentType: SyntaxProtocol>(
ofType: ParentType.Type,
stoppingIf: (Syntax) -> Bool
) -> ParentType? {
var node: Syntax? = Syntax(self)
while let unwrappedNode = node, !stoppingIf(unwrappedNode) {
if let expectedType = unwrappedNode.as(ParentType.self) {
return expectedType
}
node = unwrappedNode.parent
}
return nil
}
}
|
