Skip to content

Commit d7e2ccb

Browse files
ahoppenahoppen
committed
Deprecate SyntaxFactory
Instead of always writing `SyntaxFactory.make*` we can just use the initializers of the nodes that should be created, which leads to a lot nicer code IMO. rdar://97910890
1 parent f91b0d4 commit d7e2ccb

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

49 files changed

+9584
-4795
lines changed

‎Package.swift

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -54,21 +54,22 @@ let package = Package(
5454
name: "SwiftSyntax",
5555
dependencies: ["_CSwiftSyntax"],
5656
exclude: [
57-
"SyntaxFactory.swift.gyb",
58-
"SyntaxTraits.swift.gyb",
59-
"Trivia.swift.gyb",
6057
"Misc.swift.gyb",
61-
"SyntaxRewriter.swift.gyb",
62-
"SyntaxEnum.swift.gyb",
63-
"SyntaxClassification.swift.gyb",
58+
"SyntaxAnyVisitor.swift.gyb",
59+
"SyntaxBaseNodes.swift.gyb",
6460
"SyntaxBuilders.swift.gyb",
65-
"TokenKind.swift.gyb",
66-
"SyntaxVisitor.swift.gyb",
61+
"SyntaxClassification.swift.gyb",
6762
"SyntaxCollections.swift.gyb",
68-
"SyntaxBaseNodes.swift.gyb",
69-
"SyntaxAnyVisitor.swift.gyb",
70-
"SyntaxNodes.swift.gyb.template",
63+
"SyntaxEnum.swift.gyb",
64+
"SyntaxFactory.swift.gyb",
7165
"SyntaxKind.swift.gyb",
66+
"SyntaxNodes.swift.gyb.template",
67+
"SyntaxRewriter.swift.gyb",
68+
"SyntaxTraits.swift.gyb",
69+
"SyntaxVisitor.swift.gyb",
70+
"TokenKind.swift.gyb",
71+
"Tokens.swift.gyb",
72+
"Trivia.swift.gyb",
7273
],
7374
swiftSettings: swiftSyntaxSwiftSettings
7475
),

‎Sources/SwiftSyntax/SyntaxAnyVisitor.swift.gyb

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
# -*- mode: Swift -*-
44
# Ignore the following admonition it applies to the resulting .swift file only
55
}%
6-
//// Automatically Generated From SyntaxFactory.swift.gyb.
6+
//// Automatically Generated From SyntaxAnyVisitor.swift.gyb.
77
//// Do Not Edit Directly!
88
//===--------- SyntaxAnyVisitor.swift - Syntax any visitor class ----------===//
99
//

‎Sources/SwiftSyntax/SyntaxCollections.swift.gyb

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -55,6 +55,24 @@ public struct ${node.name}: SyntaxCollection, SyntaxHashable {
5555
self._syntaxNode = Syntax(data)
5656
}
5757

58+
public init(_ children: [${node.collection_element_type}]) {
59+
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.${node.swift_syntax_kind},
60+
layout: children.map { $0.raw }, presence: SourcePresence.present)
61+
let data = SyntaxData.forRoot(raw)
62+
self.init(data)
63+
}
64+
65+
public static func blank(presence: SourcePresence = .present) -> ${node.name} {
66+
let raw = RawSyntax.create(
67+
kind: .${node.swift_syntax_kind},
68+
layout: [],
69+
length: .zero,
70+
presence: presence
71+
)
72+
let data = SyntaxData.forRoot(raw)
73+
return ${node.name}(data)
74+
}
75+
5876
public var syntaxNodeType: SyntaxProtocol.Type {
5977
return Swift.type(of: self)
6078
}

‎Sources/SwiftSyntax/SyntaxFactory.swift.gyb

Lines changed: 84 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -28,15 +28,19 @@
2828
//===----------------------------------------------------------------------===//
2929

