@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.
Files changed (220) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +181 -2
  3. package/README.rbxtsgo.md +169 -0
  4. package/THIRD_PARTY_NOTICES.md +745 -0
  5. package/cli/cli.go +454 -0
  6. package/compile/compile.go +388 -0
  7. package/compile/declarations.go +221 -0
  8. package/compile/incremental.go +349 -0
  9. package/compile/times.go +9 -0
  10. package/docs/plugin-api.md +243 -0
  11. package/go.mod +20 -0
  12. package/go.sum +24 -0
  13. package/internal/difftest/difftest.go +530 -0
  14. package/internal/plugintest/plugintest.go +181 -0
  15. package/luau/create.go +351 -0
  16. package/luau/doc.go +71 -0
  17. package/luau/globals.go +178 -0
  18. package/luau/jsnum.go +188 -0
  19. package/luau/kinds.go +128 -0
  20. package/luau/list.go +227 -0
  21. package/luau/nodes.go +479 -0
  22. package/luau/operators.go +46 -0
  23. package/luau/render.go +134 -0
  24. package/luau/render_expressions.go +264 -0
  25. package/luau/render_fields.go +81 -0
  26. package/luau/render_indexable.go +81 -0
  27. package/luau/render_state.go +134 -0
  28. package/luau/render_statements.go +235 -0
  29. package/luau/render_util.go +296 -0
  30. package/luau/solve_temp_ids.go +212 -0
  31. package/luau/typeguards.go +175 -0
  32. package/luau/util.go +184 -0
  33. package/luau/visit.go +138 -0
  34. package/npm/index.d.ts +3 -0
  35. package/npm/rbxts-go.sh +187 -0
  36. package/package.json +45 -5
  37. package/patches/typescript/0001-checker-exports.patch +40 -0
  38. package/patches/typescript/0002-iterable-arity.patch +15 -0
  39. package/patches/typescript/0003-context-sensitive-this.patch +15 -0
  40. package/patches/typescript/0004-printer-keep-parse-tree-parentheses.patch +26 -0
  41. package/pluginapi/host.go +31 -0
  42. package/pluginapi/pluginapi.go +153 -0
  43. package/plugins/LICENSE-rbxts-transformer-setget +18 -0
  44. package/plugins/apply.go +342 -0
  45. package/plugins/config.go +431 -0
  46. package/plugins/fallback.go +84 -0
  47. package/plugins/fixemit.go +60 -0
  48. package/plugins/native.go +271 -0
  49. package/plugins/session.go +236 -0
  50. package/plugins/setget.go +478 -0
  51. package/project/copy.go +333 -0
  52. package/project/include/Promise.lua +2068 -0
  53. package/project/include/RuntimeLib.lua +260 -0
  54. package/project/nodepath/nodepath.go +917 -0
  55. package/project/pathtranslator/pathtranslator.go +214 -0
  56. package/project/project.go +498 -0
  57. package/project/rojoresolver/json.go +248 -0
  58. package/project/rojoresolver/rojoresolver.go +559 -0
  59. package/project/shared/constants.go +83 -0
  60. package/project/shared/diagnostic.go +238 -0
  61. package/project/shared/diagnostics.go +388 -0
  62. package/project/shared/elapsed.go +14 -0
  63. package/project/shared/eol_other.go +6 -0
  64. package/project/shared/eol_windows.go +4 -0
  65. package/project/shared/kleur.go +40 -0
  66. package/project/shared/util.go +183 -0
  67. package/scripts/build-with-plugins.sh +130 -0
  68. package/scripts/setup-third-party.sh +75 -0
  69. package/transformer/add_index_diagnostics.go +21 -0
  70. package/transformer/add_one_if_array_type.go +15 -0
  71. package/transformer/array_binding_pattern_contains_hoists.go +25 -0
  72. package/transformer/assert_never.go +24 -0
  73. package/transformer/assignment.go +64 -0
  74. package/transformer/call_macros.go +70 -0
  75. package/transformer/check_variable_hoist.go +125 -0
  76. package/transformer/clean_module_name.go +28 -0
  77. package/transformer/constructor_macros.go +122 -0
  78. package/transformer/convert_to_indexable_expression.go +12 -0
  79. package/transformer/create_binary_from_operator.go +86 -0
  80. package/transformer/create_continue_statements.go +68 -0
  81. package/transformer/create_get_service.go +15 -0
  82. package/transformer/create_hoist_declaration.go +27 -0
  83. package/transformer/create_import_expression.go +220 -0
  84. package/transformer/create_string_from_literal.go +195 -0
  85. package/transformer/create_truthiness_checks.go +63 -0
  86. package/transformer/create_type_check.go +9 -0
  87. package/transformer/ensure_transform_order.go +53 -0
  88. package/transformer/expression_chain.go +27 -0
  89. package/transformer/expression_might_mutate.go +60 -0
  90. package/transformer/find_constructor.go +15 -0
  91. package/transformer/fixup_whitespace_and_decode_entities.go +377 -0
  92. package/transformer/get_accessor_for_binding_type.go +160 -0
  93. package/transformer/get_add_iterable_to_array_builder.go +363 -0
  94. package/transformer/get_assignable_value.go +15 -0
  95. package/transformer/get_constant_value_literal.go +20 -0
  96. package/transformer/get_declared_variables.go +34 -0
  97. package/transformer/get_extends_node.go +23 -0
  98. package/transformer/get_flags.go +21 -0
  99. package/transformer/get_kind_name.go +18 -0
  100. package/transformer/get_original_symbol_of_node.go +16 -0
  101. package/transformer/get_source_file_from_module_specifier.go +68 -0
  102. package/transformer/get_statements.go +12 -0
  103. package/transformer/has_multiple_definitions.go +18 -0
  104. package/transformer/hoist_functions_past_final_statement.go +43 -0
  105. package/transformer/identifier_macros.go +17 -0
  106. package/transformer/is_blocked_by_try_statement.go +19 -0
  107. package/transformer/is_method.go +104 -0
  108. package/transformer/is_symbol_mutable.go +26 -0
  109. package/transformer/is_symbol_of_value.go +11 -0
  110. package/transformer/is_used_as_statement.go +25 -0
  111. package/transformer/is_valid_method_index_without_call.go +36 -0
  112. package/transformer/macro_manager.go +92 -0
  113. package/transformer/object_accessor.go +32 -0
  114. package/transformer/offset.go +58 -0
  115. package/transformer/pointer.go +53 -0
  116. package/transformer/property_call_macros.go +1035 -0
  117. package/transformer/state.go +606 -0
  118. package/transformer/transform_array_assignment_pattern.go +65 -0
  119. package/transformer/transform_array_binding_pattern.go +49 -0
  120. package/transformer/transform_array_literal_expression.go +97 -0
  121. package/transformer/transform_await_expression.go +12 -0
  122. package/transformer/transform_binary_expression.go +221 -0
  123. package/transformer/transform_binding_name.go +25 -0
  124. package/transformer/transform_block.go +14 -0
  125. package/transformer/transform_boolean_literal.go +13 -0
  126. package/transformer/transform_break_statement.go +26 -0
  127. package/transformer/transform_call_expression.go +266 -0
  128. package/transformer/transform_class_constructor.go +125 -0
  129. package/transformer/transform_class_declaration.go +12 -0
  130. package/transformer/transform_class_expression.go +14 -0
  131. package/transformer/transform_class_like_declaration.go +355 -0
  132. package/transformer/transform_conditional_expression.go +70 -0
  133. package/transformer/transform_continue_statement.go +30 -0
  134. package/transformer/transform_decorators.go +253 -0
  135. package/transformer/transform_delete_expression.go +17 -0
  136. package/transformer/transform_do_statement.go +39 -0
  137. package/transformer/transform_element_access_expression.go +114 -0
  138. package/transformer/transform_entity_name.go +21 -0
  139. package/transformer/transform_enum_declaration.go +135 -0
  140. package/transformer/transform_export_assignment.go +57 -0
  141. package/transformer/transform_export_declaration.go +150 -0
  142. package/transformer/transform_expression.go +120 -0
  143. package/transformer/transform_expression_statement.go +71 -0
  144. package/transformer/transform_for_of_statement.go +461 -0
  145. package/transformer/transform_for_statement.go +599 -0
  146. package/transformer/transform_function_declaration.go +84 -0
  147. package/transformer/transform_function_expression.go +48 -0
  148. package/transformer/transform_identifier.go +194 -0
  149. package/transformer/transform_if_statement.go +44 -0
  150. package/transformer/transform_import_declaration.go +146 -0
  151. package/transformer/transform_import_equals_declaration.go +46 -0
  152. package/transformer/transform_import_expression.go +36 -0
  153. package/transformer/transform_initializer.go +22 -0
  154. package/transformer/transform_interpolated_string_part.go +12 -0
  155. package/transformer/transform_jsx.go +41 -0
  156. package/transformer/transform_jsx_attributes.go +110 -0
  157. package/transformer/transform_jsx_children.go +50 -0
  158. package/transformer/transform_jsx_element.go +14 -0
  159. package/transformer/transform_jsx_expression.go +20 -0
  160. package/transformer/transform_jsx_fragment.go +42 -0
  161. package/transformer/transform_jsx_self_closing_element.go +13 -0
  162. package/transformer/transform_jsx_tag_name.go +53 -0
  163. package/transformer/transform_logical.go +160 -0
  164. package/transformer/transform_logical_or_coalescing_assignment_expression.go +103 -0
  165. package/transformer/transform_method_declaration.go +102 -0
  166. package/transformer/transform_module_declaration.go +143 -0
  167. package/transformer/transform_new_expression.go +27 -0
  168. package/transformer/transform_no_substitution_template_literal.go +16 -0
  169. package/transformer/transform_numeric_literal.go +15 -0
  170. package/transformer/transform_object_assignment_pattern.go +86 -0
  171. package/transformer/transform_object_binding_pattern.go +49 -0
  172. package/transformer/transform_object_literal_expression.go +107 -0
  173. package/transformer/transform_omitted_expression.go +9 -0
  174. package/transformer/transform_optional_chain.go +312 -0
  175. package/transformer/transform_parameters.go +124 -0
  176. package/transformer/transform_parenthesized_expression.go +17 -0
  177. package/transformer/transform_property_access_expression.go +37 -0
  178. package/transformer/transform_property_declaration.go +33 -0
  179. package/transformer/transform_property_name.go +20 -0
  180. package/transformer/transform_return_statement.go +83 -0
  181. package/transformer/transform_source_file.go +230 -0
  182. package/transformer/transform_spread_element.go +35 -0
  183. package/transformer/transform_statement.go +84 -0
  184. package/transformer/transform_statement_list.go +90 -0
  185. package/transformer/transform_string_literal.go +22 -0
  186. package/transformer/transform_super_keyword.go +9 -0
  187. package/transformer/transform_switch_statement.go +145 -0
  188. package/transformer/transform_tagged_template_expression.go +34 -0
  189. package/transformer/transform_template_expression.go +35 -0
  190. package/transformer/transform_this_expression.go +33 -0
  191. package/transformer/transform_throw_statement.go +18 -0
  192. package/transformer/transform_try_statement.go +192 -0
  193. package/transformer/transform_type_expression.go +12 -0
  194. package/transformer/transform_unary_expression.go +79 -0
  195. package/transformer/transform_variable_statement.go +178 -0
  196. package/transformer/transform_void_expression.go +13 -0
  197. package/transformer/transform_while_statement.go +34 -0
  198. package/transformer/transform_writable.go +69 -0
  199. package/transformer/transform_yield_expression.go +56 -0
  200. package/transformer/type_guards.go +30 -0
  201. package/transformer/types.go +381 -0
  202. package/transformer/validate_identifier.go +17 -0
  203. package/transformer/validate_method_assignment.go +106 -0
  204. package/transformer/validate_not_any.go +37 -0
  205. package/transformer/wrap_expression_statement.go +20 -0
  206. package/transformer/wrap_return_if_lua_tuple.go +63 -0
  207. package/transformer/wrap_statements_as_generator.go +22 -0
  208. package/tsbridge/affected.go +141 -0
  209. package/tsbridge/config.go +71 -0
  210. package/tsbridge/diagnostics.go +128 -0
  211. package/tsbridge/doc.go +16 -0
  212. package/tsbridge/macros.go +207 -0
  213. package/tsbridge/macrospec.go +30 -0
  214. package/tsbridge/pool.go +142 -0
  215. package/tsbridge/project.go +137 -0
  216. package/tsbridge/reprint.go +120 -0
  217. package/tsbridge/update.go +128 -0
  218. package/watch/poll.go +126 -0
  219. package/watch/session.go +651 -0
  220. 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
@@ -0,0 +1,3 @@
1
+ // @data-vegle/rbxts-go has no types of its own. This file is here because roblox-ts projects list
2
+ // node_modules/@data-vegle in typeRoots, which makes TypeScript load every package of that folder as a type library.
3
+ export {};