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
|
//===----------------------------------------------------------------------===//
//
// 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 SwiftSyntax
import SwiftSyntaxBuilder
import SyntaxSupport
import Utils
let layoutNodesParsableFile = SourceFileSyntax(leadingTrivia: copyrightHeader) {
DeclSyntax(
"""
#if swift(>=6)
@_spi(RawSyntax) public import SwiftSyntax
#else
@_spi(RawSyntax) import SwiftSyntax
#endif
"""
)
DeclSyntax(
"""
public protocol SyntaxParseable: SyntaxProtocol {
static func parse(from parser: inout Parser) -> Self
}
"""
)
for node in SYNTAX_NODES {
if let parserFunction = node.parserFunction {
DeclSyntax(
"""
extension \(node.kind.syntaxType): SyntaxParseable {
public static func parse(from parser: inout Parser) -> Self {
// Keep the parser alive so that the arena in which `raw` is allocated
// doesn’t get deallocated before we have a chance to create a syntax node
// from it. We can’t use `parser.arena` as the parameter to
// `Syntax(raw:arena:)` because the node might have been re-used during an
// incremental parse and would then live in a different arena than
// `parser.arena`.
defer { withExtendedLifetime(parser) {} }
let node = parser.\(parserFunction)()
let raw = RawSyntax(parser.parseRemainder(into: node))
return Syntax(raw: raw, rawNodeArena: parser.arena).cast(Self.self)
}
}
"""
)
}
}
try! ExtensionDeclSyntax("fileprivate extension Parser") {
DeclSyntax(
"""
mutating func parseNonOptionalCodeBlockItem() -> RawCodeBlockItemSyntax {
guard let node = self.parseCodeBlockItem(isAtTopLevel: false, allowInitDecl: true) else {
// The missing item is not necessary to be a declaration,
// which is just a placeholder here
return RawCodeBlockItemSyntax(
item: .init(
decl: RawMissingDeclSyntax(
attributes: self.emptyCollection(RawAttributeListSyntax.self),
modifiers: self.emptyCollection(RawDeclModifierListSyntax.self),
arena: self.arena
)
),
semicolon: nil,
arena: self.arena
)
}
return node
}
"""
)
DeclSyntax(
"""
mutating func parseExpression() -> RawExprSyntax {
return self.parseExpression(flavor: .basic, pattern: .none)
}
"""
)
}
}
|
