mirror of
https://github.com/oven-sh/bun
synced 2026-02-11 11:29:02 +00:00
Split JS parser into multiple files (#20880)
Splits up js_parser.zig into multiple files. Also changes visitExprInOut to use function calls rather than switch Not ready: - [ ] P.zig is ~70,000 tokens, still needs to get smaller - [x] ~~measure zig build time before & after (is it slower?)~~ no significant impact --------- Co-authored-by: pfgithub <6010774+pfgithub@users.noreply.github.com>
This commit is contained in:
pfg
556
src/ast/parseProperty.zig
Normal file
556
src/ast/parseProperty.zig
Normal file
@@ -0,0 +1,556 @@
|
||||
pub fn ParseProperty(
|
||||
comptime parser_feature__typescript: bool,
|
||||
comptime parser_feature__jsx: JSXTransformType,
|
||||
comptime parser_feature__scan_only: bool,
|
||||
) type {
|
||||
return struct {
|
||||
const P = js_parser.NewParser_(parser_feature__typescript, parser_feature__jsx, parser_feature__scan_only);
|
||||
const is_typescript_enabled = P.is_typescript_enabled;
|
||||
|
||||
pub fn parseProperty(p: *P, kind: Property.Kind, opts: *PropertyOpts, errors: ?*DeferredErrors) anyerror!?G.Property {
|
||||
var key: Expr = Expr{ .loc = logger.Loc.Empty, .data = .{ .e_missing = E.Missing{} } };
|
||||
const key_range = p.lexer.range();
|
||||
var is_computed = false;
|
||||
|
||||
switch (p.lexer.token) {
|
||||
.t_numeric_literal => {
|
||||
key = p.newExpr(E.Number{
|
||||
.value = p.lexer.number,
|
||||
}, p.lexer.loc());
|
||||
// p.checkForLegacyOctalLiteral()
|
||||
try p.lexer.next();
|
||||
},
|
||||
.t_string_literal => {
|
||||
key = try p.parseStringLiteral();
|
||||
},
|
||||
.t_big_integer_literal => {
|
||||
key = p.newExpr(E.BigInt{ .value = p.lexer.identifier }, p.lexer.loc());
|
||||
// markSyntaxFeature
|
||||
try p.lexer.next();
|
||||
},
|
||||
.t_private_identifier => {
|
||||
if (!opts.is_class or opts.ts_decorators.len > 0) {
|
||||
try p.lexer.expected(.t_identifier);
|
||||
}
|
||||
|
||||
key = p.newExpr(E.PrivateIdentifier{ .ref = p.storeNameInRef(p.lexer.identifier) catch unreachable }, p.lexer.loc());
|
||||
try p.lexer.next();
|
||||
},
|
||||
.t_open_bracket => {
|
||||
is_computed = true;
|
||||
// p.markSyntaxFeature(compat.objectExtensions, p.lexer.range())
|
||||
try p.lexer.next();
|
||||
const wasIdentifier = p.lexer.token == .t_identifier;
|
||||
const expr = try p.parseExpr(.comma);
|
||||
|
||||
if (comptime is_typescript_enabled) {
|
||||
|
||||
// Handle index signatures
|
||||
if (p.lexer.token == .t_colon and wasIdentifier and opts.is_class) {
|
||||
switch (expr.data) {
|
||||
.e_identifier => {
|
||||
try p.lexer.next();
|
||||
try p.skipTypeScriptType(.lowest);
|
||||
try p.lexer.expect(.t_close_bracket);
|
||||
try p.lexer.expect(.t_colon);
|
||||
try p.skipTypeScriptType(.lowest);
|
||||
try p.lexer.expectOrInsertSemicolon();
|
||||
|
||||
// Skip this property entirely
|
||||
return null;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try p.lexer.expect(.t_close_bracket);
|
||||
key = expr;
|
||||
},
|
||||
.t_asterisk => {
|
||||
if (kind != .normal or opts.is_generator) {
|
||||
try p.lexer.unexpected();
|
||||
return error.SyntaxError;
|
||||
}
|
||||
|
||||
try p.lexer.next();
|
||||
opts.is_generator = true;
|
||||
return try p.parseProperty(.normal, opts, errors);
|
||||
},
|
||||
|
||||
else => {
|
||||
const name = p.lexer.identifier;
|
||||
const raw = p.lexer.raw();
|
||||
const name_range = p.lexer.range();
|
||||
|
||||
if (!p.lexer.isIdentifierOrKeyword()) {
|
||||
try p.lexer.expect(.t_identifier);
|
||||
}
|
||||
|
||||
try p.lexer.next();
|
||||
|
||||
// Support contextual keywords
|
||||
if (kind == .normal and !opts.is_generator) {
|
||||
// Does the following token look like a key?
|
||||
const couldBeModifierKeyword = p.lexer.isIdentifierOrKeyword() or switch (p.lexer.token) {
|
||||
.t_open_bracket, .t_numeric_literal, .t_string_literal, .t_asterisk, .t_private_identifier => true,
|
||||
else => false,
|
||||
};
|
||||
|
||||
// If so, check for a modifier keyword
|
||||
if (couldBeModifierKeyword) {
|
||||
// TODO: micro-optimization, use a smaller list for non-typescript files.
|
||||
if (js_lexer.PropertyModifierKeyword.List.get(name)) |keyword| {
|
||||
switch (keyword) {
|
||||
.p_get => {
|
||||
if (!opts.is_async and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == .p_get) {
|
||||
// p.markSyntaxFeature(ObjectAccessors, name_range)
|
||||
return try p.parseProperty(.get, opts, null);
|
||||
}
|
||||
},
|
||||
|
||||
.p_set => {
|
||||
if (!opts.is_async and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == .p_set) {
|
||||
// p.markSyntaxFeature(ObjectAccessors, name_range)
|
||||
return try p.parseProperty(.set, opts, null);
|
||||
}
|
||||
},
|
||||
.p_async => {
|
||||
if (!opts.is_async and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == .p_async and !p.lexer.has_newline_before) {
|
||||
opts.is_async = true;
|
||||
opts.async_range = name_range;
|
||||
|
||||
// p.markSyntaxFeature(ObjectAccessors, name_range)
|
||||
return try p.parseProperty(kind, opts, null);
|
||||
}
|
||||
},
|
||||
.p_static => {
|
||||
if (!opts.is_static and !opts.is_async and opts.is_class and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_get) == .p_static) {
|
||||
opts.is_static = true;
|
||||
return try p.parseProperty(kind, opts, null);
|
||||
}
|
||||
},
|
||||
.p_declare => {
|
||||
// skip declare keyword entirely
|
||||
// https://github.com/oven-sh/bun/issues/1907
|
||||
if (opts.is_class and is_typescript_enabled and strings.eqlComptime(raw, "declare")) {
|
||||
const scope_index = p.scopes_in_order.items.len;
|
||||
if (try p.parseProperty(kind, opts, null)) |_prop| {
|
||||
var prop = _prop;
|
||||
if (prop.kind == .normal and prop.value == null and opts.ts_decorators.len > 0) {
|
||||
prop.kind = .declare;
|
||||
return prop;
|
||||
}
|
||||
}
|
||||
|
||||
p.discardScopesUpTo(scope_index);
|
||||
return null;
|
||||
}
|
||||
},
|
||||
.p_abstract => {
|
||||
if (opts.is_class and is_typescript_enabled and !opts.is_ts_abstract and strings.eqlComptime(raw, "abstract")) {
|
||||
opts.is_ts_abstract = true;
|
||||
const scope_index = p.scopes_in_order.items.len;
|
||||
if (try p.parseProperty(kind, opts, null)) |_prop| {
|
||||
var prop = _prop;
|
||||
if (prop.kind == .normal and prop.value == null and opts.ts_decorators.len > 0) {
|
||||
prop.kind = .abstract;
|
||||
return prop;
|
||||
}
|
||||
}
|
||||
p.discardScopesUpTo(scope_index);
|
||||
return null;
|
||||
}
|
||||
},
|
||||
.p_private, .p_protected, .p_public, .p_readonly, .p_override => {
|
||||
// Skip over TypeScript keywords
|
||||
if (opts.is_class and is_typescript_enabled and (js_lexer.PropertyModifierKeyword.List.get(raw) orelse .p_static) == keyword) {
|
||||
return try p.parseProperty(kind, opts, null);
|
||||
}
|
||||
},
|
||||
}
|
||||
}
|
||||
} else if (p.lexer.token == .t_open_brace and strings.eqlComptime(name, "static")) {
|
||||
const loc = p.lexer.loc();
|
||||
try p.lexer.next();
|
||||
|
||||
const old_fn_or_arrow_data_parse = p.fn_or_arrow_data_parse;
|
||||
p.fn_or_arrow_data_parse = .{
|
||||
.is_return_disallowed = true,
|
||||
.allow_super_property = true,
|
||||
.allow_await = .forbid_all,
|
||||
};
|
||||
|
||||
_ = try p.pushScopeForParsePass(.class_static_init, loc);
|
||||
var _parse_opts = ParseStatementOptions{};
|
||||
const stmts = try p.parseStmtsUpTo(.t_close_brace, &_parse_opts);
|
||||
|
||||
p.popScope();
|
||||
|
||||
p.fn_or_arrow_data_parse = old_fn_or_arrow_data_parse;
|
||||
try p.lexer.expect(.t_close_brace);
|
||||
|
||||
const block = p.allocator.create(
|
||||
G.ClassStaticBlock,
|
||||
) catch unreachable;
|
||||
|
||||
block.* = G.ClassStaticBlock{
|
||||
.stmts = js_ast.BabyList(Stmt).init(stmts),
|
||||
.loc = loc,
|
||||
};
|
||||
|
||||
return G.Property{
|
||||
.kind = .class_static_block,
|
||||
.class_static_block = block,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
// Handle invalid identifiers in property names
|
||||
// https://github.com/oven-sh/bun/issues/12039
|
||||
if (p.lexer.token == .t_syntax_error) {
|
||||
p.log.addRangeErrorFmt(p.source, name_range, p.allocator, "Unexpected {}", .{bun.fmt.quote(name)}) catch bun.outOfMemory();
|
||||
return error.SyntaxError;
|
||||
}
|
||||
|
||||
key = p.newExpr(E.String{ .data = name }, name_range.loc);
|
||||
|
||||
// Parse a shorthand property
|
||||
const isShorthandProperty = !opts.is_class and
|
||||
kind == .normal and
|
||||
p.lexer.token != .t_colon and
|
||||
p.lexer.token != .t_open_paren and
|
||||
p.lexer.token != .t_less_than and
|
||||
!opts.is_generator and
|
||||
!opts.is_async and
|
||||
!js_lexer.Keywords.has(name);
|
||||
|
||||
if (isShorthandProperty) {
|
||||
if ((p.fn_or_arrow_data_parse.allow_await != .allow_ident and
|
||||
strings.eqlComptime(name, "await")) or
|
||||
(p.fn_or_arrow_data_parse.allow_yield != .allow_ident and
|
||||
strings.eqlComptime(name, "yield")))
|
||||
{
|
||||
if (strings.eqlComptime(name, "await")) {
|
||||
p.log.addRangeError(p.source, name_range, "Cannot use \"await\" here") catch unreachable;
|
||||
} else {
|
||||
p.log.addRangeError(p.source, name_range, "Cannot use \"yield\" here") catch unreachable;
|
||||
}
|
||||
}
|
||||
|
||||
const ref = p.storeNameInRef(name) catch unreachable;
|
||||
const value = p.newExpr(E.Identifier{ .ref = ref }, key.loc);
|
||||
|
||||
// Destructuring patterns have an optional default value
|
||||
var initializer: ?Expr = null;
|
||||
if (errors != null and p.lexer.token == .t_equals) {
|
||||
errors.?.invalid_expr_default_value = p.lexer.range();
|
||||
try p.lexer.next();
|
||||
initializer = try p.parseExpr(.comma);
|
||||
}
|
||||
|
||||
return G.Property{
|
||||
.kind = kind,
|
||||
.key = key,
|
||||
.value = value,
|
||||
.initializer = initializer,
|
||||
.flags = Flags.Property.init(.{
|
||||
.was_shorthand = true,
|
||||
}),
|
||||
};
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
var has_type_parameters = false;
|
||||
var has_definite_assignment_assertion_operator = false;
|
||||
|
||||
if (comptime is_typescript_enabled) {
|
||||
if (opts.is_class) {
|
||||
if (p.lexer.token == .t_question) {
|
||||
// "class X { foo?: number }"
|
||||
// "class X { foo!: number }"
|
||||
try p.lexer.next();
|
||||
} else if (p.lexer.token == .t_exclamation and
|
||||
!p.lexer.has_newline_before and
|
||||
kind == .normal and
|
||||
!opts.is_async and
|
||||
!opts.is_generator)
|
||||
{
|
||||
// "class X { foo!: number }"
|
||||
try p.lexer.next();
|
||||
has_definite_assignment_assertion_operator = true;
|
||||
}
|
||||
}
|
||||
|
||||
// "class X { foo?<T>(): T }"
|
||||
// "const x = { foo<T>(): T {} }"
|
||||
if (!has_definite_assignment_assertion_operator) {
|
||||
has_type_parameters = try p.skipTypeScriptTypeParameters(.{ .allow_const_modifier = true }) != .did_not_skip_anything;
|
||||
}
|
||||
}
|
||||
|
||||
// Parse a class field with an optional initial value
|
||||
if (opts.is_class and
|
||||
kind == .normal and !opts.is_async and
|
||||
!opts.is_generator and
|
||||
p.lexer.token != .t_open_paren and
|
||||
!has_type_parameters and
|
||||
(p.lexer.token != .t_open_paren or has_definite_assignment_assertion_operator))
|
||||
{
|
||||
var initializer: ?Expr = null;
|
||||
var ts_metadata = TypeScript.Metadata.default;
|
||||
|
||||
// Forbid the names "constructor" and "prototype" in some cases
|
||||
if (!is_computed) {
|
||||
switch (key.data) {
|
||||
.e_string => |str| {
|
||||
if (str.eqlComptime("constructor") or (opts.is_static and str.eqlComptime("prototype"))) {
|
||||
// TODO: fmt error message to include string value.
|
||||
p.log.addRangeError(p.source, key_range, "Invalid field name") catch unreachable;
|
||||
}
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
|
||||
if (comptime is_typescript_enabled) {
|
||||
// Skip over types
|
||||
if (p.lexer.token == .t_colon) {
|
||||
try p.lexer.next();
|
||||
if (p.options.features.emit_decorator_metadata and opts.is_class and opts.ts_decorators.len > 0) {
|
||||
ts_metadata = try p.skipTypeScriptTypeWithMetadata(.lowest);
|
||||
} else {
|
||||
try p.skipTypeScriptType(.lowest);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (p.lexer.token == .t_equals) {
|
||||
if (comptime is_typescript_enabled) {
|
||||
if (!opts.declare_range.isEmpty()) {
|
||||
try p.log.addRangeError(p.source, p.lexer.range(), "Class fields that use \"declare\" cannot be initialized");
|
||||
}
|
||||
}
|
||||
|
||||
try p.lexer.next();
|
||||
|
||||
// "this" and "super" property access is allowed in field initializers
|
||||
const old_is_this_disallowed = p.fn_or_arrow_data_parse.is_this_disallowed;
|
||||
const old_allow_super_property = p.fn_or_arrow_data_parse.allow_super_property;
|
||||
p.fn_or_arrow_data_parse.is_this_disallowed = false;
|
||||
p.fn_or_arrow_data_parse.allow_super_property = true;
|
||||
|
||||
initializer = try p.parseExpr(.comma);
|
||||
|
||||
p.fn_or_arrow_data_parse.is_this_disallowed = old_is_this_disallowed;
|
||||
p.fn_or_arrow_data_parse.allow_super_property = old_allow_super_property;
|
||||
}
|
||||
|
||||
// Special-case private identifiers
|
||||
switch (key.data) {
|
||||
.e_private_identifier => |*private| {
|
||||
const name = p.loadNameFromRef(private.ref);
|
||||
if (strings.eqlComptime(name, "#constructor")) {
|
||||
p.log.addRangeError(p.source, key_range, "Invalid field name \"#constructor\"") catch unreachable;
|
||||
}
|
||||
|
||||
const declare: js_ast.Symbol.Kind = if (opts.is_static)
|
||||
.private_static_field
|
||||
else
|
||||
.private_field;
|
||||
|
||||
private.ref = p.declareSymbol(declare, key.loc, name) catch unreachable;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
try p.lexer.expectOrInsertSemicolon();
|
||||
|
||||
return G.Property{
|
||||
.ts_decorators = ExprNodeList.init(opts.ts_decorators),
|
||||
.kind = kind,
|
||||
.flags = Flags.Property.init(.{
|
||||
.is_computed = is_computed,
|
||||
.is_static = opts.is_static,
|
||||
}),
|
||||
.key = key,
|
||||
.initializer = initializer,
|
||||
.ts_metadata = ts_metadata,
|
||||
};
|
||||
}
|
||||
|
||||
// Parse a method expression
|
||||
if (p.lexer.token == .t_open_paren or kind != .normal or opts.is_class or opts.is_async or opts.is_generator) {
|
||||
if (p.lexer.token == .t_open_paren and kind != .get and kind != .set) {
|
||||
// markSyntaxFeature object extensions
|
||||
}
|
||||
|
||||
const loc = p.lexer.loc();
|
||||
const scope_index = p.pushScopeForParsePass(.function_args, loc) catch unreachable;
|
||||
var is_constructor = false;
|
||||
|
||||
// Forbid the names "constructor" and "prototype" in some cases
|
||||
if (opts.is_class and !is_computed) {
|
||||
switch (key.data) {
|
||||
.e_string => |str| {
|
||||
if (!opts.is_static and str.eqlComptime("constructor")) {
|
||||
if (kind == .get) {
|
||||
p.log.addRangeError(p.source, key_range, "Class constructor cannot be a getter") catch unreachable;
|
||||
} else if (kind == .set) {
|
||||
p.log.addRangeError(p.source, key_range, "Class constructor cannot be a setter") catch unreachable;
|
||||
} else if (opts.is_async) {
|
||||
p.log.addRangeError(p.source, key_range, "Class constructor cannot be an async function") catch unreachable;
|
||||
} else if (opts.is_generator) {
|
||||
p.log.addRangeError(p.source, key_range, "Class constructor cannot be a generator function") catch unreachable;
|
||||
} else {
|
||||
is_constructor = true;
|
||||
}
|
||||
} else if (opts.is_static and str.eqlComptime("prototype")) {
|
||||
p.log.addRangeError(p.source, key_range, "Invalid static method name \"prototype\"") catch unreachable;
|
||||
}
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
}
|
||||
|
||||
var func = try p.parseFn(null, FnOrArrowDataParse{
|
||||
.async_range = opts.async_range,
|
||||
.needs_async_loc = key.loc,
|
||||
.has_async_range = !opts.async_range.isEmpty(),
|
||||
.allow_await = if (opts.is_async) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
|
||||
.allow_yield = if (opts.is_generator) AwaitOrYield.allow_expr else AwaitOrYield.allow_ident,
|
||||
.allow_super_call = opts.class_has_extends and is_constructor,
|
||||
.allow_super_property = true,
|
||||
.allow_ts_decorators = opts.allow_ts_decorators,
|
||||
.is_constructor = is_constructor,
|
||||
.has_decorators = opts.ts_decorators.len > 0 or (opts.has_class_decorators and is_constructor),
|
||||
|
||||
// Only allow omitting the body if we're parsing TypeScript class
|
||||
.allow_missing_body_for_type_script = is_typescript_enabled and opts.is_class,
|
||||
});
|
||||
|
||||
opts.has_argument_decorators = opts.has_argument_decorators or p.fn_or_arrow_data_parse.has_argument_decorators;
|
||||
p.fn_or_arrow_data_parse.has_argument_decorators = false;
|
||||
|
||||
// "class Foo { foo(): void; foo(): void {} }"
|
||||
if (func.flags.contains(.is_forward_declaration)) {
|
||||
// Skip this property entirely
|
||||
p.popAndDiscardScope(scope_index);
|
||||
return null;
|
||||
}
|
||||
|
||||
p.popScope();
|
||||
func.flags.insert(.is_unique_formal_parameters);
|
||||
const value = p.newExpr(E.Function{ .func = func }, loc);
|
||||
|
||||
// Enforce argument rules for accessors
|
||||
switch (kind) {
|
||||
.get => {
|
||||
if (func.args.len > 0) {
|
||||
const r = js_lexer.rangeOfIdentifier(p.source, func.args[0].binding.loc);
|
||||
p.log.addRangeErrorFmt(p.source, r, p.allocator, "Getter {s} must have zero arguments", .{p.keyNameForError(key)}) catch unreachable;
|
||||
}
|
||||
},
|
||||
.set => {
|
||||
if (func.args.len != 1) {
|
||||
var r = js_lexer.rangeOfIdentifier(p.source, if (func.args.len > 0) func.args[0].binding.loc else loc);
|
||||
if (func.args.len > 1) {
|
||||
r = js_lexer.rangeOfIdentifier(p.source, func.args[1].binding.loc);
|
||||
}
|
||||
p.log.addRangeErrorFmt(p.source, r, p.allocator, "Setter {s} must have exactly 1 argument (there are {d})", .{ p.keyNameForError(key), func.args.len }) catch unreachable;
|
||||
}
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
// Special-case private identifiers
|
||||
switch (key.data) {
|
||||
.e_private_identifier => |*private| {
|
||||
const declare: Symbol.Kind = switch (kind) {
|
||||
.get => if (opts.is_static)
|
||||
.private_static_get
|
||||
else
|
||||
.private_get,
|
||||
|
||||
.set => if (opts.is_static)
|
||||
.private_static_set
|
||||
else
|
||||
.private_set,
|
||||
else => if (opts.is_static)
|
||||
.private_static_method
|
||||
else
|
||||
.private_method,
|
||||
};
|
||||
|
||||
const name = p.loadNameFromRef(private.ref);
|
||||
if (strings.eqlComptime(name, "#constructor")) {
|
||||
p.log.addRangeError(p.source, key_range, "Invalid method name \"#constructor\"") catch unreachable;
|
||||
}
|
||||
private.ref = p.declareSymbol(declare, key.loc, name) catch unreachable;
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
return G.Property{
|
||||
.ts_decorators = ExprNodeList.init(opts.ts_decorators),
|
||||
.kind = kind,
|
||||
.flags = Flags.Property.init(.{
|
||||
.is_computed = is_computed,
|
||||
.is_method = true,
|
||||
.is_static = opts.is_static,
|
||||
}),
|
||||
.key = key,
|
||||
.value = value,
|
||||
.ts_metadata = .m_function,
|
||||
};
|
||||
}
|
||||
|
||||
// Parse an object key/value pair
|
||||
try p.lexer.expect(.t_colon);
|
||||
const value = try p.parseExprOrBindings(.comma, errors);
|
||||
|
||||
return G.Property{
|
||||
.kind = kind,
|
||||
.flags = Flags.Property.init(.{
|
||||
.is_computed = is_computed,
|
||||
}),
|
||||
.key = key,
|
||||
.value = value,
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const string = []const u8;
|
||||
|
||||
const bun = @import("bun");
|
||||
const logger = bun.logger;
|
||||
const strings = bun.strings;
|
||||
|
||||
const js_ast = bun.ast;
|
||||
const E = js_ast.E;
|
||||
const Expr = js_ast.Expr;
|
||||
const ExprNodeList = js_ast.ExprNodeList;
|
||||
const Flags = js_ast.Flags;
|
||||
const Stmt = js_ast.Stmt;
|
||||
const Symbol = js_ast.Symbol;
|
||||
|
||||
const G = js_ast.G;
|
||||
const Property = G.Property;
|
||||
|
||||
const js_lexer = bun.js_lexer;
|
||||
const T = js_lexer.T;
|
||||
|
||||
const js_parser = bun.js_parser;
|
||||
const AwaitOrYield = js_parser.AwaitOrYield;
|
||||
const DeferredErrors = js_parser.DeferredErrors;
|
||||
const FnOrArrowDataParse = js_parser.FnOrArrowDataParse;
|
||||
const JSXTransformType = js_parser.JSXTransformType;
|
||||
const ParseStatementOptions = js_parser.ParseStatementOptions;
|
||||
const PropertyOpts = js_parser.PropertyOpts;
|
||||
const TypeScript = js_parser.TypeScript;
|
||||
const options = js_parser.options;
|
||||
|
||||
const std = @import("std");
|
||||
const List = std.ArrayListUnmanaged;
|
||||
Reference in New Issue
Block a user