@data-vegle/rbxts-go 0.0.0-stage → 1.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +181 -2
- package/README.rbxtsgo.md +169 -0
- package/THIRD_PARTY_NOTICES.md +745 -0
- package/cli/cli.go +454 -0
- package/compile/compile.go +388 -0
- package/compile/declarations.go +221 -0
- package/compile/incremental.go +349 -0
- package/compile/times.go +9 -0
- package/docs/plugin-api.md +243 -0
- package/go.mod +20 -0
- package/go.sum +24 -0
- package/internal/difftest/difftest.go +530 -0
- package/internal/plugintest/plugintest.go +181 -0
- package/luau/create.go +351 -0
- package/luau/doc.go +71 -0
- package/luau/globals.go +178 -0
- package/luau/jsnum.go +188 -0
- package/luau/kinds.go +128 -0
- package/luau/list.go +227 -0
- package/luau/nodes.go +479 -0
- package/luau/operators.go +46 -0
- package/luau/render.go +134 -0
- package/luau/render_expressions.go +264 -0
- package/luau/render_fields.go +81 -0
- package/luau/render_indexable.go +81 -0
- package/luau/render_state.go +134 -0
- package/luau/render_statements.go +235 -0
- package/luau/render_util.go +296 -0
- package/luau/solve_temp_ids.go +212 -0
- package/luau/typeguards.go +175 -0
- package/luau/util.go +184 -0
- package/luau/visit.go +138 -0
- package/npm/index.d.ts +3 -0
- package/npm/rbxts-go.sh +187 -0
- package/package.json +45 -5
- package/patches/typescript/0001-checker-exports.patch +40 -0
- package/patches/typescript/0002-iterable-arity.patch +15 -0
- package/patches/typescript/0003-context-sensitive-this.patch +15 -0
- package/patches/typescript/0004-printer-keep-parse-tree-parentheses.patch +26 -0
- package/pluginapi/host.go +31 -0
- package/pluginapi/pluginapi.go +153 -0
- package/plugins/LICENSE-rbxts-transformer-setget +18 -0
- package/plugins/apply.go +342 -0
- package/plugins/config.go +431 -0
- package/plugins/fallback.go +84 -0
- package/plugins/fixemit.go +60 -0
- package/plugins/native.go +271 -0
- package/plugins/session.go +236 -0
- package/plugins/setget.go +478 -0
- package/project/copy.go +333 -0
- package/project/include/Promise.lua +2068 -0
- package/project/include/RuntimeLib.lua +260 -0
- package/project/nodepath/nodepath.go +917 -0
- package/project/pathtranslator/pathtranslator.go +214 -0
- package/project/project.go +498 -0
- package/project/rojoresolver/json.go +248 -0
- package/project/rojoresolver/rojoresolver.go +559 -0
- package/project/shared/constants.go +83 -0
- package/project/shared/diagnostic.go +238 -0
- package/project/shared/diagnostics.go +388 -0
- package/project/shared/elapsed.go +14 -0
- package/project/shared/eol_other.go +6 -0
- package/project/shared/eol_windows.go +4 -0
- package/project/shared/kleur.go +40 -0
- package/project/shared/util.go +183 -0
- package/scripts/build-with-plugins.sh +130 -0
- package/scripts/setup-third-party.sh +75 -0
- package/transformer/add_index_diagnostics.go +21 -0
- package/transformer/add_one_if_array_type.go +15 -0
- package/transformer/array_binding_pattern_contains_hoists.go +25 -0
- package/transformer/assert_never.go +24 -0
- package/transformer/assignment.go +64 -0
- package/transformer/call_macros.go +70 -0
- package/transformer/check_variable_hoist.go +125 -0
- package/transformer/clean_module_name.go +28 -0
- package/transformer/constructor_macros.go +122 -0
- package/transformer/convert_to_indexable_expression.go +12 -0
- package/transformer/create_binary_from_operator.go +86 -0
- package/transformer/create_continue_statements.go +68 -0
- package/transformer/create_get_service.go +15 -0
- package/transformer/create_hoist_declaration.go +27 -0
- package/transformer/create_import_expression.go +220 -0
- package/transformer/create_string_from_literal.go +195 -0
- package/transformer/create_truthiness_checks.go +63 -0
- package/transformer/create_type_check.go +9 -0
- package/transformer/ensure_transform_order.go +53 -0
- package/transformer/expression_chain.go +27 -0
- package/transformer/expression_might_mutate.go +60 -0
- package/transformer/find_constructor.go +15 -0
- package/transformer/fixup_whitespace_and_decode_entities.go +377 -0
- package/transformer/get_accessor_for_binding_type.go +160 -0
- package/transformer/get_add_iterable_to_array_builder.go +363 -0
- package/transformer/get_assignable_value.go +15 -0
- package/transformer/get_constant_value_literal.go +20 -0
- package/transformer/get_declared_variables.go +34 -0
- package/transformer/get_extends_node.go +23 -0
- package/transformer/get_flags.go +21 -0
- package/transformer/get_kind_name.go +18 -0
- package/transformer/get_original_symbol_of_node.go +16 -0
- package/transformer/get_source_file_from_module_specifier.go +68 -0
- package/transformer/get_statements.go +12 -0
- package/transformer/has_multiple_definitions.go +18 -0
- package/transformer/hoist_functions_past_final_statement.go +43 -0
- package/transformer/identifier_macros.go +17 -0
- package/transformer/is_blocked_by_try_statement.go +19 -0
- package/transformer/is_method.go +104 -0
- package/transformer/is_symbol_mutable.go +26 -0
- package/transformer/is_symbol_of_value.go +11 -0
- package/transformer/is_used_as_statement.go +25 -0
- package/transformer/is_valid_method_index_without_call.go +36 -0
- package/transformer/macro_manager.go +92 -0
- package/transformer/object_accessor.go +32 -0
- package/transformer/offset.go +58 -0
- package/transformer/pointer.go +53 -0
- package/transformer/property_call_macros.go +1035 -0
- package/transformer/state.go +606 -0
- package/transformer/transform_array_assignment_pattern.go +65 -0
- package/transformer/transform_array_binding_pattern.go +49 -0
- package/transformer/transform_array_literal_expression.go +97 -0
- package/transformer/transform_await_expression.go +12 -0
- package/transformer/transform_binary_expression.go +221 -0
- package/transformer/transform_binding_name.go +25 -0
- package/transformer/transform_block.go +14 -0
- package/transformer/transform_boolean_literal.go +13 -0
- package/transformer/transform_break_statement.go +26 -0
- package/transformer/transform_call_expression.go +266 -0
- package/transformer/transform_class_constructor.go +125 -0
- package/transformer/transform_class_declaration.go +12 -0
- package/transformer/transform_class_expression.go +14 -0
- package/transformer/transform_class_like_declaration.go +355 -0
- package/transformer/transform_conditional_expression.go +70 -0
- package/transformer/transform_continue_statement.go +30 -0
- package/transformer/transform_decorators.go +253 -0
- package/transformer/transform_delete_expression.go +17 -0
- package/transformer/transform_do_statement.go +39 -0
- package/transformer/transform_element_access_expression.go +114 -0
- package/transformer/transform_entity_name.go +21 -0
- package/transformer/transform_enum_declaration.go +135 -0
- package/transformer/transform_export_assignment.go +57 -0
- package/transformer/transform_export_declaration.go +150 -0
- package/transformer/transform_expression.go +120 -0
- package/transformer/transform_expression_statement.go +71 -0
- package/transformer/transform_for_of_statement.go +461 -0
- package/transformer/transform_for_statement.go +599 -0
- package/transformer/transform_function_declaration.go +84 -0
- package/transformer/transform_function_expression.go +48 -0
- package/transformer/transform_identifier.go +194 -0
- package/transformer/transform_if_statement.go +44 -0
- package/transformer/transform_import_declaration.go +146 -0
- package/transformer/transform_import_equals_declaration.go +46 -0
- package/transformer/transform_import_expression.go +36 -0
- package/transformer/transform_initializer.go +22 -0
- package/transformer/transform_interpolated_string_part.go +12 -0
- package/transformer/transform_jsx.go +41 -0
- package/transformer/transform_jsx_attributes.go +110 -0
- package/transformer/transform_jsx_children.go +50 -0
- package/transformer/transform_jsx_element.go +14 -0
- package/transformer/transform_jsx_expression.go +20 -0
- package/transformer/transform_jsx_fragment.go +42 -0
- package/transformer/transform_jsx_self_closing_element.go +13 -0
- package/transformer/transform_jsx_tag_name.go +53 -0
- package/transformer/transform_logical.go +160 -0
- package/transformer/transform_logical_or_coalescing_assignment_expression.go +103 -0
- package/transformer/transform_method_declaration.go +102 -0
- package/transformer/transform_module_declaration.go +143 -0
- package/transformer/transform_new_expression.go +27 -0
- package/transformer/transform_no_substitution_template_literal.go +16 -0
- package/transformer/transform_numeric_literal.go +15 -0
- package/transformer/transform_object_assignment_pattern.go +86 -0
- package/transformer/transform_object_binding_pattern.go +49 -0
- package/transformer/transform_object_literal_expression.go +107 -0
- package/transformer/transform_omitted_expression.go +9 -0
- package/transformer/transform_optional_chain.go +312 -0
- package/transformer/transform_parameters.go +124 -0
- package/transformer/transform_parenthesized_expression.go +17 -0
- package/transformer/transform_property_access_expression.go +37 -0
- package/transformer/transform_property_declaration.go +33 -0
- package/transformer/transform_property_name.go +20 -0
- package/transformer/transform_return_statement.go +83 -0
- package/transformer/transform_source_file.go +230 -0
- package/transformer/transform_spread_element.go +35 -0
- package/transformer/transform_statement.go +84 -0
- package/transformer/transform_statement_list.go +90 -0
- package/transformer/transform_string_literal.go +22 -0
- package/transformer/transform_super_keyword.go +9 -0
- package/transformer/transform_switch_statement.go +145 -0
- package/transformer/transform_tagged_template_expression.go +34 -0
- package/transformer/transform_template_expression.go +35 -0
- package/transformer/transform_this_expression.go +33 -0
- package/transformer/transform_throw_statement.go +18 -0
- package/transformer/transform_try_statement.go +192 -0
- package/transformer/transform_type_expression.go +12 -0
- package/transformer/transform_unary_expression.go +79 -0
- package/transformer/transform_variable_statement.go +178 -0
- package/transformer/transform_void_expression.go +13 -0
- package/transformer/transform_while_statement.go +34 -0
- package/transformer/transform_writable.go +69 -0
- package/transformer/transform_yield_expression.go +56 -0
- package/transformer/type_guards.go +30 -0
- package/transformer/types.go +381 -0
- package/transformer/validate_identifier.go +17 -0
- package/transformer/validate_method_assignment.go +106 -0
- package/transformer/validate_not_any.go +37 -0
- package/transformer/wrap_expression_statement.go +20 -0
- package/transformer/wrap_return_if_lua_tuple.go +63 -0
- package/transformer/wrap_statements_as_generator.go +22 -0
- package/tsbridge/affected.go +141 -0
- package/tsbridge/config.go +71 -0
- package/tsbridge/diagnostics.go +128 -0
- package/tsbridge/doc.go +16 -0
- package/tsbridge/macros.go +207 -0
- package/tsbridge/macrospec.go +30 -0
- package/tsbridge/pool.go +142 -0
- package/tsbridge/project.go +137 -0
- package/tsbridge/reprint.go +120 -0
- package/tsbridge/update.go +128 -0
- package/watch/poll.go +126 -0
- package/watch/session.go +651 -0
- package/watch/watch.go +180 -0
|
@@ -0,0 +1,212 @@
|
|
|
1
|
+
package luau
|
|
2
|
+
|
|
3
|
+
import "strconv"
|
|
4
|
+
|
|
5
|
+
// Ported from src/LuauRenderer/solveTempIds.ts.
|
|
6
|
+
|
|
7
|
+
func isFullyScopedNode(node Node) bool {
|
|
8
|
+
switch node.Kind() {
|
|
9
|
+
case KindForStatement, KindNumericForStatement, KindFunctionDeclaration, KindFunctionExpression, KindMethodDeclaration:
|
|
10
|
+
return true
|
|
11
|
+
}
|
|
12
|
+
return false
|
|
13
|
+
}
|
|
14
|
+
|
|
15
|
+
// statementsOf returns the statement list of a node that owns one (upstream
|
|
16
|
+
// hasStatements guard plus .statements), or nil. A type switch on the
|
|
17
|
+
// concrete types is much cheaper than asserting HasStatements.
|
|
18
|
+
func statementsOf(node Node) *List {
|
|
19
|
+
switch n := node.(type) {
|
|
20
|
+
case *ForStatement:
|
|
21
|
+
return n.Statements
|
|
22
|
+
case *NumericForStatement:
|
|
23
|
+
return n.Statements
|
|
24
|
+
case *FunctionExpression:
|
|
25
|
+
return n.Statements
|
|
26
|
+
case *DoStatement:
|
|
27
|
+
return n.Statements
|
|
28
|
+
case *FunctionDeclaration:
|
|
29
|
+
return n.Statements
|
|
30
|
+
case *IfStatement:
|
|
31
|
+
return n.Statements
|
|
32
|
+
case *MethodDeclaration:
|
|
33
|
+
return n.Statements
|
|
34
|
+
case *RepeatStatement:
|
|
35
|
+
return n.Statements
|
|
36
|
+
case *WhileStatement:
|
|
37
|
+
return n.Statements
|
|
38
|
+
}
|
|
39
|
+
return nil
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
// isScopeEdge reports whether node is the first (head) or last (tail)
|
|
43
|
+
// statement of a block that creates scope.
|
|
44
|
+
func isScopeEdge(node Node, head bool) bool {
|
|
45
|
+
parent := node.Parent()
|
|
46
|
+
if parent == nil {
|
|
47
|
+
return false
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
// is the first statement in a block that creates scope
|
|
51
|
+
if statements := statementsOf(parent); statements != nil {
|
|
52
|
+
if edgeValue(statements, head) == node {
|
|
53
|
+
return true
|
|
54
|
+
}
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
// non-list elseBody would have the elseBody itself as a parent,
|
|
58
|
+
// which would be a luau.IfStatement and handled above
|
|
59
|
+
if ifStatement, ok := parent.(*IfStatement); ok {
|
|
60
|
+
if list, ok := ifStatement.ElseBody.(*List); ok && edgeValue(list, head) == node {
|
|
61
|
+
return true
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
|
|
65
|
+
return false
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
// edgeValue returns list.head?.value or list.tail?.value (nil when empty).
|
|
69
|
+
func edgeValue(list *List, head bool) Node {
|
|
70
|
+
edge := list.Tail
|
|
71
|
+
if head {
|
|
72
|
+
edge = list.Head
|
|
73
|
+
}
|
|
74
|
+
if edge == nil {
|
|
75
|
+
return nil
|
|
76
|
+
}
|
|
77
|
+
return edge.Value
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
type scope struct {
|
|
81
|
+
ids map[string]struct{}
|
|
82
|
+
lastTry map[string]int
|
|
83
|
+
parent *scope
|
|
84
|
+
}
|
|
85
|
+
|
|
86
|
+
func createScope(parent *scope) *scope {
|
|
87
|
+
return &scope{parent: parent}
|
|
88
|
+
}
|
|
89
|
+
|
|
90
|
+
func (s *scope) hasID(id string) bool {
|
|
91
|
+
for ; s != nil; s = s.parent {
|
|
92
|
+
if _, ok := s.ids[id]; ok {
|
|
93
|
+
return true
|
|
94
|
+
}
|
|
95
|
+
}
|
|
96
|
+
return false
|
|
97
|
+
}
|
|
98
|
+
|
|
99
|
+
func (s *scope) addID(id string) {
|
|
100
|
+
if s.ids == nil {
|
|
101
|
+
s.ids = make(map[string]struct{})
|
|
102
|
+
}
|
|
103
|
+
s.ids[id] = struct{}{}
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
// SolveTempIDs gives every TemporaryIdentifier under ast a unique name in
|
|
107
|
+
// state.SeenTempNodes. ast is a *List or a Node. Names that are already in
|
|
108
|
+
// SeenTempNodes are kept.
|
|
109
|
+
func SolveTempIDs(state *RenderState, ast NodeOrList) {
|
|
110
|
+
if state.SeenTempNodes == nil {
|
|
111
|
+
state.SeenTempNodes = make(map[int]string)
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
var tempIDsToProcess []*TemporaryIdentifier
|
|
115
|
+
// Like upstream, a node visited twice keeps the scope of its last visit.
|
|
116
|
+
nodesToScopes := make(map[*TemporaryIdentifier]*scope)
|
|
117
|
+
|
|
118
|
+
scopeStack := []*scope{createScope(nil)}
|
|
119
|
+
|
|
120
|
+
// Upstream indexes an empty array to get undefined and asserts on it, so an
|
|
121
|
+
// unbalanced pop (possible with the dangling links in List) is an
|
|
122
|
+
// assertion failure here too.
|
|
123
|
+
peekScopeStack := func() *scope {
|
|
124
|
+
Assert(len(scopeStack) > 0, "")
|
|
125
|
+
return scopeStack[len(scopeStack)-1]
|
|
126
|
+
}
|
|
127
|
+
pushScopeStack := func() { scopeStack = append(scopeStack, createScope(peekScopeStack())) }
|
|
128
|
+
popScopeStack := func() {
|
|
129
|
+
if len(scopeStack) > 0 {
|
|
130
|
+
scopeStack = scopeStack[:len(scopeStack)-1]
|
|
131
|
+
}
|
|
132
|
+
}
|
|
133
|
+
registerID := func(name string) { peekScopeStack().addID(name) }
|
|
134
|
+
registerParameters := func(parameters *List) {
|
|
135
|
+
for ln := parameters.Head; ln != nil; ln = ln.Next {
|
|
136
|
+
if id, ok := ln.Value.(*Identifier); ok {
|
|
137
|
+
registerID(id.Name)
|
|
138
|
+
}
|
|
139
|
+
}
|
|
140
|
+
}
|
|
141
|
+
|
|
142
|
+
Visit(ast, &Visitor{
|
|
143
|
+
Before: func(node Node) {
|
|
144
|
+
if isFullyScopedNode(node) {
|
|
145
|
+
pushScopeStack()
|
|
146
|
+
}
|
|
147
|
+
if isScopeEdge(node, true) {
|
|
148
|
+
pushScopeStack()
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
switch n := node.(type) {
|
|
152
|
+
case *TemporaryIdentifier:
|
|
153
|
+
nodesToScopes[n] = peekScopeStack()
|
|
154
|
+
tempIDsToProcess = append(tempIDsToProcess, n)
|
|
155
|
+
case *VariableDeclaration:
|
|
156
|
+
if list, ok := n.Left.(*List); ok {
|
|
157
|
+
for ln := list.Head; ln != nil; ln = ln.Next {
|
|
158
|
+
if id, ok := ln.Value.(*Identifier); ok {
|
|
159
|
+
registerID(id.Name)
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
} else if id, ok := n.Left.(*Identifier); ok {
|
|
163
|
+
registerID(id.Name)
|
|
164
|
+
}
|
|
165
|
+
case *FunctionDeclaration:
|
|
166
|
+
registerParameters(n.Parameters)
|
|
167
|
+
case *FunctionExpression:
|
|
168
|
+
registerParameters(n.Parameters)
|
|
169
|
+
case *MethodDeclaration:
|
|
170
|
+
registerParameters(n.Parameters)
|
|
171
|
+
}
|
|
172
|
+
},
|
|
173
|
+
After: func(node Node) {
|
|
174
|
+
if isFullyScopedNode(node) {
|
|
175
|
+
popScopeStack()
|
|
176
|
+
}
|
|
177
|
+
if isScopeEdge(node, false) {
|
|
178
|
+
popScopeStack()
|
|
179
|
+
}
|
|
180
|
+
},
|
|
181
|
+
})
|
|
182
|
+
|
|
183
|
+
for _, tempID := range tempIDsToProcess {
|
|
184
|
+
if _, seen := state.SeenTempNodes[tempID.ID]; seen {
|
|
185
|
+
continue
|
|
186
|
+
}
|
|
187
|
+
sc := nodesToScopes[tempID]
|
|
188
|
+
Assert(sc != nil, "")
|
|
189
|
+
|
|
190
|
+
separator := "_"
|
|
191
|
+
if tempID.Name == "" {
|
|
192
|
+
separator = ""
|
|
193
|
+
}
|
|
194
|
+
|
|
195
|
+
input := "_" + tempID.Name
|
|
196
|
+
i, ok := sc.lastTry[input]
|
|
197
|
+
if !ok {
|
|
198
|
+
i = 1
|
|
199
|
+
}
|
|
200
|
+
for sc.hasID(input) {
|
|
201
|
+
input = "_" + tempID.Name + separator + strconv.Itoa(i)
|
|
202
|
+
i++
|
|
203
|
+
}
|
|
204
|
+
if sc.lastTry == nil {
|
|
205
|
+
sc.lastTry = make(map[string]int)
|
|
206
|
+
}
|
|
207
|
+
sc.lastTry[input] = i
|
|
208
|
+
sc.addID(input)
|
|
209
|
+
|
|
210
|
+
state.SeenTempNodes[tempID.ID] = input
|
|
211
|
+
}
|
|
212
|
+
}
|
|
@@ -0,0 +1,175 @@
|
|
|
1
|
+
package luau
|
|
2
|
+
|
|
3
|
+
// Ported from src/LuauAST/impl/typeGuards.ts.
|
|
4
|
+
//
|
|
5
|
+
// Guards take a Node and test its Kind, like upstream. Go code can usually
|
|
6
|
+
// use a type assertion or switch instead; these exist so call sites can be
|
|
7
|
+
// ported one to one. A nil node is never any kind.
|
|
8
|
+
|
|
9
|
+
func kindOf(node Node) SyntaxKind {
|
|
10
|
+
if node == nil {
|
|
11
|
+
return -1
|
|
12
|
+
}
|
|
13
|
+
return node.Kind()
|
|
14
|
+
}
|
|
15
|
+
|
|
16
|
+
// indexable expressions
|
|
17
|
+
func IsAnyIdentifier(node Node) bool {
|
|
18
|
+
k := kindOf(node)
|
|
19
|
+
return k == KindIdentifier || k == KindTemporaryIdentifier
|
|
20
|
+
}
|
|
21
|
+
func IsIdentifier(node Node) bool { return kindOf(node) == KindIdentifier }
|
|
22
|
+
func IsTemporaryIdentifier(node Node) bool { return kindOf(node) == KindTemporaryIdentifier }
|
|
23
|
+
func IsComputedIndexExpression(node Node) bool { return kindOf(node) == KindComputedIndexExpression }
|
|
24
|
+
func IsPropertyAccessExpression(node Node) bool { return kindOf(node) == KindPropertyAccessExpression }
|
|
25
|
+
func IsCallExpression(node Node) bool { return kindOf(node) == KindCallExpression }
|
|
26
|
+
func IsMethodCallExpression(node Node) bool { return kindOf(node) == KindMethodCallExpression }
|
|
27
|
+
func IsParenthesizedExpression(node Node) bool { return kindOf(node) == KindParenthesizedExpression }
|
|
28
|
+
|
|
29
|
+
func IsIndexableExpression(node Node) bool {
|
|
30
|
+
k := kindOf(node)
|
|
31
|
+
return k >= KindFirstIndexableExpression && k <= KindLastIndexableExpression
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
// expressions
|
|
35
|
+
func IsNone(node Node) bool { return kindOf(node) == KindNone }
|
|
36
|
+
func IsNilLiteral(node Node) bool { return kindOf(node) == KindNilLiteral }
|
|
37
|
+
func IsFalseLiteral(node Node) bool { return kindOf(node) == KindFalseLiteral }
|
|
38
|
+
func IsTrueLiteral(node Node) bool { return kindOf(node) == KindTrueLiteral }
|
|
39
|
+
func IsNumberLiteral(node Node) bool { return kindOf(node) == KindNumberLiteral }
|
|
40
|
+
func IsStringLiteral(node Node) bool { return kindOf(node) == KindStringLiteral }
|
|
41
|
+
func IsVarArgsLiteral(node Node) bool { return kindOf(node) == KindVarArgsLiteral }
|
|
42
|
+
func IsFunctionExpression(node Node) bool { return kindOf(node) == KindFunctionExpression }
|
|
43
|
+
func IsBinaryExpression(node Node) bool { return kindOf(node) == KindBinaryExpression }
|
|
44
|
+
func IsUnaryExpression(node Node) bool { return kindOf(node) == KindUnaryExpression }
|
|
45
|
+
func IsIfExpression(node Node) bool { return kindOf(node) == KindIfExpression }
|
|
46
|
+
func IsInterpolatedString(node Node) bool { return kindOf(node) == KindInterpolatedString }
|
|
47
|
+
func IsArray(node Node) bool { return kindOf(node) == KindArray }
|
|
48
|
+
func IsMap(node Node) bool { return kindOf(node) == KindMap }
|
|
49
|
+
func IsSet(node Node) bool { return kindOf(node) == KindSet }
|
|
50
|
+
func IsMixedTable(node Node) bool { return kindOf(node) == KindMixedTable }
|
|
51
|
+
|
|
52
|
+
func IsExpression(node Node) bool {
|
|
53
|
+
k := kindOf(node)
|
|
54
|
+
return k >= KindFirstExpression && k <= KindLastExpression
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
// statements
|
|
58
|
+
func IsAssignment(node Node) bool { return kindOf(node) == KindAssignment }
|
|
59
|
+
func IsBreakStatement(node Node) bool { return kindOf(node) == KindBreakStatement }
|
|
60
|
+
func IsCallStatement(node Node) bool { return kindOf(node) == KindCallStatement }
|
|
61
|
+
func IsContinueStatement(node Node) bool { return kindOf(node) == KindContinueStatement }
|
|
62
|
+
func IsDoStatement(node Node) bool { return kindOf(node) == KindDoStatement }
|
|
63
|
+
func IsWhileStatement(node Node) bool { return kindOf(node) == KindWhileStatement }
|
|
64
|
+
func IsRepeatStatement(node Node) bool { return kindOf(node) == KindRepeatStatement }
|
|
65
|
+
func IsIfStatement(node Node) bool { return kindOf(node) == KindIfStatement }
|
|
66
|
+
func IsNumericForStatement(node Node) bool { return kindOf(node) == KindNumericForStatement }
|
|
67
|
+
func IsForStatement(node Node) bool { return kindOf(node) == KindForStatement }
|
|
68
|
+
func IsFunctionDeclaration(node Node) bool { return kindOf(node) == KindFunctionDeclaration }
|
|
69
|
+
func IsMethodDeclaration(node Node) bool { return kindOf(node) == KindMethodDeclaration }
|
|
70
|
+
func IsVariableDeclaration(node Node) bool { return kindOf(node) == KindVariableDeclaration }
|
|
71
|
+
func IsReturnStatement(node Node) bool { return kindOf(node) == KindReturnStatement }
|
|
72
|
+
func IsComment(node Node) bool { return kindOf(node) == KindComment }
|
|
73
|
+
|
|
74
|
+
func IsStatement(node Node) bool {
|
|
75
|
+
k := kindOf(node)
|
|
76
|
+
return k >= KindFirstStatement && k <= KindLastStatement
|
|
77
|
+
}
|
|
78
|
+
|
|
79
|
+
// fields
|
|
80
|
+
func IsMapField(node Node) bool { return kindOf(node) == KindMapField }
|
|
81
|
+
func IsInterpolatedStringPart(node Node) bool { return kindOf(node) == KindInterpolatedStringPart }
|
|
82
|
+
|
|
83
|
+
func IsField(node Node) bool {
|
|
84
|
+
k := kindOf(node)
|
|
85
|
+
return k >= KindFirstField && k <= KindLastField
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// IsNode reports whether v is a node (upstream checks for a numeric kind in
|
|
89
|
+
// range; here that is any non-nil Node).
|
|
90
|
+
func IsNode(v NodeOrList) bool {
|
|
91
|
+
n, ok := v.(Node)
|
|
92
|
+
return ok && n != nil
|
|
93
|
+
}
|
|
94
|
+
|
|
95
|
+
// IsSimple is Identifier, TemporaryIdentifier, nil, true, false, number or string literals.
|
|
96
|
+
func IsSimple(node Node) bool {
|
|
97
|
+
switch kindOf(node) {
|
|
98
|
+
case KindIdentifier, KindTemporaryIdentifier, KindNilLiteral, KindTrueLiteral, KindFalseLiteral,
|
|
99
|
+
KindNumberLiteral, KindStringLiteral:
|
|
100
|
+
return true
|
|
101
|
+
}
|
|
102
|
+
return false
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
// IsSimplePrimitive is nil, true, false, number or string literals.
|
|
106
|
+
func IsSimplePrimitive(node Node) bool {
|
|
107
|
+
switch kindOf(node) {
|
|
108
|
+
case KindNilLiteral, KindTrueLiteral, KindFalseLiteral, KindNumberLiteral, KindStringLiteral:
|
|
109
|
+
return true
|
|
110
|
+
}
|
|
111
|
+
return false
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
// IsTable is Array, Set, Map or MixedTable.
|
|
115
|
+
func IsTable(node Node) bool {
|
|
116
|
+
switch kindOf(node) {
|
|
117
|
+
case KindArray, KindSet, KindMap, KindMixedTable:
|
|
118
|
+
return true
|
|
119
|
+
}
|
|
120
|
+
return false
|
|
121
|
+
}
|
|
122
|
+
|
|
123
|
+
// IsFinalStatement is break, return or continue.
|
|
124
|
+
func IsFinalStatement(node Node) bool {
|
|
125
|
+
switch kindOf(node) {
|
|
126
|
+
case KindBreakStatement, KindReturnStatement, KindContinueStatement:
|
|
127
|
+
return true
|
|
128
|
+
}
|
|
129
|
+
return false
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
// IsCall is CallExpression or MethodCallExpression.
|
|
133
|
+
func IsCall(node Node) bool {
|
|
134
|
+
k := kindOf(node)
|
|
135
|
+
return k == KindCallExpression || k == KindMethodCallExpression
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
// IsWritableExpression is Identifier, TemporaryIdentifier, PropertyAccessExpression or ComputedIndexExpression.
|
|
139
|
+
func IsWritableExpression(node Node) bool {
|
|
140
|
+
switch kindOf(node) {
|
|
141
|
+
case KindIdentifier, KindTemporaryIdentifier, KindPropertyAccessExpression, KindComputedIndexExpression:
|
|
142
|
+
return true
|
|
143
|
+
}
|
|
144
|
+
return false
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
// IsFunctionLike is FunctionDeclaration, FunctionExpression or MethodDeclaration.
|
|
148
|
+
func IsFunctionLike(node Node) bool {
|
|
149
|
+
switch kindOf(node) {
|
|
150
|
+
case KindFunctionDeclaration, KindFunctionExpression, KindMethodDeclaration:
|
|
151
|
+
return true
|
|
152
|
+
}
|
|
153
|
+
return false
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
// HasStatementsKind reports whether node is a kind that owns a statement
|
|
157
|
+
// list (upstream hasStatements).
|
|
158
|
+
func HasStatementsKind(node Node) bool {
|
|
159
|
+
switch kindOf(node) {
|
|
160
|
+
case KindForStatement, KindNumericForStatement, KindFunctionExpression, KindDoStatement,
|
|
161
|
+
KindFunctionDeclaration, KindIfStatement, KindMethodDeclaration, KindRepeatStatement,
|
|
162
|
+
KindWhileStatement:
|
|
163
|
+
return true
|
|
164
|
+
}
|
|
165
|
+
return false
|
|
166
|
+
}
|
|
167
|
+
|
|
168
|
+
// IsExpressionWithPrecedence is IfExpression, UnaryExpression or BinaryExpression.
|
|
169
|
+
func IsExpressionWithPrecedence(node Node) bool {
|
|
170
|
+
switch kindOf(node) {
|
|
171
|
+
case KindIfExpression, KindUnaryExpression, KindBinaryExpression:
|
|
172
|
+
return true
|
|
173
|
+
}
|
|
174
|
+
return false
|
|
175
|
+
}
|
package/luau/util.go
ADDED
|
@@ -0,0 +1,184 @@
|
|
|
1
|
+
package luau
|
|
2
|
+
|
|
3
|
+
// Ported from src/LuauAST/util/assert.ts, isMetamethod.ts,
|
|
4
|
+
// isReservedClassField.ts, isReservedIdentifier.ts, isValidIdentifier.ts and
|
|
5
|
+
// isValidNumberLiteral.ts.
|
|
6
|
+
|
|
7
|
+
// AssertionError is the panic value Assert raises. Upstream throws an Error
|
|
8
|
+
// with the same message; treat it as a compiler bug.
|
|
9
|
+
type AssertionError struct {
|
|
10
|
+
Message string
|
|
11
|
+
}
|
|
12
|
+
|
|
13
|
+
func (e *AssertionError) Error() string {
|
|
14
|
+
return "Assertion Failed! " + e.Message +
|
|
15
|
+
"\nThis is a compiler bug! Please submit a bug report here:" +
|
|
16
|
+
"\nhttps://github.com/roblox-ts/roblox-ts/issues"
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
// Assert panics with *AssertionError when ok is false (upstream assert).
|
|
20
|
+
func Assert(ok bool, message string) {
|
|
21
|
+
if !ok {
|
|
22
|
+
panic(&AssertionError{Message: message})
|
|
23
|
+
}
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
// IsMetamethod returns true if the given string is a valid Luau metamethod.
|
|
27
|
+
func IsMetamethod(id string) bool {
|
|
28
|
+
switch id {
|
|
29
|
+
case "__index", "__newindex", "__call", "__concat", "__unm", "__add", "__sub", "__mul", "__div",
|
|
30
|
+
"__mod", "__pow", "__tostring", "__metatable", "__eq", "__lt", "__le", "__mode", "__gc", "__len":
|
|
31
|
+
return true
|
|
32
|
+
}
|
|
33
|
+
return false
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
// IsReservedClassField reports whether id is "__index" or "new".
|
|
37
|
+
func IsReservedClassField(id string) bool {
|
|
38
|
+
return id == "__index" || id == "new"
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
// IsReservedIdentifier reports whether id is a key of Globals (upstream
|
|
42
|
+
// hasOwnProperty on the globals object).
|
|
43
|
+
func IsReservedIdentifier(id string) bool {
|
|
44
|
+
switch id {
|
|
45
|
+
case "_G", "TS", "assert", "bit32", "coroutine", "error", "exports", "getmetatable", "ipairs", "next",
|
|
46
|
+
"pairs", "pcall", "require", "script", "select", "self", "setmetatable", "string", "super", "table",
|
|
47
|
+
"utf8", "math", "tostring", "type", "typeof", "unpack", "game":
|
|
48
|
+
return true
|
|
49
|
+
}
|
|
50
|
+
return false
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
func isLuauKeyword(id string) bool {
|
|
54
|
+
switch id {
|
|
55
|
+
case "and", "break", "do", "else", "elseif", "end", "false", "for", "function", "if", "in", "local",
|
|
56
|
+
"nil", "not", "or", "repeat", "return", "then", "true", "until", "while":
|
|
57
|
+
return true
|
|
58
|
+
}
|
|
59
|
+
return false
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
// IsValidIdentifier returns true if the given string is a valid Luau
|
|
63
|
+
// identifier, and does not conflict with a keyword. Equivalent to
|
|
64
|
+
// /^[A-Za-z_][A-Za-z0-9_]*$/ plus the keyword check.
|
|
65
|
+
func IsValidIdentifier(id string) bool {
|
|
66
|
+
if len(id) == 0 {
|
|
67
|
+
return false
|
|
68
|
+
}
|
|
69
|
+
for i := 0; i < len(id); i++ {
|
|
70
|
+
c := id[i]
|
|
71
|
+
if c == '_' || (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') {
|
|
72
|
+
continue
|
|
73
|
+
}
|
|
74
|
+
if i > 0 && c >= '0' && c <= '9' {
|
|
75
|
+
continue
|
|
76
|
+
}
|
|
77
|
+
return false
|
|
78
|
+
}
|
|
79
|
+
return !isLuauKeyword(id)
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
func isDigit(c byte) bool { return c >= '0' && c <= '9' }
|
|
83
|
+
|
|
84
|
+
func isHexDigit(c byte) bool {
|
|
85
|
+
return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// skipDigitsUnderscores returns the index after any run of [0-9_] at s[i:].
|
|
89
|
+
func skipDigitsUnderscores(s string, i int) int {
|
|
90
|
+
for i < len(s) && (isDigit(s[i]) || s[i] == '_') {
|
|
91
|
+
i++
|
|
92
|
+
}
|
|
93
|
+
return i
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
// IsValidNumberLiteral reports whether text is a Luau number literal.
|
|
97
|
+
// Equivalent to the union of the upstream regexes:
|
|
98
|
+
//
|
|
99
|
+
// decimal: /^(?:\d[\d_]*(?:\.[\d_]*)?|\.\d[\d_]*)(?:[eE][+-]?_*\d[\d_]*)?$/
|
|
100
|
+
// binary: /^0_*[bB]_*[01][01_]*$/
|
|
101
|
+
// hex: /^0_*[xX]_*[\da-fA-F][\da-fA-F_]*$/
|
|
102
|
+
func IsValidNumberLiteral(s string) bool {
|
|
103
|
+
return isDecimalLiteral(s) || isBinaryLiteral(s) || isHexLiteral(s)
|
|
104
|
+
}
|
|
105
|
+
|
|
106
|
+
func isDecimalLiteral(s string) bool {
|
|
107
|
+
i := 0
|
|
108
|
+
switch {
|
|
109
|
+
case i < len(s) && isDigit(s[i]):
|
|
110
|
+
i = skipDigitsUnderscores(s, i+1)
|
|
111
|
+
if i < len(s) && s[i] == '.' {
|
|
112
|
+
i = skipDigitsUnderscores(s, i+1)
|
|
113
|
+
}
|
|
114
|
+
case i < len(s) && s[i] == '.' && i+1 < len(s) && isDigit(s[i+1]):
|
|
115
|
+
i = skipDigitsUnderscores(s, i+2)
|
|
116
|
+
default:
|
|
117
|
+
return false
|
|
118
|
+
}
|
|
119
|
+
if i == len(s) {
|
|
120
|
+
return true
|
|
121
|
+
}
|
|
122
|
+
if s[i] != 'e' && s[i] != 'E' {
|
|
123
|
+
return false
|
|
124
|
+
}
|
|
125
|
+
i++
|
|
126
|
+
if i < len(s) && (s[i] == '+' || s[i] == '-') {
|
|
127
|
+
i++
|
|
128
|
+
}
|
|
129
|
+
for i < len(s) && s[i] == '_' {
|
|
130
|
+
i++
|
|
131
|
+
}
|
|
132
|
+
if i >= len(s) || !isDigit(s[i]) {
|
|
133
|
+
return false
|
|
134
|
+
}
|
|
135
|
+
i = skipDigitsUnderscores(s, i+1)
|
|
136
|
+
return i == len(s)
|
|
137
|
+
}
|
|
138
|
+
|
|
139
|
+
func skipChar(s string, i int, c byte) int {
|
|
140
|
+
for i < len(s) && s[i] == c {
|
|
141
|
+
i++
|
|
142
|
+
}
|
|
143
|
+
return i
|
|
144
|
+
}
|
|
145
|
+
|
|
146
|
+
func isBinaryLiteral(s string) bool {
|
|
147
|
+
if len(s) == 0 || s[0] != '0' {
|
|
148
|
+
return false
|
|
149
|
+
}
|
|
150
|
+
i := skipChar(s, 1, '_')
|
|
151
|
+
if i >= len(s) || (s[i] != 'b' && s[i] != 'B') {
|
|
152
|
+
return false
|
|
153
|
+
}
|
|
154
|
+
i = skipChar(s, i+1, '_')
|
|
155
|
+
if i >= len(s) || (s[i] != '0' && s[i] != '1') {
|
|
156
|
+
return false
|
|
157
|
+
}
|
|
158
|
+
for i++; i < len(s); i++ {
|
|
159
|
+
if s[i] != '0' && s[i] != '1' && s[i] != '_' {
|
|
160
|
+
return false
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
return true
|
|
164
|
+
}
|
|
165
|
+
|
|
166
|
+
func isHexLiteral(s string) bool {
|
|
167
|
+
if len(s) == 0 || s[0] != '0' {
|
|
168
|
+
return false
|
|
169
|
+
}
|
|
170
|
+
i := skipChar(s, 1, '_')
|
|
171
|
+
if i >= len(s) || (s[i] != 'x' && s[i] != 'X') {
|
|
172
|
+
return false
|
|
173
|
+
}
|
|
174
|
+
i = skipChar(s, i+1, '_')
|
|
175
|
+
if i >= len(s) || !isHexDigit(s[i]) {
|
|
176
|
+
return false
|
|
177
|
+
}
|
|
178
|
+
for i++; i < len(s); i++ {
|
|
179
|
+
if !isHexDigit(s[i]) && s[i] != '_' {
|
|
180
|
+
return false
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
return true
|
|
184
|
+
}
|
package/luau/visit.go
ADDED
|
@@ -0,0 +1,138 @@
|
|
|
1
|
+
package luau
|
|
2
|
+
|
|
3
|
+
// Ported from src/LuauRenderer/util/visit.ts.
|
|
4
|
+
|
|
5
|
+
// Visitor holds the callbacks Visit calls around every node, in tree order.
|
|
6
|
+
// Either may be nil.
|
|
7
|
+
type Visitor struct {
|
|
8
|
+
Before func(node Node)
|
|
9
|
+
After func(node Node)
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
func visitList(list *List, visitor *Visitor) {
|
|
13
|
+
for ln := list.Head; ln != nil; ln = ln.Next {
|
|
14
|
+
visitNode(ln.Value, visitor)
|
|
15
|
+
}
|
|
16
|
+
}
|
|
17
|
+
|
|
18
|
+
func visitNodeOrList(v NodeOrList, visitor *Visitor) {
|
|
19
|
+
switch x := v.(type) {
|
|
20
|
+
case nil:
|
|
21
|
+
case *List:
|
|
22
|
+
visitList(x, visitor)
|
|
23
|
+
case Node:
|
|
24
|
+
visitNode(x, visitor)
|
|
25
|
+
}
|
|
26
|
+
}
|
|
27
|
+
|
|
28
|
+
func visitNode(node Node, visitor *Visitor) {
|
|
29
|
+
if visitor.Before != nil {
|
|
30
|
+
visitor.Before(node)
|
|
31
|
+
}
|
|
32
|
+
|
|
33
|
+
switch n := node.(type) {
|
|
34
|
+
// indexable expressions
|
|
35
|
+
case *ComputedIndexExpression:
|
|
36
|
+
visitNode(n.Expression, visitor)
|
|
37
|
+
visitNode(n.Index, visitor)
|
|
38
|
+
case *PropertyAccessExpression:
|
|
39
|
+
visitNode(n.Expression, visitor)
|
|
40
|
+
case *CallExpression:
|
|
41
|
+
visitNode(n.Expression, visitor)
|
|
42
|
+
visitList(n.Args, visitor)
|
|
43
|
+
case *MethodCallExpression:
|
|
44
|
+
visitNode(n.Expression, visitor)
|
|
45
|
+
visitList(n.Args, visitor)
|
|
46
|
+
case *ParenthesizedExpression:
|
|
47
|
+
visitNode(n.Expression, visitor)
|
|
48
|
+
|
|
49
|
+
// expressions
|
|
50
|
+
case *FunctionExpression:
|
|
51
|
+
visitList(n.Parameters, visitor)
|
|
52
|
+
visitList(n.Statements, visitor)
|
|
53
|
+
case *BinaryExpression:
|
|
54
|
+
visitNode(n.Left, visitor)
|
|
55
|
+
visitNode(n.Right, visitor)
|
|
56
|
+
case *UnaryExpression:
|
|
57
|
+
visitNode(n.Expression, visitor)
|
|
58
|
+
case *IfExpression:
|
|
59
|
+
visitNode(n.Condition, visitor)
|
|
60
|
+
visitNode(n.Expression, visitor)
|
|
61
|
+
visitNode(n.Alternative, visitor)
|
|
62
|
+
case *InterpolatedString:
|
|
63
|
+
visitList(n.Parts, visitor)
|
|
64
|
+
case *Array:
|
|
65
|
+
visitList(n.Members, visitor)
|
|
66
|
+
case *Map:
|
|
67
|
+
visitList(n.Fields, visitor)
|
|
68
|
+
case *Set:
|
|
69
|
+
visitList(n.Members, visitor)
|
|
70
|
+
case *MixedTable:
|
|
71
|
+
visitList(n.Fields, visitor)
|
|
72
|
+
|
|
73
|
+
// statements
|
|
74
|
+
case *Assignment:
|
|
75
|
+
visitNodeOrList(n.Left, visitor)
|
|
76
|
+
visitNodeOrList(n.Right, visitor)
|
|
77
|
+
case *CallStatement:
|
|
78
|
+
visitNode(n.Expression, visitor)
|
|
79
|
+
case *DoStatement:
|
|
80
|
+
visitList(n.Statements, visitor)
|
|
81
|
+
case *WhileStatement:
|
|
82
|
+
visitNode(n.Condition, visitor)
|
|
83
|
+
visitList(n.Statements, visitor)
|
|
84
|
+
case *RepeatStatement:
|
|
85
|
+
visitList(n.Statements, visitor)
|
|
86
|
+
visitNode(n.Condition, visitor)
|
|
87
|
+
case *IfStatement:
|
|
88
|
+
visitNode(n.Condition, visitor)
|
|
89
|
+
visitList(n.Statements, visitor)
|
|
90
|
+
visitNodeOrList(n.ElseBody, visitor)
|
|
91
|
+
case *NumericForStatement:
|
|
92
|
+
visitNode(n.ID, visitor)
|
|
93
|
+
visitNode(n.Start, visitor)
|
|
94
|
+
visitNode(n.End, visitor)
|
|
95
|
+
if n.Step != nil {
|
|
96
|
+
visitNode(n.Step, visitor)
|
|
97
|
+
}
|
|
98
|
+
visitList(n.Statements, visitor)
|
|
99
|
+
case *ForStatement:
|
|
100
|
+
visitList(n.IDs, visitor)
|
|
101
|
+
visitList(n.Statements, visitor)
|
|
102
|
+
case *FunctionDeclaration:
|
|
103
|
+
visitNode(n.Name, visitor)
|
|
104
|
+
visitList(n.Parameters, visitor)
|
|
105
|
+
visitList(n.Statements, visitor)
|
|
106
|
+
case *MethodDeclaration:
|
|
107
|
+
visitNode(n.Expression, visitor)
|
|
108
|
+
visitList(n.Parameters, visitor)
|
|
109
|
+
visitList(n.Statements, visitor)
|
|
110
|
+
case *VariableDeclaration:
|
|
111
|
+
visitNodeOrList(n.Left, visitor)
|
|
112
|
+
visitNodeOrList(n.Right, visitor)
|
|
113
|
+
case *ReturnStatement:
|
|
114
|
+
visitNodeOrList(n.Expression, visitor)
|
|
115
|
+
|
|
116
|
+
// fields
|
|
117
|
+
case *MapField:
|
|
118
|
+
visitNode(n.Index, visitor)
|
|
119
|
+
visitNode(n.Value, visitor)
|
|
120
|
+
|
|
121
|
+
// All other kinds (identifiers, literals, break, continue, comment,
|
|
122
|
+
// None, InterpolatedStringPart) have no children.
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
if visitor.After != nil {
|
|
126
|
+
visitor.After(node)
|
|
127
|
+
}
|
|
128
|
+
}
|
|
129
|
+
|
|
130
|
+
// Visit walks an AST depth first, calling visitor.Before and visitor.After
|
|
131
|
+
// around each node. ast is a *List or a Node.
|
|
132
|
+
func Visit(ast NodeOrList, visitor *Visitor) {
|
|
133
|
+
if list, ok := ast.(*List); ok {
|
|
134
|
+
visitList(list, visitor)
|
|
135
|
+
} else if node, ok := ast.(Node); ok {
|
|
136
|
+
visitNode(node, visitor)
|
|
137
|
+
}
|
|
138
|
+
}
|
package/npm/index.d.ts
ADDED