3030
public enum SyntaxFactory {
31+
@available(*, deprecated, message: "Use initializer on TokenSyntax")
3132
public static func makeToken(_ kind: TokenKind, presence: SourcePresence,
3233
leadingTrivia: Trivia = [],
3334
trailingTrivia: Trivia = []) -> TokenSyntax {
34-
let raw = RawSyntax.createAndCalcLength(kind: kind, leadingTrivia: leadingTrivia,
35-
trailingTrivia: trailingTrivia, presence: presence)
36-
let data = SyntaxData.forRoot(raw)
37-
return TokenSyntax(data)
35+
return TokenSyntax(
36+
kind,
37+
presence: presence,
38+
leadingTrivia: leadingTrivia,
39+
trailingTrivia: trailingTrivia
40+
)
3841
}
3942

43+
@available(*, deprecated, message: "Use initializer on UnknownSyntax")
4044
public static func makeUnknownSyntax(tokens: [TokenSyntax]) -> UnknownSyntax {
4145
let raw = RawSyntax.createAndCalcLength(kind: .unknown,
4246
layout: tokens.map { $0.raw }, presence: .present)
@@ -51,51 +55,34 @@ public enum SyntaxFactory {
5155
% pass
5256
% elif node.children:
5357
% child_params = []
58+
% initializer_args = []
5459
% for child in node.children:
55-
% param_type = child.type_name
56-
% if child.is_optional:
57-
% param_type = param_type + "?"
58-
% child_params.append("%s: %s" % (child.swift_name, param_type))
59-
% child_params = ', '.join(child_params)
60-
public static func make${node.syntax_kind}(${child_params}) -> ${node.name} {
61-
let layout: [RawSyntax?] = [
62-
% for child in node.children:
60+
% param_type = child.type_name
6361
% if child.is_optional:
64-
${child.swift_name}?.raw,
65-
% else:
66-
${child.swift_name}.raw,
62+
% param_type = param_type + "?"
6763
% end
64+
% child_params.append("%s: %s" % (child.swift_name, param_type))
65+
% initializer_args.append(f"{child.swift_name}: {child.swift_name}")
6866
% end
69-
]
70-
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.${node.swift_syntax_kind},
71-
layout: layout, presence: SourcePresence.present)
72-
let data = SyntaxData.forRoot(raw)
73-
return ${node.name}(data)
67+
% child_params_str = ', '.join(child_params)
68+
% initializer_args_str = ', '.join(initializer_args)
69+
@available(*, deprecated, message: "Use initializer on ${node.name}")
70+
public static func make${node.syntax_kind}(${child_params_str}) -> ${node.name} {
71+
return ${node.name}(${initializer_args_str})
7472
}
7573
% elif node.is_syntax_collection():
74+
@available(*, deprecated, message: "Use initializer on ${node.name}")
7675
public static func make${node.syntax_kind}(
7776
_ elements: [${node.collection_element_type}]) -> ${node.name} {
78-
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.${node.swift_syntax_kind},
79-
layout: elements.map { $0.raw }, presence: SourcePresence.present)
80-
let data = SyntaxData.forRoot(raw)
81-
return ${node.name}(data)
77+
return ${node.name}(elements)
8278
}
8379
% end
8480

8581
% if not node.is_base():
8682
% default_presence = 'missing' if node.is_missing() else 'present'
83+
@available(*, deprecated, message: "Use ${node.name}.blank(presence:) instead")
8784
public static func makeBlank${node.syntax_kind}(presence: SourcePresence = .${default_presence}) -> ${node.name} {
88-
let data = SyntaxData.forRoot(RawSyntax.create(kind: .${node.swift_syntax_kind},
89-
layout: [
90-
% for child in node.children:
91-
% if child.is_optional:
92-
nil,
93-
% else:
94-
${make_missing_swift_child(child)},
95-
% end
96-
% end
97-
], length: .zero, presence: presence))
98-
return ${node.name}(data)
85+
return ${node.name}.blank(presence: presence)
9986
}
10087
% end
10188
% end
@@ -111,129 +98,150 @@ public enum SyntaxFactory {
11198
% leading_trivia = token_trivia(token.requires_leading_space)
11299
% trailing_trivia = token_trivia(token.requires_trailing_space)
113100
% if token.is_keyword:
101+
@available(*, deprecated, message: "Use TokenSyntax.${token.swift_kind()}Keyword instead")
114102
public static func make${token.name}Keyword(
115103
leadingTrivia: Trivia = ${leading_trivia},
116104
trailingTrivia: Trivia = ${trailing_trivia}
117105
) -> TokenSyntax {
118-
return makeToken(.${token.swift_kind()}, presence: .present,
119-
leadingTrivia: leadingTrivia,
120-
trailingTrivia: trailingTrivia)
106+
return TokenSyntax.${token.swift_kind()}(
107+
leadingTrivia: leadingTrivia,
108+
trailingTrivia: trailingTrivia
109+
)
121110
}
122111
% elif token.text:
112+
@available(*, deprecated, message: "Use TokenSyntax.${token.swift_kind()}Token instead")
123113
public static func make${token.name}Token(
124114
leadingTrivia: Trivia = ${leading_trivia},
125115
trailingTrivia: Trivia = ${trailing_trivia}
126116
) -> TokenSyntax {
127-
return makeToken(.${token.swift_kind()}, presence: .present,
128-
leadingTrivia: leadingTrivia,
129-
trailingTrivia: trailingTrivia)
117+
return TokenSyntax.${token.swift_kind()}Token(
118+
leadingTrivia: leadingTrivia,
119+
trailingTrivia: trailingTrivia
120+
)
130121
}
131122
% else:
123+
@available(*, deprecated, message: "Use TokenSyntax.${token.swift_kind()} instead")
132124
public static func make${token.name}(
133125
_ text: String,
134126
leadingTrivia: Trivia = ${leading_trivia},
135127
trailingTrivia: Trivia = ${trailing_trivia}
136128
) -> TokenSyntax {
137-
return makeToken(.${token.swift_kind()}(text), presence: .present,
138-
leadingTrivia: leadingTrivia,
139-
trailingTrivia: trailingTrivia)
129+
return TokenSyntax.${token.swift_kind()}(
130+
text,
131+
leadingTrivia: leadingTrivia,
132+
trailingTrivia: trailingTrivia
133+
)
140134
}
141135
% end
142136
% end
143137

144138
/// MARK: Convenience APIs
145139

140+
@available(*, deprecated, message: "Use initializer on TupleTypeSyntax")
146141
public static func makeVoidTupleType() -> TupleTypeSyntax {
147-
return makeTupleType(leftParen: makeLeftParenToken(),
148-
elements: makeBlankTupleTypeElementList(),
149-
rightParen: makeRightParenToken())
142+
return TupleTypeSyntax(leftParen: makeLeftParenToken(),
143+
elements: makeBlankTupleTypeElementList(),
144+
rightParen: makeRightParenToken())
150145
}
151146

147+
@available(*, deprecated, message: "Use initializer on TupleTypeSyntax")
152148
public static func makeTupleTypeElement(name: TokenSyntax?,
153149
colon: TokenSyntax?, type: TypeSyntax,
154150
trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
155-
return makeTupleTypeElement(inOut: nil, name: name, secondName: nil,
156-
colon: colon, type: type, ellipsis: nil,
157-
initializer: nil, trailingComma: trailingComma)
151+
return TupleTypeElementSyntax(inOut: nil, name: name, secondName: nil,
152+
colon: colon, type: type, ellipsis: nil,
153+
initializer: nil, trailingComma: trailingComma)
158154
}
159155

156+
@available(*, deprecated, message: "Use initializer on TupleTypeSyntax")
160157
public static func makeTupleTypeElement(type: TypeSyntax,
161158
trailingComma: TokenSyntax?) -> TupleTypeElementSyntax {
162-
return makeTupleTypeElement(name: nil, colon: nil,
163-
type: type, trailingComma: trailingComma)
159+
return TupleTypeElementSyntax(inOut: nil, name: nil, secondName: nil,
160+
colon: nil, type: type, ellipsis: nil,
161+
initializer: nil, trailingComma: trailingComma)
164162
}
165163

164+
@available(*, deprecated, message: "Use initializer on GenericParameterSyntax")
166165
public static func makeGenericParameter(name: TokenSyntax,
167166
trailingComma: TokenSyntax) -> GenericParameterSyntax {
168-
return makeGenericParameter(attributes: nil, name: name, colon: nil,
169-
inheritedType: nil,
170-
trailingComma: trailingComma)
167+
return GenericParameterSyntax(attributes: nil, name: name, colon: nil,
168+
inheritedType: nil,
169+
trailingComma: trailingComma)
171170
}
172171

172+
@available(*, deprecated, message: "Use initializer on SimpleTypeIdentifierSyntax")
173173
public static func makeTypeIdentifier(_ name: String,
174174
leadingTrivia: Trivia = [],
175175
trailingTrivia: Trivia = []) -> TypeSyntax {
176-
let identifier = makeIdentifier(name, leadingTrivia: leadingTrivia,
177-
trailingTrivia: trailingTrivia)
178-
let typeIdentifier = makeSimpleTypeIdentifier(name: identifier,
179-
genericArgumentClause: nil)
176+
let identifier = TokenSyntax.identifier(name, leadingTrivia: leadingTrivia,
177+
trailingTrivia: trailingTrivia)
178+
let typeIdentifier = SimpleTypeIdentifierSyntax(name: identifier,
179+
genericArgumentClause: nil)
180180
return TypeSyntax(typeIdentifier)
181181
}
182182

183+
@available(*, deprecated, message: "Use initializer on SimpleTypeIdentifierSyntax")
183184
public static func makeAnyTypeIdentifier(leadingTrivia: Trivia = [],
184185
trailingTrivia: Trivia = []) -> TypeSyntax {
185186
return makeTypeIdentifier("Any", leadingTrivia: leadingTrivia,
186187
trailingTrivia: trailingTrivia)
187188
}
188189

190+
@available(*, deprecated, message: "Use initializer on SimpleTypeIdentifierSyntax")
189191
public static func makeSelfTypeIdentifier(leadingTrivia: Trivia = [],
190192
trailingTrivia: Trivia = []) -> TypeSyntax {
191193
return makeTypeIdentifier("Self", leadingTrivia: leadingTrivia,
192194
trailingTrivia: trailingTrivia)
193195
}
194196

197+
@available(*, deprecated, message: "Use initializer on SimpleTypeIdentifierSyntax")
195198
public static func makeTypeToken(leadingTrivia: Trivia = [],
196199
trailingTrivia: Trivia = []) -> TokenSyntax {
197-
return makeIdentifier("Type", leadingTrivia: leadingTrivia,
198-
trailingTrivia: trailingTrivia)
200+
return TokenSyntax.identifier("Type", leadingTrivia: leadingTrivia,
201+
trailingTrivia: trailingTrivia)
199202
}
200203

204+
@available(*, deprecated, message: "Use TokenSyntax.protocol")
201205
public static func makeProtocolToken(leadingTrivia: Trivia = [],
202206
trailingTrivia: Trivia = []) -> TokenSyntax {
203-
return makeIdentifier("Protocol", leadingTrivia: leadingTrivia,
204-
trailingTrivia: trailingTrivia)
207+
return TokenSyntax.identifier("Protocol", leadingTrivia: leadingTrivia,
208+
trailingTrivia: trailingTrivia)
205209
}
206210

211+
@available(*, deprecated, message: "Use TokenSyntax.spacedBinaryOperator")
207212
public static func makeBinaryOperator(_ name: String,
208213
leadingTrivia: Trivia = [],
209214
trailingTrivia: Trivia = []) -> TokenSyntax {
210-
return makeToken(.spacedBinaryOperator(name),
211-
presence: .present,
212-
leadingTrivia: leadingTrivia,
213-
trailingTrivia: trailingTrivia)
215+
return TokenSyntax.spacedBinaryOperator(
216+
name,
217+
leadingTrivia: leadingTrivia,
218+
trailingTrivia: trailingTrivia
219+
)
214220
}
215221

222+
@available(*, deprecated, message: "Use initializer on StringLiteralExprSyntax")
216223
public static func makeStringLiteralExpr(_ text: String,
217224
leadingTrivia: Trivia = [],
218225
trailingTrivia: Trivia = []) -> StringLiteralExprSyntax {
219-
let string = makeStringSegment(text)
220-
let segment = makeStringSegment(content: string)
226+
let string = TokenSyntax.stringSegment(text)
227+
let segment = StringSegmentSyntax(content: string)
221228
let segments = makeStringLiteralSegments([Syntax(segment)])
222229
let openQuote = makeStringQuoteToken(leadingTrivia: leadingTrivia)
223230
let closeQuote = makeStringQuoteToken(trailingTrivia: trailingTrivia)
224-
return makeStringLiteralExpr(openDelimiter: nil,
225-
openQuote: openQuote,
226-
segments: segments,
227-
closeQuote: closeQuote,
228-
closeDelimiter: nil)
231+
return StringLiteralExprSyntax(openDelimiter: nil,
232+
openQuote: openQuote,
233+
segments: segments,
234+
closeQuote: closeQuote,
235+
closeDelimiter: nil)
229236
}
230237

238+
@available(*, deprecated, message: "Use initializer on IdentifierExprSyntax")
231239
public static func makeVariableExpr(_ text: String,
232240
leadingTrivia: Trivia = [],
233241
trailingTrivia: Trivia = []) -> IdentifierExprSyntax {
234242
let string = makeIdentifier(text,
235243
leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia)
236-
return makeIdentifierExpr(identifier: string,
237-
declNameArguments: nil)
244+
return IdentifierExprSyntax(identifier: string,
245+
declNameArguments: nil)
238246
}
239247
}

‎Sources/SwiftSyntax/SyntaxNodes.swift.gyb.template

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,44 @@ public struct ${node.name}: ${base_type}Protocol, SyntaxHashable {
8080
self._syntaxNode = Syntax(data)
8181
}
8282

83+
% child_params = []
84+
% for child in node.children:
85+
% param_type = child.type_name
86+
% if child.is_optional:
87+
% param_type = param_type + "?"
88+
% child_params.append("%s: %s" % (child.swift_name, param_type))
89+
% child_params = ', '.join(child_params)
90+
public init(${child_params}) {
91+
let layout: [RawSyntax?] = [
92+
% for child in node.children:
93+
% if child.is_optional:
94+
${child.swift_name}?.raw,
95+
% else:
96+
${child.swift_name}.raw,
97+
% end
98+
% end
99+
]
100+
let raw = RawSyntax.createAndCalcLength(kind: SyntaxKind.${node.swift_syntax_kind},
101+
layout: layout, presence: SourcePresence.present)
102+
let data = SyntaxData.forRoot(raw)
103+
self.init(data)
104+
}
105+
106+
public static func blank(presence: SourcePresence = .present) -> ${node.name} {
107+
let raw = RawSyntax.create(kind: .${node.swift_syntax_kind},
108+
layout: [
109+
% for child in node.children:
110+
% if child.is_optional:
111+
nil,
112+
% else:
113+
${make_missing_swift_child(child)},
114+
% end
115+
% end
116+
], length: .zero, presence: presence)
117+
let data = SyntaxData.forRoot(raw)
118+
return ${node.name}(data)
119+
}
120+
83121
public var syntaxNodeType: SyntaxProtocol.Type {
84122
return Swift.type(of: self)
85123
}

0 commit comments

Comments
 (0)