diff options
Diffstat (limited to 'src/js_ast.zig')
| -rw-r--r-- | src/js_ast.zig | 300 |
1 files changed, 244 insertions, 56 deletions
diff --git a/src/js_ast.zig b/src/js_ast.zig index fb494b909..813e76c0e 100644 --- a/src/js_ast.zig +++ b/src/js_ast.zig @@ -26,6 +26,10 @@ pub const BindingNodeIndex = *Binding; pub const StmtNodeIndex = *Stmt; pub const ExprNodeIndex = *Expr; +pub const ExprNodeList = []Expr; +pub const StmtNodeList = []Stmt; +pub const BindingNodeList = []Binding; + // TODO: figure out if we actually need this // -- original comment -- // Files are parsed in parallel for speed. We want to allow each parser to @@ -40,10 +44,10 @@ pub const ExprNodeIndex = *Expr; // The maps can be merged quickly by creating a single outer array containing // all inner arrays from all parsed files. pub const Ref = struct { - source_index: u32 = 0, + source_index: ?u32 = null, inner_index: u32, - const None = Ref{ .source_index = std.math.maxInt(u32), .inner_index = std.math.maxInt(u32) }; + const None = Ref{ .source_index = null, .inner_index = std.math.maxInt(u32) }; }; pub const ImportItemStatus = enum(u8) { @@ -59,23 +63,48 @@ pub const ImportItemStatus = enum(u8) { pub const LocRef = struct { loc: logger.Loc, ref: ?Ref }; pub const Binding = struct { + loc: logger.Loc, data: B, -}; - -pub const B = union(enum) { - identifier: B.Identifier, - array: B.Array, - property: B.Property, - object: B.Object, - missing: B.Missing, - pub const Type = enum { - b_missing, + pub const Tag = enum { b_identifier, b_array, + b_property, b_object, + b_missing, }; + pub fn init(t: anytype, loc: logger.Loc) Binding { + switch (@TypeOf(t)) { + B.Identifier => { + return Binding{ .loc = loc, .data = B{ .b_identifier = t } }; + }, + B.Array => { + return Binding{ .loc = loc, .data = B{ .b_array = t } }; + }, + B.Property => { + return Binding{ .loc = loc, .data = B{ .b_property = t } }; + }, + B.Object => { + return Binding{ .loc = loc, .data = B{ .b_object = t } }; + }, + B.Missing => { + return Binding{ .loc = loc, .data = B{ .b_missing = t } }; + }, + else => { + @compileError("Invalid type passed to Binding.init"); + }, + } + } +}; + +pub const B = union(Binding.Tag) { + b_identifier: B.Identifier, + b_array: B.Array, + b_property: B.Property, + b_object: B.Object, + b_missing: B.Missing, + pub const Identifier = struct { ref: Ref, }; @@ -89,7 +118,7 @@ pub const B = union(enum) { }; key: ExprNodeIndex, - value: ?BindingNodeIndex, + value: ?BindingNodeIndex = null, kind: Kind = Kind.normal, initializer: ?ExprNodeIndex, is_computed: bool = false, @@ -100,7 +129,11 @@ pub const B = union(enum) { pub const Object = struct { properties: []Property }; - pub const Array = struct { binding: BindingNodeIndex, default_value: ?Expr }; + pub const Array = struct { + items: []ArrayBinding, + has_spread: bool = false, + is_single_line: bool = false, + }; pub const Missing = struct {}; }; @@ -134,7 +167,7 @@ pub const G = struct { pub const Class = struct { class_keyword: logger.Range, - ts_decorators: ?[]ExprNodeIndex = null, + ts_decorators: ?ExprNodeList = null, name: logger.Loc, extends: ?ExprNodeIndex = null, body_loc: logger.Loc, @@ -145,7 +178,7 @@ pub const G = struct { pub const Comment = struct { loc: logger.Loc, text: string }; pub const Property = struct { - ts_decorators: []ExprNodeIndex, + ts_decorators: ExprNodeList, key: ExprNodeIndex, // This is omitted for class fields @@ -170,7 +203,7 @@ pub const G = struct { pub const FnBody = struct { loc: logger.Loc, - stmts: []StmtNodeIndex, + stmts: StmtNodeList, }; pub const Fn = struct { @@ -178,7 +211,7 @@ pub const G = struct { open_parens_loc: logger.Loc, args: ?[]Arg = null, body: ?FnBody = null, - arguments_ref: ?Ref, + arguments_ref: ?Ref = null, is_async: bool = false, is_generator: bool = false, @@ -190,7 +223,7 @@ pub const G = struct { }; pub const Arg = struct { - ts_decorators: ?[]ExprNodeIndex = null, + ts_decorators: ?ExprNodeList = null, binding: BindingNodeIndex, default: ?ExprNodeIndex = null, @@ -222,7 +255,7 @@ pub const Symbol = struct { // form a linked-list where the last link is the symbol to use. This link is // an invalid ref if it's the last link. If this isn't invalid, you need to // FollowSymbols to get the real one. - link: ?Ref, + link: ?Ref = null, // An estimate of the number of uses of this symbol. This is used to detect // whether a symbol is used or not. For example, TypeScript imports that are @@ -247,7 +280,7 @@ pub const Symbol = struct { // slot namespaces: regular symbols, label symbols, and private symbols. nested_scope_slot: ?u32 = null, - kind: Kind, + kind: Kind = Kind.other, // Certain symbols must not be renamed or minified. For example, the // "arguments" variable is declared by the runtime for every function. @@ -410,7 +443,7 @@ pub const Symbol = struct { }; pub const Use = struct { - count_estimate: u32, + count_estimate: u32 = 0, }; pub const Map = struct { @@ -465,10 +498,10 @@ ccontinue }; pub const E = struct { pub const Array = struct { - items: []ExprNodeIndex, - comma_after_spread: logger.Loc, - is_single_line: bool, - is_parenthesized: bool, + items: ExprNodeList, + comma_after_spread: ?logger.Loc = null, + is_single_line: bool = false, + is_parenthesized: bool = false, }; pub const Unary = struct { @@ -488,7 +521,7 @@ pub const E = struct { pub const Undefined = struct {}; pub const New = struct { target: ExprNodeIndex, - args: []ExprNodeIndex, + args: ExprNodeList, // True if there is a comment containing "@__PURE__" or "#__PURE__" preceding // this call expression. See the comment inside ECall for more details. @@ -500,8 +533,8 @@ pub const E = struct { pub const Call = struct { // Node: target: ExprNodeIndex, - args: []ExprNodeIndex, - optional_chain: OptionalChain, + args: ExprNodeList, + optional_chain: ?OptionalChain = null, is_direct_eval: bool = false, // True if there is a comment containing "@__PURE__" or "#__PURE__" preceding @@ -525,7 +558,7 @@ pub const E = struct { // target is Node name: string, name_loc: logger.Loc, - optional_chain: ?OptionalChain, + optional_chain: ?OptionalChain = null, // If true, this property access is known to be free of side-effects. That // means it can be removed if the resulting value isn't used. @@ -545,7 +578,7 @@ pub const E = struct { pub const Index = struct { index: ExprNodeIndex, - optional_chain: ?OptionalChain, + optional_chain: ?OptionalChain = null, pub fn hasSameFlagsAs(a: *Index, b: *Index) bool { return (a.optional_chain == b.optional_chain); @@ -619,9 +652,9 @@ pub const E = struct { }; pub const JSXElement = struct { - tag: ?ExprNodeIndex, + tag: ?ExprNodeIndex = null, properties: []G.Property, - children: []ExprNodeIndex, + children: ExprNodeList, }; pub const Missing = struct {}; @@ -634,17 +667,17 @@ pub const E = struct { pub const Object = struct { properties: []G.Property, - comma_after_spread: logger.Loc, - is_single_line: bool, - is_parenthesized: bool, + comma_after_spread: ?logger.Loc = null, + is_single_line: bool = false, + is_parenthesized: bool = false, }; pub const Spread = struct { value: ExprNodeIndex }; pub const String = struct { value: JavascriptString, - legacy_octal_loc: logger.Loc, - prefer_template: bool, + legacy_octal_loc: ?logger.Loc = null, + prefer_template: bool = false, }; // value is in the Node @@ -655,8 +688,8 @@ pub const E = struct { tail_raw: string, }; - pub const Template = struct { tag: ?ExprNodeIndex, head: JavascriptString, head_raw: string, // This is only filled out for tagged template literals - parts: ?[]TemplatePart, legacy_octal_loc: logger.Loc }; + pub const Template = struct { tag: ?ExprNodeIndex = null, head: JavascriptString, head_raw: string, // This is only filled out for tagged template literals + parts: ?[]TemplatePart = null, legacy_octal_loc: logger.Loc }; pub const RegExp = struct { value: string, @@ -667,8 +700,8 @@ pub const E = struct { pub const Await = struct { value: ExprNodeIndex }; pub const Yield = struct { - value: ?ExprNodeIndex, - is_star: bool, + value: ?ExprNodeIndex = null, + is_star: bool = false, }; pub const If = struct { @@ -963,7 +996,146 @@ pub const Expr = struct { pub const Flags = enum { none, ts_decorator }; - pub const Data = union(enum) { + pub fn init(data: anytype, loc: logger.Loc) Expr { + switch (@TypeOf(data)) { + E.Array => { + return Expr{ .loc = loc, .data = Data{ .e_array = data } }; + }, + E.Unary => { + return Expr{ .loc = loc, .data = Data{ .e_unary = data } }; + }, + E.Binary => { + return Expr{ .loc = loc, .data = Data{ .e_binary = data } }; + }, + E.Boolean => { + return Expr{ .loc = loc, .data = Data{ .e_boolean = data } }; + }, + E.Super => { + return Expr{ .loc = loc, .data = Data{ .e_super = data } }; + }, + E.Null => { + return Expr{ .loc = loc, .data = Data{ .e_null = data } }; + }, + E.Undefined => { + return Expr{ .loc = loc, .data = Data{ .e_undefined = data } }; + }, + E.New => { + return Expr{ .loc = loc, .data = Data{ .e_new = data } }; + }, + E.NewTarget => { + return Expr{ .loc = loc, .data = Data{ .e_new_target = data } }; + }, + E.ImportMeta => { + return Expr{ .loc = loc, .data = Data{ .e_import_meta = data } }; + }, + E.Call => { + return Expr{ .loc = loc, .data = Data{ .e_call = data } }; + }, + E.Dot => { + return Expr{ .loc = loc, .data = Data{ .e_dot = data } }; + }, + E.Index => { + return Expr{ .loc = loc, .data = Data{ .e_index = data } }; + }, + E.Arrow => { + return Expr{ .loc = loc, .data = Data{ .e_arrow = data } }; + }, + E.Identifier => { + return Expr{ .loc = loc, .data = Data{ .e_identifier = data } }; + }, + E.ImportIdentifier => { + return Expr{ .loc = loc, .data = Data{ .e_import_identifier = data } }; + }, + E.PrivateIdentifier => { + return Expr{ .loc = loc, .data = Data{ .e_private_identifier = data } }; + }, + E.JSXElement => { + return Expr{ .loc = loc, .data = Data{ .e_jsx_element = data } }; + }, + E.Missing => { + return Expr{ .loc = loc, .data = Data{ .e_missing = data } }; + }, + E.Number => { + return Expr{ .loc = loc, .data = Data{ .e_number = data } }; + }, + E.BigInt => { + return Expr{ .loc = loc, .data = Data{ .e_big_int = data } }; + }, + E.Object => { + return Expr{ .loc = loc, .data = Data{ .e_object = data } }; + }, + E.Spread => { + return Expr{ .loc = loc, .data = Data{ .e_spread = data } }; + }, + E.String => { + return Expr{ .loc = loc, .data = Data{ .e_string = data } }; + }, + E.TemplatePart => { + return Expr{ .loc = loc, .data = Data{ .e_template_part = data } }; + }, + E.Template => { + return Expr{ .loc = loc, .data = Data{ .e_template = data } }; + }, + E.RegExp => { + return Expr{ .loc = loc, .data = Data{ .e_reg_exp = data } }; + }, + E.Await => { + return Expr{ .loc = loc, .data = Data{ .e_await = data } }; + }, + E.Yield => { + return Expr{ .loc = loc, .data = Data{ .e_yield = data } }; + }, + E.If => { + return Expr{ .loc = loc, .data = Data{ .e_if = data } }; + }, + E.RequireOrRequireResolve => { + return Expr{ .loc = loc, .data = Data{ .e_require_or_require_resolve = data } }; + }, + E.Import => { + return Expr{ .loc = loc, .data = Data{ .e_import = data } }; + }, + else => { + @compileError("Invalid type passed to Expr.init"); + }, + } + } + + pub const Tag = enum { + e_array, + e_unary, + e_binary, + e_boolean, + e_super, + e_null, + e_undefined, + e_new, + e_new_target, + e_import_meta, + e_call, + e_dot, + e_index, + e_arrow, + e_identifier, + e_import_identifier, + e_private_identifier, + e_jsx_element, + e_missing, + e_number, + e_big_int, + e_object, + e_spread, + e_string, + e_template_part, + e_template, + e_reg_exp, + e_await, + e_yield, + e_if, + e_require_or_require_resolve, + e_import, + }; + + pub const Data = union(Tag) { e_array: E.Array, e_unary: E.Unary, e_binary: E.Binary, @@ -1038,7 +1210,7 @@ pub const EnumValue = struct { }; pub const S = struct { - pub const Block = struct { stmts: []StmtNodeIndex }; + pub const Block = struct { stmts: StmtNodeList }; pub const Comment = struct { text: string }; @@ -1073,7 +1245,7 @@ pub const S = struct { pub const Namespace = struct { name: LocRef, arg: Ref, - stmts: []StmtNodeIndex, + stmts: StmtNodeList, is_export: bool, }; @@ -1119,10 +1291,10 @@ pub const S = struct { }; pub const Try = struct { - body: []StmtNodeIndex, + body: StmtNodeList, body_loc: logger.Log, - catch_: ?Catch, - finally: ?Finally, + catch_: ?Catch = null, + finally: ?Finally = null, }; pub const Switch = struct { @@ -1150,8 +1322,8 @@ pub const S = struct { // when converting this module to a CommonJS module. namespace_ref: Ref, default_name: *LocRef, items: *[]ClauseItem, star_name_loc: *logger.Loc, import_record_index: u32, is_single_line: bool }; - pub const Return = struct {}; - pub const Throw = struct {}; + pub const Return = struct { value: ?ExprNodeIndex = null }; + pub const Throw = struct { value: ExprNodeIndex }; pub const Local = struct { kind: Kind = Kind.k_var, @@ -1180,15 +1352,15 @@ pub const S = struct { pub const Catch = struct { loc: logger.Loc, binding: ?BindingNodeIndex, - body: []StmtNodeIndex, + body: StmtNodeList, }; pub const Finally = struct { loc: logger.Loc, - stmts: []StmtNodeIndex, + stmts: StmtNodeList, }; -pub const Case = struct { loc: logger.Loc, value: ?ExprNodeIndex, body: []StmtNodeIndex }; +pub const Case = struct { loc: logger.Loc, value: ?ExprNodeIndex, body: StmtNodeList }; pub const Op = struct { // If you add a new token, remember to add it to "OpTable" too @@ -1686,7 +1858,23 @@ pub const Scope = struct { } }; -// test "ast" { -// const ast = Ast{}; -// } +test "Binding.init" { + var binding = Binding.init( + B.Identifier{ .ref = Ref{ .source_index = 0, .inner_index = 10 } }, + logger.Loc{ .start = 1 }, + ); + std.testing.expect(binding.loc.start == 1); + std.testing.expect(@as(Binding.Tag, binding.data) == Binding.Tag.b_identifier); +} +test "Expr.init" { + var ident = Expr.init(E.Identifier{}, logger.Loc{ .start = 100 }); + var list = [_]Expr{ident}; + var expr = Expr.init( + E.Array{ .items = list[0..] }, + logger.Loc{ .start = 1 }, + ); + std.testing.expect(expr.loc.start == 1); + std.testing.expect(@as(Expr.Tag, expr.data) == Expr.Tag.e_array); + std.testing.expect(expr.data.e_array.items[0].loc.start == 100); +} |