Skip to content

Commit 22fe6d9

Browse files
saehejkangsaehejkang
committed
[ASTGen]: Implementation of visit(syntax) method
1 parent 581b9d8 commit 22fe6d9

File tree

10 files changed

+340
-222
lines changed

10 files changed

+340
-222
lines changed

‎lib/ASTGen/Sources/ASTGen/ASTGen.swift

Lines changed: 183 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
import CASTBridging
22
import CBasicBridging
33

4-
// Needed to use SyntaxTransformVisitor's visit method.
5-
@_spi(SyntaxTransformVisitor)
64
// Needed to use BumpPtrAllocator
75
@_spi(RawSyntax)
86
import SwiftSyntax
@@ -61,7 +59,7 @@ class Boxed<Value> {
6159
}
6260
}
6361

64-
struct ASTGenVisitor: SyntaxTransformVisitor {
62+
struct ASTGenVisitor {
6563
typealias ResultType = ASTNode
6664

6765
fileprivate let diagnosticEngine: BridgedDiagnosticEngine
@@ -86,27 +84,12 @@ struct ASTGenVisitor: SyntaxTransformVisitor {
8684
self.ctx = astContext
8785
}
8886

89-
// TODO: this some how messes up the witness table when I uncomment it locally :/
90-
// public func visit<T>(_ node: T?) -> [UnsafeMutableRawPointer]? {
91-
// if let node = node { return visit(node) }
92-
// return nil
93-
// }
94-
95-
@_disfavoredOverload
96-
public func visit(_ node: SourceFileSyntax) -> ASTNode {
97-
fatalError("Use other overload.")
98-
}
99-
100-
public func visitAny(_ node: Syntax) -> ASTNode {
101-
fatalError("Not implemented.")
102-
}
103-
104-
public func visit(_ node: SourceFileSyntax) -> [UnsafeMutableRawPointer] {
87+
public func generate(_ node: SourceFileSyntax) -> [UnsafeMutableRawPointer] {
10588
var out = [UnsafeMutableRawPointer]()
10689

10790
for element in node.statements {
10891
let loc = element.bridgedSourceLoc(in: self)
109-
let swiftASTNodes = visit(element)
92+
let swiftASTNodes = generate(element)
11093
switch swiftASTNodes {
11194
case .decl(let d):
11295
out.append(d)
@@ -147,109 +130,260 @@ extension ASTGenVisitor {
147130
}
148131
}
149132

133+
extension ASTGenVisitor {
134+
func generate(_ node: DeclSyntax) -> ASTNode {
135+
return generate(Syntax(node))
136+
}
137+
138+
func generate(_ node: ExprSyntax) -> ASTNode {
139+
return generate(Syntax(node))
140+
}
141+
142+
func generate(_ node: PatternSyntax) -> ASTNode {
143+
return generate(Syntax(node))
144+
}
145+
146+
func generate(_ node: StmtSyntax) -> ASTNode {
147+
return generate(Syntax(node))
148+
}
149+
150+
func generate(_ node: TypeSyntax) -> ASTNode {
151+
return generate(Syntax(node))
152+
}
153+
154+
func generate(_ node: some SyntaxChildChoices) -> ASTNode {
155+
return self.generate(Syntax(node))
156+
}
157+
158+
func generate(_ node: Syntax) -> ASTNode {
159+
switch node.as(SyntaxEnum.self) {
160+
case .actorDecl(let node):
161+
return generate(node)
162+
case .arrayElement(let node):
163+
return generate(node)
164+
case .arrayExpr(let node):
165+
return generate(node)
166+
case .arrayType(let node):
167+
return generate(node)
168+
case .associatedTypeDecl(let node):
169+
return generate(node)
170+
case .attributedType(let node):
171+
return generate(node)
172+
case .booleanLiteralExpr(let node):
173+
return generate(node)
174+
case .classDecl(let node):
175+
return generate(node)
176+
case .closureExpr(let node):
177+
return generate(node)
178+
case .codeBlock(let node):
179+
return generate(node)
180+
case .codeBlockItem(let node):
181+
return generate(node)
182+
case .compositionType(let node):
183+
return generate(node)
184+
case .conditionElement(let node):
185+
return generate(node)
186+
case .declReferenceExpr(let node):
187+
return generate(node)
188+
case .deinitializerDecl(let node):
189+
return generate(node)
190+
case .dictionaryType(let node):
191+
return generate(node)
192+
case .enumCaseDecl(let node):
193+
return generate(node)
194+
case .enumCaseElement(let node):
195+
return generate(node)
196+
case .enumCaseParameter(let node):
197+
return generate(node)
198+
case .enumCaseParameterClause(let node):
199+
return generate(node)
200+
case .enumDecl(let node):
201+
return generate(node)
202+
case .expressionStmt(let node):
203+
return generate(node)
204+
case .extensionDecl(let node):
205+
return generate(node)
206+
case .functionCallExpr(let node):
207+
return generate(node)
208+
case .functionDecl(let node):
209+
return generate(node)
210+
case .functionParameter(let node):
211+
return generate(node)
212+
case .functionParameterClause(let node):
213+
return generate(node)
214+
case .functionType(let node):
215+
return generate(node)
216+
case .genericParameter(let node):
217+
return generate(node)
218+
case .genericParameterClause(let node):
219+
return generate(node)
220+
case .genericWhereClause(let node):
221+
return generate(node)
222+
case .identifierPattern(let node):
223+
return generate(node)
224+
case .identifierType(let node):
225+
return generate(node)
226+
case .ifExpr(let node):
227+
return generate(node)
228+
case .implicitlyUnwrappedOptionalType(let node):
229+
return generate(node)
230+
case .importDecl(let node):
231+
return generate(node)
232+
case .initializerClause(let node):
233+
return generate(node)
234+
case .initializerDecl(let node):
235+
return generate(node)
236+
case .integerLiteralExpr(let node):
237+
return generate(node)
238+
case .labeledExprList:
239+
fatalError("case does not correspond to an ASTNode")
240+
case .memberAccessExpr(let node):
241+
return generate(node)
242+
case .memberBlockItem(let node):
243+
return generate(node)
244+
case .memberType(let node):
245+
return generate(node)
246+
case .metatypeType(let node):
247+
return generate(node)
248+
case .namedOpaqueReturnType(let node):
249+
return generate(node)
250+
case .nilLiteralExpr(let node):
251+
return generate(node)
252+
case .operatorDecl(let node):
253+
return generate(node)
254+
case .optionalType(let node):
255+
return generate(node)
256+
case .packExpansionType(let node):
257+
return generate(node)
258+
case .precedenceGroupDecl(let node):
259+
return generate(node)
260+
case .protocolDecl(let node):
261+
return generate(node)
262+
case .returnStmt(let node):
263+
return generate(node)
264+
case .someOrAnyType(let node):
265+
return generate(node)
266+
case .stringLiteralExpr(let node):
267+
return generate(node)
268+
case .structDecl(let node):
269+
return generate(node)
270+
case .tupleExpr(let node):
271+
return generate(node)
272+
case .tupleType(let node):
273+
return generate(node)
274+
case .typeAliasDecl(let node):
275+
return generate(node)
276+
case .variableDecl(let node):
277+
return generate(node)
278+
default:
279+
fatalError("not implemented")
280+
}
281+
}
282+
}
283+
150284
// Misc visits.
151285
// TODO: Some of these are called within a single file/method; we may want to move them to the respective files.
152286
extension ASTGenVisitor {
153-
public func visit(_ node: MemberBlockItemSyntax) -> ASTNode {
154-
visit(Syntax(node.decl))
287+
public func generate(_ node: MemberBlockItemSyntax) -> ASTNode {
288+
generate(node.decl)
155289
}
156290

157-
public func visit(_ node: InitializerClauseSyntax) -> ASTNode {
158-
visit(node.value)
291+
public func generate(_ node: InitializerClauseSyntax) -> ASTNode {
292+
generate(node.value)
159293
}
160294

161-
public func visit(_ node: ConditionElementSyntax) -> ASTNode {
162-
visit(node.condition)
295+
public func generate(_ node: ConditionElementSyntax) -> ASTNode {
296+
generate(node.condition)
163297
}
164298

165-
public func visit(_ node: CodeBlockItemSyntax) -> ASTNode {
166-
visit(node.item)
299+
public func generate(_ node: CodeBlockItemSyntax) -> ASTNode {
300+
generate(node.item)
167301
}
168302

169-
public func visit(_ node: ArrayElementSyntax) -> ASTNode {
170-
visit(node.expression)
303+
public func generate(_ node: ArrayElementSyntax) -> ASTNode {
304+
generate(node.expression)
171305
}
172306

173307
@inline(__always)
174-
func visit(_ node: CodeBlockItemListSyntax) -> BridgedArrayRef {
175-
node.lazy.map { self.visit($0).bridged }.bridgedArray(in: self)
308+
func generate(_ node: CodeBlockItemListSyntax) -> BridgedArrayRef {
309+
node.lazy.map { self.generate($0).bridged }.bridgedArray(in: self)
176310
}
177311
}
178312

179313
// Forwarding overloads that take optional syntax nodes. These are defined on demand to achieve a consistent
180314
// 'self.visit(<expr>)' recursion pattern between optional and non-optional inputs.
181315
extension ASTGenVisitor {
182316
@inline(__always)
183-
func visit(_ node: TypeSyntax?) -> ASTNode? {
317+
func generate(_ node: TypeSyntax?) -> ASTNode? {
184318
guard let node else {
185319
return nil
186320
}
187321

188-
return self.visit(node)
322+
return self.generate(node)
189323
}
190324

191325
@inline(__always)
192-
func visit(_ node: ExprSyntax?) -> ASTNode? {
326+
func generate(_ node: ExprSyntax?) -> ASTNode? {
193327
guard let node else {
194328
return nil
195329
}
196330

197-
return self.visit(node)
331+
return self.generate(node)
198332
}
199333

200334
@inline(__always)
201-
func visit(_ node: (some SyntaxChildChoices)?) -> ASTNode? {
335+
func generate(_ node: (some SyntaxChildChoices)?) -> ASTNode? {
202336
guard let node else {
203337
return nil
204338
}
205339

206340
// This call recurses without disambiguation.
207-
return (self.visit as (_) -> ASTNode)(node)
341+
return self.generate(node) as ASTNode
208342
}
209343

210344
@inline(__always)
211-
func visit(_ node: GenericParameterClauseSyntax?) -> ASTNode? {
345+
func generate(_ node: GenericParameterClauseSyntax?) -> ASTNode? {
212346
guard let node else {
213347
return nil
214348
}
215349

216-
return self.visit(node)
350+
return self.generate(node)
217351
}
218352

219353
@inline(__always)
220-
func visit(_ node: GenericWhereClauseSyntax?) -> ASTNode? {
354+
func generate(_ node: GenericWhereClauseSyntax?) -> ASTNode? {
221355
guard let node else {
222356
return nil
223357
}
224358

225-
return self.visit(node)
359+
return self.generate(node)
226360
}
227361

228362
@inline(__always)
229-
func visit(_ node: EnumCaseParameterClauseSyntax?) -> ASTNode? {
363+
func generate(_ node: EnumCaseParameterClauseSyntax?) -> ASTNode? {
230364
guard let node else {
231365
return nil
232366
}
233367

234-
return self.visit(node)
368+
return self.generate(node)
235369
}
236370

237371
@inline(__always)
238-
func visit(_ node: InheritedTypeListSyntax?) -> BridgedArrayRef {
372+
func generate(_ node: InheritedTypeListSyntax?) -> BridgedArrayRef {
239373
guard let node else {
240374
return .init()
241375
}
242376

243-
return self.visit(node)
377+
return self.generate(node)
244378
}
245379

246380
@inline(__always)
247-
func visit(_ node: PrecedenceGroupNameListSyntax?) -> BridgedArrayRef {
381+
func generate(_ node: PrecedenceGroupNameListSyntax?) -> BridgedArrayRef {
248382
guard let node else {
249383
return .init()
250384
}
251385

252-
return self.visit(node)
386+
return self.generate(node)
253387
}
254388
}
255389

@@ -336,7 +470,7 @@ public func buildTopLevelASTNodes(
336470
declContext: BridgedDeclContext(raw: dc),
337471
astContext: BridgedASTContext(raw: ctx)
338472
)
339-
.visit(sourceFile.pointee.syntax)
473+
.generate(sourceFile.pointee.syntax)
340474
.forEach { callback($0, outputContext) }
341475
}
342476
}

‎lib/ASTGen/Sources/ASTGen/Bridge.swift

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -45,18 +45,18 @@ extension SyntaxProtocol {
4545
///
4646
/// - Parameter astgen: The visitor providing the source buffer.
4747
@inline(__always)
48-
func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
48+
func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
4949
return BridgedSourceLoc(at: self.positionAfterSkippingLeadingTrivia, in: astgen.base)
5050
}
5151
}
5252

53-
extension Optional where Wrapped: SyntaxProtocol {
53+
extension Optional where Wrapped: SyntaxProtocol {
5454
/// Obtains the bridged start location of the node excluding leading trivia in the source buffer provided by `astgen`.
5555
///
5656
/// - Parameter astgen: The visitor providing the source buffer.
5757
@inline(__always)
58-
func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
59-
guard let self else {
58+
func bridgedSourceLoc(in astgen: ASTGenVisitor) -> BridgedSourceLoc {
59+
guard let self else {
6060
return nil
6161
}
6262

0 commit comments

Comments
 (0)