diff --git a/README.md b/README.md index 40bbb9bc..7ed93b2b 100644 --- a/README.md +++ b/README.md @@ -127,12 +127,12 @@ bazelisk test //maldoca/js/ir/conversion/... ### Run the `jsir_gen` tool -Convert a JavaScript source file to JSHIR: +Convert a JavaScript source file to JSIR: ```shell bazelisk run //maldoca/js/ir:jsir_gen --\ --input_file=$(pwd)/maldoca/js/ir/conversion/tests/if_statement/input.js \ - --passes=source2ast,ast2hir + --passes=source2ast,ast2jsir ``` ## Other links diff --git a/docs/dataflow_analysis.md b/docs/dataflow_analysis.md index bccd7c5e..983e491c 100644 --- a/docs/dataflow_analysis.md +++ b/docs/dataflow_analysis.md @@ -264,7 +264,7 @@ The JSIR for the code above is as follows: ``` ... %cond = jsir.identifier{"cond"} -jshir.if_statement (%cond) ({ +jsir.if_statement (%cond) ({ %a_ref_true = jsir.identifier_ref{"a"} %1 = jsir.numeric_literal{1} %assign_true = jsir.assignment_expression (%a_ref_true, %1) @@ -288,14 +288,14 @@ preserves the nested structures. We can see that the two branches of the > more than 1 block in any region. The JSIR dataflow analysis API understands the branching behaviors of -`jshir.if_statement`, and builds **CFG (control flow graph) edges** to represent +`jsir.if_statement`, and builds **CFG (control flow graph) edges** to represent them internally: ``` ... %cond = jsir.identifier{"cond"} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ %a_ref_true = jsir.identifier_ref{"a"} │ %1 = jsir.numeric_literal{1} @@ -334,7 +334,7 @@ reaching `B1`, i.e. right **B**efore the `if`-statement. // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ <IR for `a = 1;`> │ ┌────◄ @@ -359,7 +359,7 @@ to two program points: `T0` and `F0`, which represent the entry points of the // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = {} │ <IR for `a = 1;`> @@ -412,7 +412,7 @@ propagation before, we will consequently visit all ops in the region. // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = {} │ %a_ref_true = jsir.identifier_ref{"a"} @@ -452,7 +452,7 @@ the CFG edge and propagate its state to `E0`, i.e. the end of the // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = {} │ <IR for `a = 1;`> @@ -485,7 +485,7 @@ compute states up to `state[F4]`: // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = {} │ <IR for `a = 1;`> @@ -526,7 +526,7 @@ propagate its state to `E0`. // state[%cond] = Unknown // state[B1] = {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = {} │ <IR for `a = 1;`> @@ -604,7 +604,7 @@ The final result of the analysis, in full detail, is as follows: // state[%cond] = Unknown // state[B1] = [default = Unknown] {} ┌─────◄ -│ jshir.if_statement (%cond) ({ +│ jsir.if_statement (%cond) ({ ├───────► │ // state[T0] = [default = Unknown] {} │ %a_ref_true = jsir.identifier_ref{"a"} @@ -684,7 +684,7 @@ the combination of all iterations. Now, similar to the previous examples, we convert the code into JSIR: ``` -jshir.while_statement ({ +jsir.while_statement ({ // The `test` region // IR for `cond()`: %cond_id = jsir.identifier {"cond"} @@ -711,7 +711,7 @@ Then, we build CFG edges to represent control flow branches: %assign_before = jsir.assignment_expression (%a_ref_before, %1) jsir.expression_statement (%assign_before) ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // IR for `cond()`: │ %cond = ... @@ -739,7 +739,7 @@ Similar to the handling of the `if`-statement, we compute the states before the <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Const{1}} │ // IR for `cond()`: @@ -773,7 +773,7 @@ don't know the return value of `cond()`, so we can only assign `Unknown` to <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Const{1}} │ // IR for `cond()`: @@ -804,7 +804,7 @@ possible to enter the loop body and exit the loop. Therefore, we propagate <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Const{1}} │ %cond = <IR for `cond()`> @@ -840,7 +840,7 @@ first iteration of the loop body, which changes `a` from `1` to `3`. <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Const{1}} │ %cond = <IR for `cond()`> @@ -867,7 +867,7 @@ At the end of the loop body, we jump back to the `test` region, which `Join`s <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Const{1} Unknown} │ %cond = <IR for `cond()`> @@ -896,7 +896,7 @@ again with this new state, and propagate it to `I0` and `E0`. <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Unknown} │ %cond = <IR for `cond()`> @@ -929,7 +929,7 @@ end of the `body` region `I6` becomes `{a: Unknown}`. <IR for `a = 1;`> // state[B4] = {a: Const{1}} ┌─────◄ -│ jshir.while_statement ({ +│ jsir.while_statement ({ ├───────► │ // state[T0] = {a: Unknown} │ // IR for `cond()`: diff --git a/docs/intermediate_representation_design.md b/docs/intermediate_representation_design.md index d207cd93..d853d2ea 100644 --- a/docs/intermediate_representation_design.md +++ b/docs/intermediate_representation_design.md @@ -211,10 +211,10 @@ semantic meanings: ## Representing control flows -As mentioned above, JSIR seeks to have a nearly one-to-one mapping from the -AST. Therefore, to preserve all information about the original control flow +As mentioned above, JSIR seeks to have a nearly one-to-one mapping from the AST. +Therefore, to preserve all information about the original control flow structures, we define a separate op for each control flow structure (e.g. -`jshir.if_statement`, `jshir.while_statement`, etc.). The nested code blocks are +`jsir.if_statement`, `jsir.while_statement`, etc.). The nested code blocks are represented as MLIR [regions](https://mlir.llvm.org/docs/LangRef/#regions). ### Example: `if`-statement @@ -247,7 +247,7 @@ And, its corresponding JSIR is as follows: ```mlir %cond = jsir.identifier {"cond"} -jshir.if_statement (%cond) ({ +jsir.if_statement (%cond) ({ %a = jsir.identifier {"a"} jsir.expression_statement (%a) }, { @@ -289,7 +289,7 @@ WhileStatement { Its corresponding JSIR is as follows: ```mlir -jshir.while_statement ({ +jsir.while_statement ({ %cond_id = jsir.identifier {"cond"} %cond_call = jsir.call_expression (%cond_id) jsir.expr_region_end (%cond_call) @@ -300,11 +300,11 @@ jshir.while_statement ({ }) ``` -Note that unlike `jshir.if_statement`, the condition in a -`jshir.while_statement` is represented as a region rather than a normal SSA -value (`%cond`). This is because the condition is evaluated in each iteration -**within** the `while`-statement, whereas the condition is evaluated only once -**before** the `if`-statement. +Note that unlike `jsir.if_statement`, the condition in a `jsir.while_statement` +is represented as a region rather than a normal SSA value (`%cond`). This is +because the condition is evaluated in each iteration **within** the +`while`-statement, whereas the condition is evaluated only once **before** the +`if`-statement. ### Example: logical expression @@ -333,7 +333,7 @@ Its corresponding JSIR is as follows: ```mlir %x_ref = jsir.identifier_ref {"x"} %a = jsir.identifier {"a"} -%and = jshir.logical_expression (%a) ({ +%and = jsir.logical_expression (%a) ({ %b = jsir.identifier {"b"} jsir.expr_region_end (%b) }) @@ -341,7 +341,7 @@ Its corresponding JSIR is as follows: jsir.expression_statement (%assign) ``` -Note that in `jshir.logical_expression`, `left` is an SSA value, and `right` is -a region. This is because `left` is always evaluated first, whereas `right` is +Note that in `jsir.logical_expression`, `left` is an SSA value, and `right` is a +region. This is because `left` is always evaluated first, whereas `right` is only evaluated if the result of `left` is truthy, and omitted if `left` is falsy due to the short-circuit behavior. diff --git a/maldoca/astgen/ast_def.cc b/maldoca/astgen/ast_def.cc index 6debce86..0e253c1f 100644 --- a/maldoca/astgen/ast_def.cc +++ b/maldoca/astgen/ast_def.cc @@ -225,7 +225,7 @@ std::optional NodeDef::ir_op_name(absl::string_view lang_name, return std::nullopt; } - auto ir_name = absl::StrCat(lang_name, has_control_flow() ? "hir" : "ir"); + auto ir_name = absl::StrCat(lang_name, "ir"); Symbol result{ir_name}; diff --git a/maldoca/astgen/ast_def.h b/maldoca/astgen/ast_def.h index c8be0376..c5d02ca0 100644 --- a/maldoca/astgen/ast_def.h +++ b/maldoca/astgen/ast_def.h @@ -218,22 +218,15 @@ class NodeDef { return aggregated_kinds_; } - // Whether this node has control-flow-related information. - // - // A node is considered to have control-flow-related information if it - // contains some branch semantics. - // - // Example: IfStatement, BreakStatement. - // - // When this is true, we define two ops, one in HIR (high-level IR), one in - // LIR (low-level IR). - bool has_control_flow() const { return has_control_flow_; } + // Deprecated: No longer used for dialect splitting. Merged HIR into IR. + [[deprecated("Merged HIR into IR")]] + bool has_control_flow() const { + return has_control_flow_; + } // The MLIR op name (C++ class name). // - // : - // has_control_flow: hir - // !has_control_flow: ir + // : ir // // - Non-leaf type: "OpInterface" // - Leaf type: diff --git a/maldoca/astgen/ast_def.proto b/maldoca/astgen/ast_def.proto index c6071136..5c42041d 100644 --- a/maldoca/astgen/ast_def.proto +++ b/maldoca/astgen/ast_def.proto @@ -295,9 +295,8 @@ message NodeDefPb { // Supported kinds. Each kind leads to a different IR op. repeated FieldKind kinds = 6; - // Whether this op has control flow. If so, we will define a high-level IR op, - // and a low-level IR op. - optional bool has_control_flow = 7; + // Deprecated: No longer used for dialect splitting. Merged HIR into IR. + optional bool has_control_flow = 7 [deprecated = true]; // [Optional] Custom MLIR op name. // diff --git a/maldoca/astgen/ir_table_gen_printer.cc b/maldoca/astgen/ir_table_gen_printer.cc index 031ecddf..2244ea1e 100644 --- a/maldoca/astgen/ir_table_gen_printer.cc +++ b/maldoca/astgen/ir_table_gen_printer.cc @@ -204,8 +204,6 @@ void IrTableGenPrinter::PrintAst(const AstDef& ast, absl::string_view ir_path) { void IrTableGenPrinter::PrintNode(const AstDef& ast, const NodeDef& node, FieldKind kind) { auto ir_name = absl::StrCat(ast.lang_name(), "ir"); - auto hir_name = - absl::StrCat(ast.lang_name(), node.has_control_flow() ? "hir" : "ir"); auto vars = WithVars({ {"OpName", node.ir_op_name(ast.lang_name(), kind).value().ToPascalCase()}, @@ -213,7 +211,6 @@ void IrTableGenPrinter::PrintNode(const AstDef& ast, const NodeDef& node, {"Name", node.name()}, {"name", Symbol(node.name()).ToCcVarName()}, {"IrName", Symbol(ir_name).ToPascalCase()}, - {"HirName", Symbol(hir_name).ToPascalCase()}, }); std::vector traits; @@ -295,7 +292,7 @@ void IrTableGenPrinter::PrintNode(const AstDef& ast, const NodeDef& node, // ]> { // ``` Print( - "def $OpName$ : $HirName$_Op<\n" + "def $OpName$ : $IrName$_Op<\n" " \"$op_mnemonic$\", [\n"); { diff --git a/maldoca/js/ast/BUILD b/maldoca/js/ast/BUILD index 5863f5e2..844ac91c 100644 --- a/maldoca/js/ast/BUILD +++ b/maldoca/js/ast/BUILD @@ -24,6 +24,25 @@ package( default_visibility = JSIR_ALLOWED_USERS, ) +cc_test( + name = "ast_gen_test", + srcs = ["ast_gen_test.cc"], + data = [ + "ast.generated.cc", + "ast.generated.h", + "ast_def.textproto", + "ast_from_json.generated.cc", + "ast_to_json.generated.cc", + "//maldoca/js/ir:jsir_ops.generated.td", + "//maldoca/js/ir/conversion:ast_to_jsir.generated.cc", + "//maldoca/js/ir/conversion:jsir_to_ast.generated.cc", + ], + deps = [ + "//maldoca/astgen/test:ast_gen_test_util", + "@googletest//:gtest_main", + ], +) + cc_library( name = "ast", srcs = [ diff --git a/maldoca/js/ast/ast_def.textproto b/maldoca/js/ast/ast_def.textproto new file mode 100644 index 00000000..a01deb6a --- /dev/null +++ b/maldoca/js/ast/ast_def.textproto @@ -0,0 +1,3408 @@ +# proto-file: third_party/maldoca/astgen/ast_def.proto +# proto-message: AstDefPb + +# To update the generated code: +# +# blaze build //third_party/maldoca/astgen:ast_gen_main +# +# ./blaze-bin/third_party/maldoca/astgen/ast_gen_main \ +# --ast_def_path="third_party/maldoca/js/ast/ast_def.textproto" \ +# --cc_namespace="maldoca" \ +# --ast_path="third_party/maldoca/js/ast" \ +# --ir_path="third_party/maldoca/js/ir" + +lang_name: "js" + +# enum UnaryOperator { +# "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" | "throw" +# } +enums { + name: "UnaryOperator" + members { + name: "Minus" + string_value: "-" + } + members { + name: "Plus" + string_value: "+" + } + members { + name: "Not" + string_value: "!" + } + members { + name: "BitwiseNot" + string_value: "~" + } + members { + name: "TypeOf" + string_value: "typeof" + } + members { + name: "Void" + string_value: "void" + } + members { + name: "Delete" + string_value: "delete" + } + members { + name: "Throw" + string_value: "throw" + } +} + +# enum UpdateOperator { +# "++" | "--" +# } +enums { + name: "UpdateOperator" + members { + name: "Increment" + string_value: "++" + } + members { + name: "Decrement" + string_value: "--" + } +} + +# enum BinaryOperator { +# "==" | "!=" | "===" | "!==" +# | "<" | "<=" | ">" | ">=" +# | "<<" | ">>" | ">>>" +# | "+" | "-" | "*" | "/" | "%" +# | "**" | "|" | "^" | "&" | "in" +# | "instanceof" +# | "|>" +# } +enums { + name: "BinaryOperator" + members { + name: "Equal" + string_value: "==" + } + members { + name: "NotEqual" + string_value: "!=" + } + members { + name: "StrictEqual" + string_value: "===" + } + members { + name: "StrictNotEqual" + string_value: "!==" + } + members { + name: "LessThan" + string_value: "<" + } + members { + name: "LessEqual" + string_value: "<=" + } + members { + name: "GreaterThan" + string_value: ">" + } + members { + name: "GreaterEqual" + string_value: ">=" + } + members { + name: "LeftShift" + string_value: "<<" + } + members { + name: "RightShift" + string_value: ">>" + } + members { + name: "UnsignedRightShift" + string_value: ">>>" + } + members { + name: "Add" + string_value: "+" + } + members { + name: "Subtract" + string_value: "-" + } + members { + name: "Multiply" + string_value: "*" + } + members { + name: "Divide" + string_value: "/" + } + members { + name: "Mod" + string_value: "%" + } + members { + name: "Exp" + string_value: "**" + } + members { + name: "BitwiseOr" + string_value: "|" + } + members { + name: "BitwiseXor" + string_value: "^" + } + members { + name: "BitwiseAnd" + string_value: "&" + } + members { + name: "In" + string_value: "in" + } + members { + name: "InstanceOf" + string_value: "instanceof" + } + members { + name: "Pipeline" + string_value: "|>" + } +} + +# enum AssignmentOperator { +# "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" +# | "<<=" | ">>=" | ">>>=" +# | "|=" | "^=" | "&=" +# | "||=" | "&&=" | "??=" +# } +enums { + name: "AssignmentOperator" + members { + name: "Assign" + string_value: "=" + } + members { + name: "AddAssign" + string_value: "+=" + } + members { + name: "SubtractAssign" + string_value: "-=" + } + members { + name: "MultiplyAssign" + string_value: "*=" + } + members { + name: "DivideAssign" + string_value: "/=" + } + members { + name: "ModAssign" + string_value: "%=" + } + members { + name: "ExpAssign" + string_value: "**=" + } + members { + name: "LeftShiftAssign" + string_value: "<<=" + } + members { + name: "RightShiftAssign" + string_value: ">>=" + } + members { + name: "UnsignedRightShiftAssign" + string_value: ">>>=" + } + members { + name: "BitwiseOrAssign" + string_value: "|=" + } + members { + name: "BitwiseXorAssign" + string_value: "^=" + } + members { + name: "BitwiseAndAssign" + string_value: "&=" + } + members { + name: "OrAssign" + string_value: "||=" + } + members { + name: "AndAssign" + string_value: "&&=" + } + members { + name: "NullishCoalesceAssign" + string_value: "??=" + } +} + +# enum LogicalOperator { +# "||" | "&&" | "??" +# } +enums { + name: "LogicalOperator" + members { + name: "Or" + string_value: "||" + } + members { + name: "And" + string_value: "&&" + } + members { + name: "NullishCoalesce" + string_value: "??" + } +} + +# interface Comment { +# type: string; +# loc: SourceLocation; +# value: string; +# start: number; +# end: number; +# } +nodes { + name: "Comment" + fields { + name: "loc" + type { class: "SourceLocation" } + optionalness: OPTIONALNESS_MAYBE_NULL + } + fields { + name: "value" + type { string {} } + } + fields { + name: "start" + type { int64 {} } + optionalness: OPTIONALNESS_MAYBE_NULL + } + fields { + name: "end" + type { int64 {} } + optionalness: OPTIONALNESS_MAYBE_NULL + } +} + +# interface CommentBlock <: Comment { +# type: "CommentBlock"; +# } +nodes { + name: "CommentBlock" + type: "CommentBlock" + parents: "Comment" +} + +# interface CommentLine <: Comment { +# type: "CommentLine"; +# } +nodes { + name: "CommentLine" + type: "CommentLine" + parents: "Comment" +} + +# interface SymbolId { +# name: string; +# defScopeUid?: number; +# } +nodes { + name: "SymbolId" + fields { + name: "name" + type { string {} } + } + fields { + name: "defScopeUid" + type { int64 {} } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + } + should_generate_ir_op: false +} + +# interface Node { +# type: string; +# loc: SourceLocation | null; +# start: number | null; +# end: number | null; +# leadingCommentUids?: [Comment]; +# trailingCommentUids?: [Comment]; +# innerCommentUids?: [Comment]; +# scopeUid?: number; +# referencedSymbol?: SymbolId; +# definedSymbol?: SymbolId; +# } +nodes { + name: "Node" + fields { + name: "loc" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "SourceLocation" } + ignore_in_ir: true + } + fields { + name: "start" + optionalness: OPTIONALNESS_MAYBE_NULL + type { int64 {} } + ignore_in_ir: true + } + fields { + name: "end" + optionalness: OPTIONALNESS_MAYBE_NULL + type { int64 {} } + ignore_in_ir: true + } + fields { + name: "leadingCommentUids" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { int64 {} } + } + } + ignore_in_ir: true + } + fields { + name: "trailingCommentUids" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { int64 {} } + } + } + ignore_in_ir: true + } + fields { + name: "innerCommentUids" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { int64 {} } + } + } + ignore_in_ir: true + } + fields { + name: "scopeUid" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { int64 {} } + ignore_in_ir: true + } + fields { + name: "referencedSymbol" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { class: "SymbolId" } + ignore_in_ir: true + } + fields { + name: "definedSymbols" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { class: "SymbolId" } + } + } + ignore_in_ir: true + } +} + +# interface File <: Node { +# type: "File"; +# program: Program; +# comments?: Array | null; +# tokens?: Array | null; +# } +# TODO(tzx) +nodes { + name: "File" + parents: "Node" + type: "File" + fields { + name: "program" + type { class: "Program" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "comments" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { + class: "Comment" + } + } + } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_ISOLATED_FROM_ABOVE +} + +# interface SourceLocation { +# // source: string | null; +# start: Position; +# end: Position; +# identifierName?: string; +# } +nodes { + name: "SourceLocation" + fields { + name: "start" + type { class: "Position" } + } + fields { + name: "end" + type { class: "Position" } + } + fields { + name: "identifierName" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { string {} } + } +} + +# interface Position { +# line: number; // >= 1 +# column: number; // >= 0 +# } +nodes { + name: "Position" + fields: { + name: "line" + type { int64 {} } + } + fields: { + name: "column" + type { int64 {} } + } +} + +# // interface Identifier <: Expression, Pattern { +# // type: "Identifier"; +# // name: string; +# // } +# interface Identifier <: Expression, Pattern, LVal { +# type: "Identifier"; +# name: string; +# } +nodes { + name: "Identifier" + type: "Identifier" + parents: "Expression" + parents: "Pattern" + parents: "LVal" + fields { + name: "name" + type { string {} } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface PrivateName <: Node { +# type: "PrivateName"; +# id: Identifier; +# } +nodes { + name: "PrivateName" + type: "PrivateName" + parents: "Node" + fields { + name: "id" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true +} + +# interface Literal <: Expression { } +nodes { + name: "Literal" + parents: "Expression" + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface RegExpLiteral <: Literal { +# type: "RegExpLiteral"; +# pattern: string; +# flags: string; +# extra?: { +# raw: string; +# } +# } +nodes { + name: "RegExpLiteralExtra" + type: "RegExpLiteralExtra" + fields { + name: "raw" + type { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR +} +nodes { + name: "RegExpLiteral" + type: "RegExpLiteral" + parents: "Literal" + fields { + name: "pattern" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "flags" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "extra" + type { class: "RegExpLiteralExtra" } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true + has_fold: true +} + +# interface NullLiteral <: Literal { +# type: "NullLiteral"; +# } +nodes { + name: "NullLiteral" + type: "NullLiteral" + parents: "Literal" + should_generate_ir_op: true + has_fold: true +} + +# interface StringLiteral <: Literal { +# type: "StringLiteral"; +# value: string; // does not include quotes +# extra?: { +# raw: string; // includes quotes +# rawValue: string; // does not include quotes +# } +# } +nodes { + name: "StringLiteralExtra" + type: "StringLiteralExtra" + fields { + name: "raw" + type: { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "rawValue" + type: { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR +} + +nodes { + name: "StringLiteral" + type: "StringLiteral" + parents: "Literal" + fields { + name: "value" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "extra" + type { class: "StringLiteralExtra" } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true + has_fold: true +} + +# interface BooleanLiteral <: Literal { +# type: "BooleanLiteral"; +# value: boolean; +# } +nodes { + name: "BooleanLiteral" + type: "BooleanLiteral" + parents: "Literal" + fields { + name: "value" + type { bool {} } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true + has_fold: true +} + +# interface NumericLiteral <: Literal { +# type: "NumericLiteral"; +# value: number; +# extra?: { +# raw: string; +# rawValue: number; +# } +# } +nodes { + name: "NumericLiteralExtra" + type: "NumericLiteralExtra" + fields { + name: "raw" + type: { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "rawValue" + type: { double {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR +} + +nodes { + name: "NumericLiteral" + type: "NumericLiteral" + parents: "Literal" + fields { + name: "value" + type { double {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "extra" + type { class: "NumericLiteralExtra" } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true + has_fold: true +} + +# interface BigIntLiteral <: Literal { +# type: "BigIntLiteral"; +# value: string; +# extra?: { +# raw: string; // includes the suffix "n" +# rawValue: string; // does not include the suffix "n" +# } +# } +nodes { + name: "BigIntLiteralExtra" + type: "BigIntLiteralExtra" + fields { + name: "raw" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "rawValue" + type { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR +} +nodes { + name: "BigIntLiteral" + type: "BigIntLiteral" + parents: "Literal" + fields { + name: "value" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "extra" + type { class: "BigIntLiteralExtra" } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true + has_fold: true +} + +# // interface DecimalLiteral <: Literal { +# // type: "DecimalLiteral"; +# // value: string; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decimal" plugin. +# ------------------------------------------------------------------------------ + +# interface Program <: Node { +# type: "Program"; +# interpreter: InterpreterDirective | null; +# sourceType: "script" | "module"; +# body: [ Statement | ModuleDeclaration ]; +# directives: [ Directive ]; +# } +# TODO(tzx) + +union_types { + name: "ProgramBodyElement" + parents: "Node" + types: "Statement" + types: "ModuleDeclaration" + kinds: FIELD_KIND_STMT + # should_generate_ir_op: true +} + +nodes { + name: "Program" + parents: "Node" + type: "Program" + fields { + name: "interpreter" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "InterpreterDirective" } + kind: FIELD_KIND_ATTR + } + fields { + name: "sourceType" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "body" + type { + list { + element_type { + class: "ProgramBodyElement" + } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "directives" + type { + list { + element_type { class: "Directive" } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# // interface Function <: Node { +# // id: Identifier | null; +# // params: [ Pattern ]; +# // body: BlockStatement; +# // generator: boolean; +# // async: boolean; +# // } +# ------------------------------------------------------------------------------ +# NOTE: In ArrowFunctionExpression, the type of "body" is overrideen to +# "BlockStatement | Expression". +# +# interface Function <: Node { +# id: Identifier | null; +# params: [ Pattern ]; +# generator: boolean; +# async: boolean; +# } +# interface BlockStatementFunction <: Function { +# body: BlockStatement; +# } +nodes { + name: "Function" + parents: "Node" + fields { + name: "id" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + fields { + name: "params" + type { + list { + element_type { class: "Pattern" } + } + } + kind: FIELD_KIND_LVAL + enclose_in_region: true + } + fields { + name: "generator" + type { bool {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "async" + type { bool {} } + kind: FIELD_KIND_ATTR + } + # Note: We cannot specify FIELD_KIND_STMT here because FunctionExpression is + # a FIELD_KIND_EXPR +} +nodes { + name: "BlockStatementFunction" + parents: "Function" + fields { + name: "body" + type { class: "BlockStatement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } +} + +# interface Statement <: Node { } +nodes { + name: "Statement" + parents: "Node" + kinds: FIELD_KIND_STMT +} + +# interface ExpressionStatement <: Statement { +# type: "ExpressionStatement"; +# expression: Expression; +# } +nodes { + name: "ExpressionStatement" + type: "ExpressionStatement" + parents: "Statement" + fields { + name: "expression" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface BlockStatement <: Statement { +# type: "BlockStatement"; +# body: [ Statement ]; +# directives: [ Directive ]; +# } +nodes { + name: "BlockStatement" + parents: "Statement" + type: "BlockStatement" + fields { + name: "body" + type { + list { + element_type { class: "Statement" } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "directives" + type { + list { + element_type { class: "Directive" } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# interface EmptyStatement <: Statement { +# type: "EmptyStatement"; +# } +nodes { + name: "EmptyStatement" + parents: "Statement" + type: "EmptyStatement" + should_generate_ir_op: true +} + +# interface DebuggerStatement <: Statement { +# type: "DebuggerStatement"; +# } +nodes { + name: "DebuggerStatement" + parents: "Statement" + type: "DebuggerStatement" + should_generate_ir_op: true +} + +# interface WithStatement <: Statement { +# type: "WithStatement"; +# object: Expression; +# body: Statement; +# } +nodes { + name: "WithStatement" + parents: "Statement" + type: "WithStatement" + fields { + name: "object" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "body" + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# interface ReturnStatement <: Statement { +# type: "ReturnStatement"; +# argument: Expression | null; +# } +nodes { + name: "ReturnStatement" + parents: "Statement" + type: "ReturnStatement" + fields { + name: "argument" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface LabeledStatement <: Statement { +# type: "LabeledStatement"; +# label: Identifier; +# body: Statement; +# } +nodes { + name: "LabeledStatement" + parents: "Statement" + type: "LabeledStatement" + fields { + name: "label" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + fields { + name: "body" + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# interface BreakStatement <: Statement { +# type: "BreakStatement"; +# label: Identifier | null; +# } +nodes { + name: "BreakStatement" + parents: "Statement" + type: "BreakStatement" + fields { + name: "label" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + has_control_flow: true +} + +# interface ContinueStatement <: Statement { +# type: "ContinueStatement"; +# label: Identifier | null; +# } +nodes { + name: "ContinueStatement" + parents: "Statement" + type: "ContinueStatement" + fields { + name: "label" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + has_control_flow: true +} + +# interface IfStatement <: Statement { +# type: "IfStatement"; +# test: Expression; +# consequent: Statement; +# alternate: Statement | null; +# } +nodes { + name: "IfStatement" + parents: "Statement" + type: "IfStatement" + fields { + name: "test" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "consequent" + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "alternate" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# interface SwitchStatement <: Statement { +# type: "SwitchStatement"; +# discriminant: Expression; +# cases: [ SwitchCase ]; +# } +nodes { + name: "SwitchStatement" + parents: "Statement" + type: "SwitchStatement" + fields { + name: "discriminant" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "cases" + type { + list { + element_type { class: "SwitchCase" } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + has_control_flow: true + should_generate_ir_op: true +} + +# interface SwitchCase <: Node { +# type: "SwitchCase"; +# test: Expression | null; +# consequent: [ Statement ]; +# } +nodes { + name: "SwitchCase" + parents: "Node" + type: "SwitchCase" + fields { + name: "test" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "consequent" + type { + list { + element_type { class: "Statement" } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + has_control_flow: true + should_generate_ir_op: true +} + +# interface ThrowStatement <: Statement { +# type: "ThrowStatement"; +# argument: Expression; +# } +nodes { + name: "ThrowStatement" + parents: "Statement" + type: "ThrowStatement" + fields { + name: "argument" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface TryStatement <: Statement { +# type: "TryStatement"; +# block: BlockStatement; +# handler: CatchClause | null; +# finalizer: BlockStatement | null; +# } +nodes { + name: "TryStatement" + parents: "Statement" + type: "TryStatement" + fields { + name: "block" + type { class: "BlockStatement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "handler" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "CatchClause" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "finalizer" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "BlockStatement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# // interface CatchClause <: Node { +# // type: "CatchClause"; +# // param?: Pattern; +# // body: BlockStatement; +# // } +# interface CatchClause <: Node { +# type: "CatchClause"; +# param: Pattern | null; +# body: BlockStatement; +# } +nodes { + name: "CatchClause" + type: "CatchClause" + parents: "Node" + fields { + name: "param" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Pattern" } + kind: FIELD_KIND_LVAL + } + fields { + name: "body" + type { class: "BlockStatement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + has_control_flow: true + should_generate_ir_op: true +} + +# interface WhileStatement <: Statement { +# type: "WhileStatement"; +# test: Expression; +# body: Statement; +# } +nodes { + name: "WhileStatement" + parents: "Statement" + type: "WhileStatement" + fields { + name: "test" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "body" + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + has_control_flow: true + should_generate_ir_op: true +} + +# interface DoWhileStatement <: Statement { +# type: "DoWhileStatement"; +# body: Statement; +# test: Expression; +# } +nodes { + name: "DoWhileStatement" + parents: "Statement" + type: "DoWhileStatement" + fields { + name: "body" + type { class: "Statement" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "test" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + has_control_flow: true + should_generate_ir_op: true +} + +# interface ForStatement <: Statement { +# type: "ForStatement"; +# init: VariableDeclaration | Expression | null; +# test: Expression | null; +# update: Expression | null; +# body: Statement; +# } +nodes { + name: "ForStatement" + parents: "Statement" + type: "ForStatement" + fields { + name: "init" + optionalness: OPTIONALNESS_MAYBE_NULL + type { + variant { + types { class: "VariableDeclaration" } + types { class: "Expression" } + } + } + } + fields { + name: "test" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + } + fields { + name: "update" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + } + fields { + name: "body" + type { class: "Statement" } + } + has_control_flow: true + should_generate_ir_op: false +} + +# // interface ForInStatement <: Statement { +# // type: "ForInStatement"; +# // left: VariableDeclaration | Expression; +# // right: Expression; +# // body: Statement; +# // } +# interface ForInStatement <: Statement { +# type: "ForInStatement"; +# left: VariableDeclaration | LVal; +# right: Expression; +# body: Statement; +# } +nodes { + name: "ForInStatement" + parents: "Statement" + type: "ForInStatement" + fields { + name: "left" + type { + variant { + types { class: "VariableDeclaration" } + types { class: "LVal" } + } + } + } + fields { + name: "right" + type { class: "Expression" } + } + fields { + name: "body" + type { class: "Statement" } + } + has_control_flow: true + should_generate_ir_op: false +} + +# // interface ForOfStatement <: ForInStatement { +# // type: "ForOfStatement"; +# // await: boolean; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We shouldn't override a leaf type. +# ------------------------------------------------------------------------------ +# interface ForOfStatement <: Statement { +# type: "ForOfStatement"; +# left: VariableDeclaration | LVal; +# right: Expression; +# body: Statement; +# await: boolean; +# } +nodes { + name: "ForOfStatement" + parents: "Statement" + type: "ForOfStatement" + fields { + name: "left" + type { + variant { + types { class: "VariableDeclaration" } + types { class: "LVal" } + } + } + } + fields { + name: "right" + type { class: "Expression" } + } + fields { + name: "body" + type { class: "Statement" } + } + fields { + name: "await" + type { bool {} } + } + has_control_flow: true + should_generate_ir_op: false +} + +# interface Declaration <: Statement { } +nodes { + name: "Declaration" + parents: "Statement" +} + +# // interface FunctionDeclaration <: Function, Declaration { +# // type: "FunctionDeclaration"; +# // id: Identifier; +# // } +# ------------------------------------------------------------------------------ +# NOTE: Sometimes id is optional. +# interface FunctionDeclaration <: BlockStatementFunction, Declaration { +# type: "FunctionDeclaration"; +# } +nodes { + name: "FunctionDeclaration" + parents: "BlockStatementFunction" + parents: "Declaration" + type: "FunctionDeclaration" + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# interface VariableDeclaration <: Declaration { +# type: "VariableDeclaration"; +# declarations: [ VariableDeclarator ]; +# kind: "var" | "let" | "const"; +# } +nodes { + name: "VariableDeclaration" + parents: "Declaration" + type: "VariableDeclaration" + fields { + name: "declarations" + type { + list { + element_type { class: "VariableDeclarator" } + } + } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "kind" + type { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# // interface VariableDeclarator <: Node { +# // type: "VariableDeclarator"; +# // id: Pattern; +# // init: Expression | null; +# // } +# interface VariableDeclarator <: Node { +# type: "VariableDeclarator"; +# id: LVal; +# init: Expression | null; +# } +nodes { + name: "VariableDeclarator" + parents: "Node" + type: "VariableDeclarator" + fields { + name: "id" + type { class: "LVal" } + kind: FIELD_KIND_LVAL + } + fields { + name: "init" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true +} + +# // interface Decorator <: Node { +# // type: "Decorator"; +# // expression: Expression; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decorators" plugin. +# ------------------------------------------------------------------------------ + +# interface Directive <: Node { +# type: "Directive"; +# value: DirectiveLiteral; +# } +# ------------------------------------------------------------------------------ +# Example: +# "use strict" +# ------------------------------------------------------------------------------ +nodes { + name: "Directive" + parents: "Node" + type: "Directive" + fields { + name: "value" + type { class: "DirectiveLiteral" } + kind: FIELD_KIND_RVAL + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# // interface DirectiveLiteral <: StringLiteral { +# // type: "DirectiveLiteral"; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We shouldn't override a leaf type. +# ------------------------------------------------------------------------------ +# interface DirectiveLiteral <: Node { +# type: "DirectiveLiteral"; +# value: string; +# extra?: { +# raw: string; +# rawValue: string; +# } +# } +nodes { + name: "DirectiveLiteralExtra" + type: "DirectiveLiteralExtra" + fields { + name: "raw" + type: { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "rawValue" + type: { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR +} + +nodes { + name: "DirectiveLiteral" + parents: "Node" + type: "DirectiveLiteral" + fields { + name: "value" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "extra" + type { class: "DirectiveLiteralExtra" } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# +# interface InterpreterDirective <: StringLiteral { +# type: "InterpreterDirective"; +# } +# +# ------------------------------------------------------------------------------ +# NOTE: We shouldn't override a leaf type. +# ------------------------------------------------------------------------------ +# interface InterpreterDirective <: Node { +# type: "InterpreterDirective"; +# value: string; +# } +# ------------------------------------------------------------------------------ +# Example: +# #!/usr/bin/env node +# ------------------------------------------------------------------------------ +nodes { + name: "InterpreterDirective" + parents: "Node" + type: "InterpreterDirective" + fields { + name: "value" + type { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR + should_generate_ir_op: false + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface Expression <: Node { } +nodes { + name: "Expression" + parents: "Node" + kinds: FIELD_KIND_RVAL +} + +# (From @babel/types) +# type LVal = +# | Identifier (is Pattern) +# | MemberExpression (is Pattern) +# | RestElement (is Pattern) +# | AssignmentPattern +# | ArrayPattern +# | ObjectPattern +# | TSParameterProperty +nodes { + name: "LVal" + parents: "Node" + kinds: FIELD_KIND_LVAL + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface Super <: Node { +# type: "Super"; +# } +# ------------------------------------------------------------------------------ +# NOTE: A `super` pseudo-expression. +# +# Only used in: +# - MemberExpression::object +# - CallExpression::callee +# - NewExpression::callee +# +# Example: +# return super.foo; +# ~~~~~ +# ------------------------------------------------------------------------------ +nodes { + name: "Super" + parents: "Node" + type: "Super" + should_generate_ir_op: true + kinds: FIELD_KIND_RVAL + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface Import <: Node { +# type: "Import"; +# } +# ------------------------------------------------------------------------------ +# NOTE: A `import` pseudo-expression. +# +# Only used in: +# - CallExpression::callee +# - NewExpression::callee +# +# Example: +# import('test.js'); +# ~~~~~~ +# ------------------------------------------------------------------------------ +nodes { + name: "Import" + parents: "Node" + type: "Import" + should_generate_ir_op: true + kinds: FIELD_KIND_RVAL +} + +# interface ThisExpression <: Expression { +# type: "ThisExpression"; +# } +nodes { + name: "ThisExpression" + parents: "Expression" + type: "ThisExpression" + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface ArrowFunctionExpression <: Function, Expression { +# type: "ArrowFunctionExpression"; +# body: BlockStatement | Expression; +# } +nodes { + name: "ArrowFunctionExpression" + parents: "Function" + parents: "Expression" + type: "ArrowFunctionExpression" + fields { + name: "body" + type { + variant { + types { class: "BlockStatement" } + types { class: "Expression" } + } + } + } + should_generate_ir_op: false +} + +# interface YieldExpression <: Expression { +# type: "YieldExpression"; +# argument: Expression | null; +# delegate: boolean; +# } +nodes { + name: "YieldExpression" + type: "YieldExpression" + parents: "Expression" + fields { + name: "argument" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "delegate" + type { bool {} } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface AwaitExpression <: Expression { +# type: "AwaitExpression"; +# argument: Expression | null; +# } +nodes { + name: "AwaitExpression" + parents: "Expression" + type: "AwaitExpression" + fields { + name: "argument" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface ArrayExpression <: Expression { +# type: "ArrayExpression"; +# elements: [ Expression | SpreadElement | null ]; +# } +nodes { + name: "ArrayExpression" + parents: "Expression" + type: "ArrayExpression" + fields { + name: "elements" + type { + list { + element_type { + variant { + types { class: "Expression" } + types { class: "SpreadElement" } + } + } + element_maybe_null: true + } + } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface ObjectExpression <: Expression { +# type: "ObjectExpression"; +# properties: [ ObjectProperty | ObjectMethod | SpreadElement ]; +# } +nodes { + name: "ObjectExpression" + type: "ObjectExpression" + parents: "Expression" + fields { + name: "properties" + type { + list { + element_type { + variant { + types { class: "ObjectProperty" } + types { class: "ObjectMethod" } + types { class: "SpreadElement" } + } + } + } + } + } + should_generate_ir_op: false +} + +# // interface ObjectMember <: Node { +# // key: Expression; +# // computed: boolean; +# // decorators: [ Decorator ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decorators" plugin. +# ------------------------------------------------------------------------------ +# interface ObjectMember <: Node { +# key: Expression; +# computed: boolean; +# } +nodes { + name: "ObjectMember" + parents: "Node" + fields { + name: "key" + type { class: "Expression" } + } + fields { + name: "computed" + type { bool {} } + } +} + +# // interface ObjectProperty <: ObjectMember { +# // type: "ObjectProperty"; +# // shorthand: boolean; +# // value: Expression; +# // } +# interface ObjectProperty <: ObjectMember { +# type: "ObjectProperty"; +# shorthand: boolean; +# value: Expression | Pattern; +# } +nodes { + name: "ObjectProperty" + parents: "ObjectMember" + type: "ObjectProperty" + fields { + name: "shorthand" + type { bool {} } + } + fields { + name: "value" + type { + variant { + types { class: "Expression" } + types { class: "Pattern" } + } + } + } + kinds: FIELD_KIND_LVAL + kinds: FIELD_KIND_RVAL +} + +# +# interface ObjectMethod <: ObjectMember, Function { +# type: "ObjectMethod"; +# kind: "get" | "set" | "method"; +# } +# +# ------------------------------------------------------------------------------ +# interface ObjectMethod <: ObjectMember, BlockStatementFunction { +# type: "ObjectMethod"; +# kind: "get" | "set" | "method"; +# } +nodes { + name: "ObjectMethod" + type: "ObjectMethod" + parents: "ObjectMember" + parents: "BlockStatementFunction" + fields { + name: "kind" + type { string {} } + } +} + +# // interface RecordExpression <: Expression { +# // type: "RecordExpression"; +# // properties: [ ObjectProperty | ObjectMethod | SpreadElement ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "recordAndTuple" plugin. +# ------------------------------------------------------------------------------ + +# // interface TupleExpression <: Expression { +# // type: "TupleExpression"; +# // elements: [ Expression | SpreadElement | null ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "recordAndTuple" plugin. +# ------------------------------------------------------------------------------ + +# interface FunctionExpression <: BlockStatementFunction, Expression { +# type: "FunctionExpression"; +# } +nodes { + name: "FunctionExpression" + type: "FunctionExpression" + parents: "BlockStatementFunction" + parents: "Expression" + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true +} + +# interface UnaryExpression <: Expression { +# type: "UnaryExpression"; +# operator: UnaryOperator; +# prefix: boolean; +# argument: Expression; +# } +# enum UnaryOperator { +# "-" | "+" | "!" | "~" | "typeof" | "void" | "delete" | "throw" +# } +nodes { + name: "UnaryExpression" + type: "UnaryExpression" + parents: "Expression" + fields { + name: "operator" + type { enum: "UnaryOperator" } + kind: FIELD_KIND_ATTR + } + fields { + name: "prefix" + type { bool {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "argument" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + has_fold: true +} + +# // Original: +# // interface UpdateExpression <: Expression { +# // type: "UpdateExpression"; +# // operator: UpdateOperator; +# // argument: Expression; +# // prefix: boolean; +# // } +# interface UpdateExpression <: Expression { +# type: "UpdateExpression"; +# operator: UpdateOperator; +# argument: LVal; +# prefix: boolean; +# } +# enum UpdateOperator { +# "++" | "--" +# } +nodes { + name: "UpdateExpression" + type: "UpdateExpression" + parents: "Expression" + fields { + name: "operator" + type { enum: "UpdateOperator" } + kind: FIELD_KIND_ATTR + } + fields { + name: "argument" + type { class: "LVal" } + kind: FIELD_KIND_LVAL + } + fields { + name: "prefix" + type { bool {} } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface BinaryExpression <: Expression { +# type: "BinaryExpression"; +# operator: BinaryOperator; +# left: Expression | PrivateName; +# right: Expression; +# } +# enum BinaryOperator { +# "==" | "!=" | "===" | "!==" +# | "<" | "<=" | ">" | ">=" +# | "<<" | ">>" | ">>>" +# | "+" | "-" | "*" | "/" | "%" +# | "**" | "|" | "^" | "&" | "in" +# | "instanceof" +# | "|>" +# } +nodes { + name: "BinaryExpression" + type: "BinaryExpression" + parents: "Expression" + fields { + name: "operator" + type { enum: "BinaryOperator" } + kind: FIELD_KIND_ATTR + } + fields { + name: "left" + type { + variant { + types { class: "Expression" } + types { class: "PrivateName" } + } + } + kind: FIELD_KIND_RVAL + } + fields { + name: "right" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + has_fold: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# // interface AssignmentExpression <: Expression { +# // type: "AssignmentExpression"; +# // operator: AssignmentOperator; +# // left: Pattern | Expression; +# // right: Expression; +# // } +# interface AssignmentExpression <: Expression { +# type: "AssignmentExpression"; +# operator: AssignmentOperator; +# left: LVal; +# right: Expression; +# } +# enum AssignmentOperator { +# "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" +# | "<<=" | ">>=" | ">>>=" +# | "|=" | "^=" | "&=" +# | "||=" | "&&=" | "??=" +# } +nodes { + name: "AssignmentExpression" + parents: "Expression" + type: "AssignmentExpression" + fields { + name: "operator" + type { enum: "AssignmentOperator" } + kind: FIELD_KIND_ATTR + } + fields { + name: "left" + type { class: "LVal" } + kind: FIELD_KIND_LVAL + } + fields { + name: "right" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface LogicalExpression <: Expression { +# type: "LogicalExpression"; +# operator: LogicalOperator; +# left: Expression; +# right: Expression; +# } +# enum LogicalOperator { +# "||" | "&&" | "??" +# } +nodes { + name: "LogicalExpression" + parents: "Expression" + type: "LogicalExpression" + fields { + name: "operator" + type { enum: "LogicalOperator" } + kind: FIELD_KIND_ATTR + } + fields { + name: "left" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "right" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + should_generate_ir_op: true + has_control_flow: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface SpreadElement <: Node { +# type: "SpreadElement"; +# argument: Expression; +# } +# ------------------------------------------------------------------------------ +# Example: +# func(...a) +# ~~~~ +# ------------------------------------------------------------------------------ +nodes { + name: "SpreadElement" + parents: "Node" + type: "SpreadElement" + fields { + name: "argument" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# // interface ArgumentPlaceholder <: Node { +# // type: "ArgumentPlaceholder"; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "partialApplication" plugin. +# ------------------------------------------------------------------------------ + +# // interface MemberExpression <: Expression, Pattern { +# // type: "MemberExpression"; +# // object: Expression | Super; +# // property: Expression | PrivateName; +# // computed: boolean; +# // } +# interface MemberExpression <: Expression, Pattern, LVal { +# type: "MemberExpression"; +# object: Expression | Super; +# property: Expression | PrivateName; +# computed: boolean; +# } +# ------------------------------------------------------------------------------ +# NOTE: A member expression. +# - If `computed` is `true`, the node corresponds to a computed (`a[b]`) member +# expression and `property` is an `Expression`. +# - If `computed` is `false`, the node corresponds to a static (`a.b`) member +# expression and `property` is an `Identifier` or a `PrivateName`. +# ------------------------------------------------------------------------------ +nodes { + name: "MemberExpression" + parents: "Expression" + parents: "Pattern" + parents: "LVal" + type: "MemberExpression" + fields { + name: "object" + type { + variant { + types { class: "Expression" } + types { class: "Super" } + } + } + } + fields { + name: "property" + type { + variant { + types { class: "Expression" } + types { class: "PrivateName" } + } + } + } + fields { + name: "computed" + type { bool {} } + } + should_generate_ir_op: false +} + +# interface OptionalMemberExpression <: Expression { +# type: "OptionalMemberExpression"; +# object: Expression; +# property: Expression | PrivateName; +# computed: boolean; +# optional: boolean; +# } +# TODO(tzx) Why not used anywhere? +# ------------------------------------------------------------------------------ +# NOTE: An optional member expression is a part of the optional chain. +# +# When `optional` is `true`, it is the starting element of the optional chain. +# +# In `a?.b.c`: +# - `?.b` is an optional member expression with `optional: true` +# - `.c` is an optional member expression +# +# See https://gist.github.com/JLHwung/567fb29fa2b82bbe164ad9067ff3290f for more +# AST examples. +# ------------------------------------------------------------------------------ +nodes { + name: "OptionalMemberExpression" + parents: "Expression" + type: "OptionalMemberExpression" + fields { + name: "object" + type { class: "Expression" } + } + fields { + name: "property" + type { + variant { + types { class: "Expression" } + types { class: "PrivateName" } + } + } + } + fields { + name: "computed" + type { bool {} } + } + fields { + name: "optional" + type { bool {} } + } + should_generate_ir_op: false +} + +# // interface BindExpression <: Expression { +# // type: "BindExpression"; +# // object: Expression | null; +# // callee: Expression; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "functionBind" plugin. +# ------------------------------------------------------------------------------ + +# interface PipelineBody <: NodeBase { +# type: "PipelineBody"; +# } + +# interface PipelineBody <: NodeBase { +# type: "PipelineBareFunctionBody"; +# callee: Expression; +# } + +# interface PipelineBareConstructorBody <: NodeBase { +# type: "PipelineBareConstructorBody"; +# callee: Expression; +# } + +# interface PipelineBareConstructorBody <: NodeBase { +# type: "PipelineTopicBody"; +# expression: Expression; +# } + +# interface PipelineBareConstructorBody <: NodeBase { +# type: "PipelineBareAwaitedFunctionBody"; +# callee: Expression; +# } + +# interface ConditionalExpression <: Expression { +# type: "ConditionalExpression"; +# test: Expression; +# alternate: Expression; +# consequent: Expression; +# } +nodes { + name: "ConditionalExpression" + type: "ConditionalExpression" + parents: "Expression" + fields { + name: "test" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "alternate" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "consequent" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + has_control_flow: true + should_generate_ir_op: true +} + +# interface CallExpression <: Expression { +# type: "CallExpression"; +# callee: Expression | Super | Import; +# arguments: [ Expression | SpreadElement ]; +# } +nodes { + name: "CallExpression" + parents: "Expression" + type: "CallExpression" + fields { + name: "callee" + type { + variant { + types { class: "Expression" } + types { class: "Super" } + types { class: "Import" } + } + } + kind: FIELD_KIND_RVAL + } + fields { + name: "arguments" + type { + list { + element_type { + variant { + types { class: "Expression" } + types { class: "SpreadElement" } + } + } + } + } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface OptionalCallExpression <: Expression { +# type: "OptionalCallExpression"; +# callee: Expression; +# arguments: [ Expression | SpreadElement ]; +# optional: boolean; +# } +nodes { + name: "OptionalCallExpression" + parents: "Expression" + type: "OptionalCallExpression" + fields { + name: "callee" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "arguments" + type { + list { + element_type { + variant { + types { class: "Expression" } + types { class: "SpreadElement" } + } + } + } + } + kind: FIELD_KIND_RVAL + } + fields { + name: "optional" + type { bool {} } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# // interface NewExpression <: CallExpression { +# // type: "NewExpression"; +# // } +# interface NewExpression <: Expression { +# type: "NewExpression"; +# callee: Expression | Super | Import; +# arguments: [ Expression | SpreadElement ]; +# } +nodes { + name: "NewExpression" + type: "NewExpression" + parents: "Expression" + fields { + name: "callee" + type { + variant { + types { class: "Expression" } + types { class: "Super" } + types { class: "Import" } + } + } + kind: FIELD_KIND_RVAL + } + fields { + name: "arguments" + type { + list { + element_type { + variant { + types { class: "Expression" } + types { class: "SpreadElement" } + } + } + } + } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# interface SequenceExpression <: Expression { +# type: "SequenceExpression"; +# expressions: [ Expression ]; +# } +nodes { + name: "SequenceExpression" + parents: "Expression" + type: "SequenceExpression" + fields { + name: "expressions" + type { + list { + element_type { class: "Expression" } + } + } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# // Original: +# // interface ParenthesizedExpression <: Expression { +# // type "ParenthesizedExpression"; +# // expression: Expression; +# // } +# interface ParenthesizedExpression <: Expression, Pattern, LVal { +# type "ParenthesizedExpression"; +# expression: Expression; +# } +nodes { + name: "ParenthesizedExpression" + parents: "Expression" + parents: "Pattern" + parents: "LVal" + type: "ParenthesizedExpression" + fields { + name: "expression" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: false + has_fold: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# // interface DoExpression <: Expression { +# // type: "DoExpression"; +# // body: BlockStatement; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "doExpression" plugin. +# ------------------------------------------------------------------------------ + +# // interface ModuleExpression <: Expression { +# // type: "ModuleExpression"; +# // body: Program +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "moduleBlocks" plugin. +# ------------------------------------------------------------------------------ + +# interface TemplateLiteral <: Expression { +# type: "TemplateLiteral"; +# quasis: [ TemplateElement ]; +# expressions: [ Expression ]; +# } +# ------------------------------------------------------------------------------ +# Example: +# `a${b}c${d}` +# ~~~~~~~~~~~~ TemplateLiteral +# ~ ~ ~ quasis (including the last "") +# ~~~~ ~~~~ expressions +# ------------------------------------------------------------------------------ +nodes { + name: "TemplateLiteral" + parents: "Expression" + type: "TemplateLiteral" + fields { + name: "quasis" + type { + list { + element_type { class: "TemplateElement" } + } + } + kind: FIELD_KIND_RVAL + } + fields { + name: "expressions" + type { + list { + element_type { class: "Expression" } + } + } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface TaggedTemplateExpression <: Expression { +# type: "TaggedTemplateExpression"; +# tag: Expression; +# quasi: TemplateLiteral; +# } +# ------------------------------------------------------------------------------ +# Example: +# raw`42` +# ~~~~~~~ TaggedTemplateExpression +# ~~~ tag +# ~~~~ quasi +# ------------------------------------------------------------------------------ +nodes { + name: "TaggedTemplateExpression" + parents: "Expression" + type: "TaggedTemplateExpression" + fields { + name: "tag" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "quasi" + type { class: "TemplateLiteral" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface TemplateElement <: Node { +# type: "TemplateElement"; +# tail: boolean; +# value: { +# cooked: string | null; +# raw: string; +# }; +# } +nodes { + name: "TemplateElementValue" + fields { + name: "cooked" + optionalness: OPTIONALNESS_MAYBE_NULL + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "raw" + type { string {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true +} +nodes { + name: "TemplateElement" + parents: "Node" + type: "TemplateElement" + fields { + name: "tail" + type { bool {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "value" + type { class: "TemplateElementValue" } + kind: FIELD_KIND_RVAL + } + kinds: FIELD_KIND_RVAL + should_generate_ir_op: true + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# interface Pattern <: Node { } +nodes { + name: "Pattern" + parents: "Node" + kinds: FIELD_KIND_LVAL + additional_mlir_traits: MLIR_TRAIT_PURE +} + +# // interface AssignmentProperty <: ObjectProperty { +# // value: Pattern; +# // } +# Note: ObjectProperty is already a leaf type. Here the spec tries to override +# the type of "value" from "Expression" to "Pattern". +# Therefore, we just let "value" be "Expression | Pattern" in ObjectProperty, +# and thus delete AssignmentProperty. + +# // interface ObjectPattern <: Pattern { +# // type: "ObjectPattern"; +# // properties: [ AssignmentProperty | RestElement ]; +# // } +# interface ObjectPattern <: Pattern, LVal { +# type: "ObjectPattern"; +# properties: [ ObjectProperty | RestElement ]; +# } +nodes { + name: "ObjectPattern" + type: "ObjectPattern" + parents: "Pattern" + parents: "LVal" + fields { + name: "properties" + type { + list { + element_type { + variant { + types { class: "ObjectProperty" } + types { class: "RestElement" } + } + } + } + } + kind: FIELD_KIND_LVAL + enclose_in_region: true + } + should_generate_ir_op: true +} + +# // interface ArrayPattern <: Pattern { +# // type: "ArrayPattern"; +# // elements: [ Pattern | null ]; +# // } +# interface ArrayPattern <: Pattern, LVal { +# type: "ArrayPattern"; +# elements: [ Pattern | null ]; +# } +nodes { + name: "ArrayPattern" + type: "ArrayPattern" + parents: "Pattern" + parents: "LVal" + fields { + name: "elements" + type { + list { + element_type { class: "Pattern" } + element_maybe_null: true + } + } + kind: FIELD_KIND_LVAL + } + should_generate_ir_op: true +} + +# // interface RestElement <: Pattern { +# // type: "RestElement"; +# // argument: Pattern; +# // } +# interface RestElement <: Pattern, LVal { +# type: "RestElement"; +# argument: LVal; +# } +nodes { + name: "RestElement" + parents: "Pattern" + parents: "LVal" + type: "RestElement" + fields { + name: "argument" + type { class: "LVal" } + kind: FIELD_KIND_LVAL + } + should_generate_ir_op: true +} + +# // interface AssignmentPattern <: Pattern { +# // type: "AssignmentPattern"; +# // left: Pattern; +# // right: Expression; +# // } +# interface AssignmentPattern <: Pattern, LVal { +# type: "AssignmentPattern"; +# left: Pattern; +# right: Expression; +# } +nodes { + name: "AssignmentPattern" + parents: "Pattern" + parents: "LVal" + type: "AssignmentPattern" + fields { + name: "left" + type { class: "Pattern" } + kind: FIELD_KIND_LVAL + } + fields { + name: "right" + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + should_generate_ir_op: true +} + +# // interface Class <: Node { +# // id: Identifier | null; +# // superClass: Expression | null; +# // body: ClassBody; +# // decorators: [ Decorator ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decorators" plugin. +# ------------------------------------------------------------------------------ +# interface Class <: Node { +# superClass: Expression | null; +# body: ClassBody; +# } +nodes { + name: "Class" + parents: "Node" + fields { + name: "superClass" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + } + fields { + name: "body" + type { class: "ClassBody" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } +} + +# // interface ClassBody <: Node { +# // type: "ClassBody"; +# // body: [ ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | StaticBlock ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "classStaticBlock" plugin. +# ------------------------------------------------------------------------------ +# interface ClassBody <: Node { +# type: "ClassBody"; +# body: [ ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty ]; +# } +nodes { + name: "ClassBody" + type: "ClassBody" + parents: "Node" + fields { + name: "body" + type { + list { + element_type { + variant { + types { class: "ClassMethod" } + types { class: "ClassPrivateMethod" } + types { class: "ClassProperty" } + types { class: "ClassPrivateProperty" } + } + } + } + } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# // interface ClassMethod <: Function { +# // type: "ClassMethod"; +# // key: Expression; +# // kind: "constructor" | "method" | "get" | "set"; +# // computed: boolean; +# // static: boolean; +# // decorators: [ Decorator ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decorators" plugin. +# ------------------------------------------------------------------------------ +# interface ClassMethod <: BodyStatementFunction { +# type: "ClassMethod"; +# key: Expression; +# kind: "constructor" | "method" | "get" | "set"; +# computed: boolean; +# static: boolean; +# } +# +# NOTE: +# - If computed is false, key must be one of: +# - Identifier +# - StringLiteral +# - NumericLiteral +# +# Example: +# ``` +# class MyClass { +# foo() {} // Identifier +# "bar"() {} // StringLiteral +# 1.0() {} // NumericLiteral +# } +# +# let obj = new MyClass(); +# console.log(obj.foo); +# console.log(obj["foo"]); +# console.log(obj.bar); +# console.log(obj["bar"]); +# console.log(obj[1.0]); +# ``` +# +# Reference: https://tc39.es/ecma262/#prod-LiteralPropertyName +# +# - If computed is true, key can be any expression (rvalue). +# +# Example: +# ``` +# let foo = "oof"; +# let bar = "rab"; +# let baz = "zab"; +# +# class MyClass { +# [foo]() {} +# [bar + baz]() {} +# [1.0]() {} +# } +# +# let obj = new MyClass(); +# console.log(obj.oof); +# console.log(obj["oof"]); +# console.log(obj.zabrab); +# console.log(obj["zabrab"]); +# console.log(obj[1.0]); +# ``` +# +# Reference: https://tc39.es/ecma262/#prod-ComputedPropertyName +nodes { + name: "ClassMethod" + parents: "BlockStatementFunction" + type: "ClassMethod" + fields { + name: "key" + type { class: "Expression" } + } + fields { + name: "kind" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "computed" + type { bool {} } + } + fields { + name: "static" + type { bool {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: false +} + +# // interface ClassPrivateMethod <: Function { +# // type: "ClassPrivateMethod"; +# // key: PrivateName; +# // kind: "method" | "get" | "set"; +# // static: boolean; +# // decorators: [ Decorator ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "decorators" plugin. +# ------------------------------------------------------------------------------ +# interface ClassPrivateMethod <: BlockStatementFunction { +# type: "ClassPrivateMethod"; +# key: PrivateName; +# kind: "method" | "get" | "set"; +# static: boolean; +# computed?: boolean; # Actually always false +# } +nodes { + name: "ClassPrivateMethod" + parents: "BlockStatementFunction" + type: "ClassPrivateMethod" + fields { + name: "key" + type { class: "PrivateName" } + kind: FIELD_KIND_ATTR + } + fields { + name: "kind" + type { string {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "static" + type { bool {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "computed" + type { bool {} } + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: false +} + +# // interface ClassProperty <: Node { +# // type: "ClassProperty"; +# // key: Expression; +# // value: Expression; +# // static: boolean; +# // computed: boolean; +# // } +# interface ClassProperty <: Node { +# type: "ClassProperty"; +# key: Expression; +# value: Expression | null; +# static: boolean; +# computed: boolean; +# } +# +# NOTE: +# - If computed is false, key must be one of: +# - Identifier +# - StringLiteral +# - NumericLiteral +# +# Example: +# ``` +# class MyClass { +# foo = 1 // Identifier +# "bar" = 1 // StringLiteral +# 1.0 = 1 // NumericLiteral +# } +# +# let obj = new MyClass(); +# console.log(obj.foo); +# console.log(obj["foo"]); +# console.log(obj.bar); +# console.log(obj["bar"]); +# console.log(obj[1.0]); +# ``` +# +# Reference: https://tc39.es/ecma262/#prod-LiteralPropertyName +# +# - If computed is true, key can be any expression (rvalue). +# +# Example: +# ``` +# let foo = "oof"; +# let bar = "rab"; +# let baz = "zab"; +# +# class MyClass { +# [foo] = 1 +# [bar + baz] = 1 +# [1.0] = 1 +# } +# +# let obj = new MyClass(); +# console.log(obj.oof); +# console.log(obj["oof"]); +# console.log(obj.zabrab); +# console.log(obj["zabrab"]); +# console.log(obj[1.0]); +# ``` +# +# Reference: https://tc39.es/ecma262/#prod-ComputedPropertyName +nodes { + name: "ClassProperty" + parents: "Node" + type: "ClassProperty" + fields { + name: "key" + type { class: "Expression" } + } + fields { + name: "value" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "static" + type { bool {} } + kind: FIELD_KIND_ATTR + } + fields { + name: "computed" + type { bool {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: false +} + +# // interface ClassPrivateProperty <: Node { +# // type: "ClassPrivateProperty"; +# // key: PrivateName; +# // value: Expression; +# // static: boolean; +# // } +# interface ClassPrivateProperty <: Node { +# type: "ClassPrivateProperty"; +# key: PrivateName; +# value: Expression | null; +# static: boolean; +# } +nodes { + name: "ClassPrivateProperty" + parents: "Node" + type: "ClassPrivateProperty" + fields { + name: "key" + type { class: "PrivateName" } + kind: FIELD_KIND_ATTR + } + fields { + name: "value" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Expression" } + kind: FIELD_KIND_RVAL + enclose_in_region: true + } + fields { + name: "static" + type { bool {} } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} + +# // interface StaticBlock <: Node { +# // type: "StaticBlock"; +# // body: [ Statement ]; +# // } +# ------------------------------------------------------------------------------ +# NOTE: We don't enable the Babel "classStaticBlock" plugin. +# ------------------------------------------------------------------------------ + +# // interface ClassDeclaration <: Class, Declaration { +# // type: "ClassDeclaration"; +# // id: Identifier; +# // } +# ------------------------------------------------------------------------------ +# NOTE: The spec also has OptClassDeclaration where id: Identifier | null. +# We can't support field type override. +# Therefore, we always let id: Identifier | null, and delete +# OptClassDeclaration. +# ------------------------------------------------------------------------------ +# interface ClassDeclaration <: Class, Declaration { +# type: "ClassDeclaration"; +# id: Identifier | null; +# } +nodes { + name: "ClassDeclaration" + parents: "Class" + parents: "Declaration" + type: "ClassDeclaration" + fields { + name: "id" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface ClassExpression <: Class, Expression { +# type: "ClassExpression"; +# } +# ------------------------------------------------------------------------------ +# NOTE: ??? +# ------------------------------------------------------------------------------ +# interface ClassExpression <: Class, Expression { +# type: "ClassExpression"; +# id: string | null +# } +nodes { + name: "ClassExpression" + parents: "Class" + parents: "Expression" + type: "ClassExpression" + fields { + name: "id" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface MetaProperty <: Expression { +# type: "MetaProperty"; +# meta: Identifier; +# property: Identifier; +# } +# ------------------------------------------------------------------------------ +# NOTE: +# MetaProperty is used for special "." expressions. +# Normally, "." would be represented by MemberExpression. +# +# Currently, only the following are meta properties: +# - import.meta +# - new.target +# - function.sent +# (will be a SyntaxError, since it requires the "functionSent" Babel plugin) +# ------------------------------------------------------------------------------ +nodes { + name: "MetaProperty" + parents: "Expression" + type: "MetaProperty" + fields { + name: "meta" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + fields { + name: "property" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface ModuleDeclaration <: Node { } +nodes { + name: "ModuleDeclaration" + parents: "Node" + kinds: FIELD_KIND_STMT +} + +# // interface ModuleSpecifier <: Node { +# // local: Identifier; +# // } +# ------------------------------------------------------------------------------ +# Note: "ExportSpecifier", which extends "ModuleSpecifier", has +# "local?: Identifier | StringLiteral"; +# ------------------------------------------------------------------------------ +# interface ModuleSpecifier <: Node {} +nodes { + name: "ModuleSpecifier" + parents: "Node" + kinds: FIELD_KIND_ATTR +} + +# // interface ImportDeclaration <: ModuleDeclaration { +# // type: "ImportDeclaration"; +# // importKind: null | "type" | "typeof" | "value"; +# // specifiers: [ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier ]; +# // source: StringLiteral; +# // assertions?: [ ImportAttribute ]; +# // } +# ------------------------------------------------------------------------------ +# Note: "importKind" is only populated with the "flow" plugin enabled +# ------------------------------------------------------------------------------ +# interface ImportDeclaration <: ModuleDeclaration { +# type: "ImportDeclaration"; +# specifiers: [ ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier ]; +# source: StringLiteral; +# assertions?: [ ImportAttribute ]; +# } +nodes { + name: "ImportDeclaration" + type: "ImportDeclaration" + parents: "ModuleDeclaration" + fields { + name: "specifiers" + type { + list { + element_type { + variant { + types { class: "ImportSpecifier" } + types { class: "ImportDefaultSpecifier" } + types { class: "ImportNamespaceSpecifier" } + } + } + } + } + kind: FIELD_KIND_ATTR + } + fields { + name: "source" + type { class: "StringLiteral" } + kind: FIELD_KIND_ATTR + } + fields { + name: "assertions" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { class: "ImportAttribute" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# // interface ImportSpecifier <: ModuleSpecifier { +# // type: "ImportSpecifier"; +# // imported: Identifier | StringLiteral; +# // } +# interface ImportSpecifier <: ModuleSpecifier { +# type: "ImportSpecifier"; +# imported: Identifier | StringLiteral; +# local: Identifier; +# } +nodes { + name: "ImportSpecifier" + parents: "ModuleSpecifier" + type: "ImportSpecifier" + fields { + name: "imported" + type { + variant { + types { class: "Identifier" } + types { class: "StringLiteral" } + } + } + kind: FIELD_KIND_ATTR + } + fields { + name: "local" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: false +} + +# // interface ImportDefaultSpecifier <: ModuleSpecifier { +# // type: "ImportDefaultSpecifier"; +# // } +# interface ImportDefaultSpecifier <: ModuleSpecifier { +# type: "ImportDefaultSpecifier"; +# local: Identifier; +# } +nodes { + name: "ImportDefaultSpecifier" + parents: "ModuleSpecifier" + type: "ImportDefaultSpecifier" + fields { + name: "local" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: false +} + +# // interface ImportNamespaceSpecifier <: ModuleSpecifier { +# // type: "ImportNamespaceSpecifier"; +# // } +# interface ImportNamespaceSpecifier <: ModuleSpecifier { +# type: "ImportNamespaceSpecifier"; +# local: Identifier; +# } +nodes { + name: "ImportNamespaceSpecifier" + parents: "ModuleSpecifier" + type: "ImportNamespaceSpecifier" + fields { + name: "local" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: false +} + +# interface ImportAttribute <: Node { +# type: "ImportAttribute"; +# key: Identifier; +# value: StringLiteral; +# } +nodes { + name: "ImportAttribute" + parents: "Node" + type: "ImportAttribute" + fields { + name: "key" + type { class: "Identifier" } + kind: FIELD_KIND_ATTR + } + fields { + name: "value" + type { class: "StringLiteral" } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_ATTR + should_generate_ir_op: false +} + +# interface ExportNamedDeclaration <: ModuleDeclaration { +# type: "ExportNamedDeclaration"; +# declaration: Declaration | null; +# specifiers: [ ExportSpecifier ]; +# source: StringLiteral | null; +# assertions?: [ ImportAttribute ]; +# } +nodes { + name: "ExportNamedDeclaration" + type: "ExportNamedDeclaration" + parents: "ModuleDeclaration" + fields { + name: "declaration" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "Declaration" } + kind: FIELD_KIND_STMT + enclose_in_region: true + } + fields { + name: "specifiers" + type { + list { + element_type { class: "ExportSpecifier" } + } + } + kind: FIELD_KIND_ATTR + } + fields { + name: "source" + optionalness: OPTIONALNESS_MAYBE_NULL + type { class: "StringLiteral" } + kind: FIELD_KIND_ATTR + } + fields { + name: "assertions" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { class: "ImportAttribute" } + } + } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: true +} + +# interface ExportSpecifier <: ModuleSpecifier { +# type: "ExportSpecifier"; +# exported: Identifier | StringLiteral; +# local?: Identifier | StringLiteral; +# } +nodes { + name: "ExportSpecifier" + type: "ExportSpecifier" + parents: "ModuleSpecifier" + fields { + name: "exported" + type { + variant { + types { + class: "Identifier" + } + types { + class: "StringLiteral" + } + } + } + kind: FIELD_KIND_ATTR + } + fields { + name: "local" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + variant { + types { + class: "Identifier" + } + types { + class: "StringLiteral" + } + } + } + kind: FIELD_KIND_ATTR + } + should_generate_ir_op: false +} + +# // interface OptFunctionDeclaration <: FunctionDeclaration { +# // id: Identifier | null; +# // } +# NOTE: "FunctionDeclaration" is already a leaf type. +# Here the spec tries to override the type of "id" from "Identifier" to +# "Identifier | null". +# However, we can't support field type override. Therefore, we let "id" to be +# always nullable (even in FunctionDeclaration) and thus delete +# OptFunctionDeclaration. + +# // interface OptClassDeclaration <: ClassDeclaration { +# // id: Identifier | null; +# // } +# NOTE: "ClassDeclaration" is already a leaf type. +# Here the spec tries to override the type of "id" from "Identifier" to +# "Identifier | null". +# However, we can't support field type override. Therefore, we let "id" to be +# always nullable (even in ClassDeclaration) and thus delete +# OptClassDeclaration. + +# // interface ExportDefaultDeclaration <: ModuleDeclaration { +# // type: "ExportDefaultDeclaration"; +# // declaration: OptFunctionDeclaration | OptClassDeclaration | Expression; +# // } +# interface ExportDefaultDeclaration <: ModuleDeclaration { +# type: "ExportDefaultDeclaration"; +# declaration: FunctionDeclaration | ClassDeclaration | Expression; +# } +nodes { + name: "ExportDefaultDeclaration" + parents: "ModuleDeclaration" + type: "ExportDefaultDeclaration" + fields { + name: "declaration" + type { + variant { + types { class: "FunctionDeclaration" } + types { class: "ClassDeclaration" } + types { class: "Expression" } + } + } + } + should_generate_ir_op: false +} + +# interface ExportAllDeclaration <: ModuleDeclaration { +# type: "ExportAllDeclaration"; +# source: StringLiteral; +# assertions?: [ ImportAttribute ]; +# } +nodes { + name: "ExportAllDeclaration" + type: "ExportAllDeclaration" + parents: "ModuleDeclaration" + fields { + name: "source" + type { class: "StringLiteral" } + kind: FIELD_KIND_ATTR + } + fields { + name: "assertions" + optionalness: OPTIONALNESS_MAYBE_UNDEFINED + type { + list { + element_type { class: "ImportAttribute" } + } + } + kind: FIELD_KIND_ATTR + } + kinds: FIELD_KIND_STMT + should_generate_ir_op: true +} diff --git a/maldoca/js/ast/ast_gen_test.cc b/maldoca/js/ast/ast_gen_test.cc new file mode 100644 index 00000000..628dcb56 --- /dev/null +++ b/maldoca/js/ast/ast_gen_test.cc @@ -0,0 +1,50 @@ +// Copyright 2024 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// https://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "gtest/gtest.h" +#include "maldoca/astgen/test/ast_gen_test_util.h" + +namespace maldoca { +namespace astgen { +namespace { + +INSTANTIATE_TEST_SUITE_P( + JavaScript, AstGenTest, + ::testing::Values(AstGenTestParam{ + .ast_def_path = + "maldoca/js/ast/ast_def.textproto", + .cc_namespace = "maldoca", + .ast_path = "maldoca/js/ast", + .ir_path = "maldoca/js/ir", + .expected_ast_header_path = + "maldoca/js/ast/ast.generated.h", + .expected_ast_source_path = + "maldoca/js/ast/ast.generated.cc", + .expected_ast_to_json_path = + "maldoca/js/ast/ast_to_json.generated.cc", + .expected_ast_from_json_path = + "maldoca/js/ast/ast_from_json.generated.cc", + .expected_ir_tablegen_path = + "maldoca/js/ir/jsir_ops.generated.td", + .expected_ast_to_ir_source_path = + "maldoca/js/ir/conversion/" + "ast_to_jsir.generated.cc", + .expected_ir_to_ast_source_path = + "maldoca/js/ir/conversion/" + "jsir_to_ast.generated.cc", + })); + +} // namespace +} // namespace astgen +} // namespace maldoca diff --git a/maldoca/js/driver/conversion.cc b/maldoca/js/driver/conversion.cc index 26ebcd48..07437206 100644 --- a/maldoca/js/driver/conversion.cc +++ b/maldoca/js/driver/conversion.cc @@ -69,12 +69,11 @@ absl::StatusOr ToJsAstRepr::FromJsAstStringRepr( // AST -> HIR // ----------------------------------------------------------------------------- -absl::StatusOr ToJsHirRepr::FromJsAstRepr( - const JsAstRepr &ast_repr, - mlir::MLIRContext &mlir_context) { +absl::StatusOr ToJsirRepr::FromJsAstRepr( + const JsAstRepr& ast_repr, mlir::MLIRContext& mlir_context) { ABSL_ASSIGN_OR_RETURN(mlir::OwningOpRef op, - AstToJshirFile(*ast_repr.ast, mlir_context)); - return JsHirRepr{std::move(op), ast_repr.scopes, ast_repr.source_map}; + AstToJsirFile(*ast_repr.ast, mlir_context)); + return JsirRepr{std::move(op), ast_repr.scopes, ast_repr.source_map}; } // ----------------------------------------------------------------------------- @@ -96,29 +95,28 @@ absl::StatusOr ToJsAstRepr::FromJsSourceRepr( // Source -> AST string -> AST -> HIR // ----------------------------------------------------------------------------- -absl::StatusOr ToJsHirRepr::FromJsSourceRepr( - const JsSourceRepr &source_repr, BabelParseRequest parse_request, +absl::StatusOr ToJsirRepr::FromJsSourceRepr( + const JsSourceRepr& source_repr, BabelParseRequest parse_request, absl::Duration timeout, std::optional recursion_depth_limit, - Babel &babel, mlir::MLIRContext &mlir_context) { + Babel& babel, mlir::MLIRContext& mlir_context) { ABSL_ASSIGN_OR_RETURN( JsAstRepr ast, ToJsAstRepr::FromJsSourceRepr(source_repr, parse_request, timeout, recursion_depth_limit, babel)); - return ToJsHirRepr::FromJsAstRepr(ast, mlir_context); + return ToJsirRepr::FromJsAstRepr(ast, mlir_context); } // ----------------------------------------------------------------------------- // AST string -> AST -> HIR // ----------------------------------------------------------------------------- -absl::StatusOr ToJsHirRepr::FromJsAstStringRepr( - const JsAstStringRepr &ast_string_repr, - std::optional recursion_depth_limit, - mlir::MLIRContext &mlir_context) { +absl::StatusOr ToJsirRepr::FromJsAstStringRepr( + const JsAstStringRepr& ast_string_repr, + std::optional recursion_depth_limit, mlir::MLIRContext& mlir_context) { ABSL_ASSIGN_OR_RETURN( JsAstRepr ast, ToJsAstRepr::FromJsAstStringRepr(ast_string_repr, recursion_depth_limit)); - return ToJsHirRepr::FromJsAstRepr(ast, mlir_context); + return ToJsirRepr::FromJsAstRepr(ast, mlir_context); } // ============================================================================= @@ -129,11 +127,10 @@ absl::StatusOr ToJsHirRepr::FromJsAstStringRepr( // HIR -> AST // ----------------------------------------------------------------------------- -absl::StatusOr ToJsAstRepr::FromJsHirRepr( - const JsHirRepr &hir_repr) { +absl::StatusOr ToJsAstRepr::FromJsirRepr(const JsirRepr& ir_repr) { ABSL_ASSIGN_OR_RETURN(std::unique_ptr ast, - JshirFileToAst(hir_repr.op.get())); - return JsAstRepr{std::move(ast), hir_repr.scopes, hir_repr.source_map}; + JsirFileToAst(ir_repr.op.get())); + return JsAstRepr{std::move(ast), ir_repr.scopes, ir_repr.source_map}; } // ----------------------------------------------------------------------------- @@ -166,9 +163,9 @@ absl::StatusOr ToJsSourceRepr::FromJsAstStringRepr( // HIR -> AST -> AST string // ----------------------------------------------------------------------------- -absl::StatusOr ToJsAstStringRepr::FromJsHirRepr( - const JsHirRepr &hir_repr) { - ABSL_ASSIGN_OR_RETURN(JsAstRepr ast, ToJsAstRepr::FromJsHirRepr(hir_repr)); +absl::StatusOr ToJsAstStringRepr::FromJsirRepr( + const JsirRepr& ir_repr) { + ABSL_ASSIGN_OR_RETURN(JsAstRepr ast, ToJsAstRepr::FromJsirRepr(ir_repr)); return ToJsAstStringRepr::FromJsAstRepr(ast); } @@ -176,11 +173,11 @@ absl::StatusOr ToJsAstStringRepr::FromJsHirRepr( // HIR -> AST -> AST string -> Source // ----------------------------------------------------------------------------- -absl::StatusOr ToJsSourceRepr::FromJsHirRepr( - const JsHirRepr &hir_repr, BabelGenerateOptions generate_options, - absl::Duration timeout, Babel &babel) { +absl::StatusOr ToJsSourceRepr::FromJsirRepr( + const JsirRepr& ir_repr, BabelGenerateOptions generate_options, + absl::Duration timeout, Babel& babel) { ABSL_ASSIGN_OR_RETURN(JsAstStringRepr ast_string, - ToJsAstStringRepr::FromJsHirRepr(hir_repr)); + ToJsAstStringRepr::FromJsirRepr(ir_repr)); return ToJsSourceRepr::FromJsAstStringRepr(ast_string, generate_options, timeout, babel); } diff --git a/maldoca/js/driver/conversion.h b/maldoca/js/driver/conversion.h index b1301212..6882d2e7 100644 --- a/maldoca/js/driver/conversion.h +++ b/maldoca/js/driver/conversion.h @@ -48,9 +48,9 @@ struct ToJsSourceRepr { const JsAstRepr &ast_repr, BabelGenerateOptions generate_options, absl::Duration timeout, Babel &babel); - static absl::StatusOr FromJsHirRepr( - const JsHirRepr &hir_repr, BabelGenerateOptions generate_options, - absl::Duration timeout, Babel &babel); + static absl::StatusOr FromJsirRepr( + const JsirRepr& ir_repr, BabelGenerateOptions generate_options, + absl::Duration timeout, Babel& babel); }; struct ToJsAstStringRepr { @@ -61,8 +61,7 @@ struct ToJsAstStringRepr { static absl::StatusOr FromJsAstRepr( const JsAstRepr &ast_repr); - static absl::StatusOr FromJsHirRepr( - const JsHirRepr &hir_repr); + static absl::StatusOr FromJsirRepr(const JsirRepr& ir_repr); }; struct ToJsAstRepr { @@ -75,23 +74,22 @@ struct ToJsAstRepr { const JsAstStringRepr &ast_string_repr, std::optional recursion_depth_limit); - static absl::StatusOr FromJsHirRepr(const JsHirRepr &hir_repr); + static absl::StatusOr FromJsirRepr(const JsirRepr& ir_repr); }; -struct ToJsHirRepr { - static absl::StatusOr FromJsSourceRepr( - const JsSourceRepr &source_repr, BabelParseRequest parse_request, +struct ToJsirRepr { + static absl::StatusOr FromJsSourceRepr( + const JsSourceRepr& source_repr, BabelParseRequest parse_request, absl::Duration timeout, std::optional recursion_depth_limit, - Babel &babel, mlir::MLIRContext &mlir_context); + Babel& babel, mlir::MLIRContext& mlir_context); - static absl::StatusOr FromJsAstStringRepr( - const JsAstStringRepr &ast_string_repr, + static absl::StatusOr FromJsAstStringRepr( + const JsAstStringRepr& ast_string_repr, std::optional recursion_depth_limit, - mlir::MLIRContext &mlir_context); + mlir::MLIRContext& mlir_context); - static absl::StatusOr FromJsAstRepr( - const JsAstRepr &ast_repr, - mlir::MLIRContext &mlir_context); + static absl::StatusOr FromJsAstRepr( + const JsAstRepr& ast_repr, mlir::MLIRContext& mlir_context); }; } // namespace maldoca diff --git a/maldoca/js/driver/conversion_test.cc b/maldoca/js/driver/conversion_test.cc index ff303a75..14426725 100644 --- a/maldoca/js/driver/conversion_test.cc +++ b/maldoca/js/driver/conversion_test.cc @@ -64,7 +64,7 @@ struct TestCase { // Note: `hir_repr` is not constructed by parsing the golden file. Instead, it // is constructed by converting the `ast` above. This is because the golden // file does not contain loc information. - JsHirRepr hir_repr; + JsirRepr hir_repr; std::string hir_dump; BabelAstString lifted_babel_ast_string; @@ -120,8 +120,8 @@ absl::StatusOr GetTestCase() { auto mlir_context = std::make_unique(); LoadNecessaryDialects(*mlir_context); - ABSL_ASSIGN_OR_RETURN(JsHirRepr hir_repr, - ToJsHirRepr::FromJsAstRepr(ast_repr, *mlir_context)); + ABSL_ASSIGN_OR_RETURN(JsirRepr hir_repr, + ToJsirRepr::FromJsAstRepr(ast_repr, *mlir_context)); ABSL_ASSIGN_OR_RETURN(auto hir_str, load_content("test_hir.mlir.test")); BabelAstString lifted_babel_ast_string; @@ -184,14 +184,14 @@ TEST(ConversionTest, AstStringToAst) { CheckAst(repr, test_case); } -TEST(ConversionTest, AstToHir) { +TEST(ConversionTest, AstToJsir) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); mlir::MLIRContext mlir_context; LoadNecessaryDialects(mlir_context); MALDOCA_ASSERT_OK_AND_ASSIGN( - JsHirRepr repr, ToJsHirRepr::FromJsAstRepr(test_case.ast, mlir_context)); + JsirRepr repr, ToJsirRepr::FromJsAstRepr(test_case.ast, mlir_context)); EXPECT_EQ(mlir::debugString(*repr.op), test_case.hir_dump); EXPECT_THAT(repr.scopes, EqualsProto(test_case.scopes)); @@ -215,7 +215,7 @@ TEST(ConversionTest, SourceToAst) { CheckAst(repr, test_case); } -TEST(ConversionTest, SourceToHir) { +TEST(ConversionTest, SourceToJsir) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); QuickJsBabel babel; @@ -228,8 +228,8 @@ TEST(ConversionTest, SourceToHir) { LoadNecessaryDialects(mlir_context); MALDOCA_ASSERT_OK_AND_ASSIGN( - JsHirRepr repr, - ToJsHirRepr::FromJsSourceRepr( + JsirRepr repr, + ToJsirRepr::FromJsSourceRepr( source_repr, parse_request, absl::InfiniteDuration(), /*recursion_depth_limit=*/std::nullopt, babel, mlir_context)); @@ -237,7 +237,7 @@ TEST(ConversionTest, SourceToHir) { EXPECT_THAT(repr.scopes, EqualsProto(test_case.scopes)); } -TEST(ConversionTest, AstStringToHir) { +TEST(ConversionTest, AstStringToJsir) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); JsAstStringRepr ast_string_repr{test_case.parsed_babel_ast_string, @@ -247,10 +247,9 @@ TEST(ConversionTest, AstStringToHir) { LoadNecessaryDialects(mlir_context); MALDOCA_ASSERT_OK_AND_ASSIGN( - JsHirRepr repr, - ToJsHirRepr::FromJsAstStringRepr(ast_string_repr, - /*recursion_depth_limit=*/std::nullopt, - mlir_context)); + JsirRepr repr, ToJsirRepr::FromJsAstStringRepr( + ast_string_repr, + /*recursion_depth_limit=*/std::nullopt, mlir_context)); EXPECT_EQ(mlir::debugString(*repr.op), test_case.hir_dump); EXPECT_THAT(repr.scopes, EqualsProto(test_case.scopes)); @@ -260,11 +259,11 @@ TEST(ConversionTest, AstStringToHir) { // Lifting conversions // ============================================================================= -TEST(ConversionTest, HirToAst) { +TEST(ConversionTest, JsirToAst) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); MALDOCA_ASSERT_OK_AND_ASSIGN(JsAstRepr repr, - ToJsAstRepr::FromJsHirRepr(test_case.hir_repr)); + ToJsAstRepr::FromJsirRepr(test_case.hir_repr)); CheckAst(repr, test_case); } @@ -298,25 +297,25 @@ TEST(ConversionTest, AstStringToSource) { EXPECT_EQ(repr.source, test_case.source); } -TEST(ConversionTest, HirToAstString) { +TEST(ConversionTest, JsirToAstString) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); MALDOCA_ASSERT_OK_AND_ASSIGN( JsAstStringRepr repr, - ToJsAstStringRepr::FromJsHirRepr(test_case.hir_repr)); + ToJsAstStringRepr::FromJsirRepr(test_case.hir_repr)); EXPECT_THAT(repr.ast_string, EqualsProto(test_case.lifted_babel_ast_string)); } -TEST(ConversionTest, HirToSource) { +TEST(ConversionTest, JsirToSource) { MALDOCA_ASSERT_OK_AND_ASSIGN(TestCase test_case, GetTestCase()); QuickJsBabel babel; MALDOCA_ASSERT_OK_AND_ASSIGN( JsSourceRepr repr, - ToJsSourceRepr::FromJsHirRepr(test_case.hir_repr, BabelGenerateOptions(), - absl::InfiniteDuration(), babel)); + ToJsSourceRepr::FromJsirRepr(test_case.hir_repr, BabelGenerateOptions(), + absl::InfiniteDuration(), babel)); EXPECT_EQ(repr.source, test_case.source); } diff --git a/maldoca/js/driver/driver.cc b/maldoca/js/driver/driver.cc index 42e92cf7..bb7b0709 100644 --- a/maldoca/js/driver/driver.cc +++ b/maldoca/js/driver/driver.cc @@ -51,8 +51,8 @@ std::ostream &operator<<(std::ostream &os, JsReprKind kind) { return os << "AstString"; case JsReprKind::kAst: return os << "Ast"; - case JsReprKind::kJshir: - return os << "Jshir"; + case JsReprKind::kJsir: + return os << "Jsir"; } } @@ -72,7 +72,7 @@ absl::StatusOr> JsRepr::FromProto( case JsReprPb::kBabelAstString: return std::make_unique(proto.babel_ast_string(), std::move(source_map)); - case JsReprPb::kJsHir: + case JsReprPb::kJsIr: return absl::UnimplementedError("JSIR parsing not supported"); } } @@ -95,9 +95,9 @@ absl::StatusOr JsAstStringRepr::ToProto() const { return proto; } -absl::StatusOr JsHirRepr::ToProto() const { +absl::StatusOr JsirRepr::ToProto() const { JsReprPb proto; - proto.set_js_hir(mlir::debugString(*op)); + proto.set_js_ir(mlir::debugString(*op)); if (source_map.has_value()) { proto.set_source_map(*source_map); } diff --git a/maldoca/js/driver/driver.h b/maldoca/js/driver/driver.h index c405a1ce..7e2ec25a 100644 --- a/maldoca/js/driver/driver.h +++ b/maldoca/js/driver/driver.h @@ -59,7 +59,7 @@ enum class JsReprKind { kJsSource, kAstString, kAst, - kJshir, + kJsir, }; std::ostream& operator<<(std::ostream& os, JsReprKind kind); @@ -178,28 +178,17 @@ struct JsirRepr : JsRepr { mlir::OwningOpRef op; BabelScopes scopes; - static bool classof(const JsRepr* repr) { - return repr->kind == JsReprKind::kJshir; - } - std::string Dump() const override { return mlir::debugString(*op); } - protected: - JsirRepr(JsReprKind kind, mlir::OwningOpRef op, - BabelScopes scopes, std::optional source_map) - : JsRepr(kind, std::move(source_map)), + public: + JsirRepr(mlir::OwningOpRef op, BabelScopes scopes, + std::optional source_map) + : JsRepr(JsReprKind::kJsir, std::move(source_map)), op(std::move(op)), scopes(std::move(scopes)) {} -}; - -struct JsHirRepr : JsirRepr { - JsHirRepr(mlir::OwningOpRef op, BabelScopes scopes, - std::optional source_map) - : JsirRepr(JsReprKind::kJshir, std::move(op), std::move(scopes), - std::move(source_map)) {} static bool classof(const JsRepr* repr) { - return repr->kind == JsReprKind::kJshir; + return repr->kind == JsReprKind::kJsir; } absl::StatusOr ToProto() const override; diff --git a/maldoca/js/driver/driver.proto b/maldoca/js/driver/driver.proto index 6e24ddda..e6bd2fc8 100644 --- a/maldoca/js/driver/driver.proto +++ b/maldoca/js/driver/driver.proto @@ -31,7 +31,7 @@ message JsReprPb { oneof kind { string js_source = 1; BabelAstString babel_ast_string = 2; - string js_hir = 3; + string js_ir = 3; } optional string source_map = 7; @@ -52,8 +52,8 @@ message JsConversionConfig { JsAstToAstStringConfig js_ast_to_ast_string = 4; // ast <=> hir - JsAstToHirConfig js_ast_to_hir = 5; - JsHirToAstConfig js_hir_to_ast = 6; + JsAstToJsirConfig js_ast_to_jsir = 5; + JsirToAstConfig jsir_to_ast = 6; } } @@ -73,9 +73,9 @@ message JsAstStringToAstConfig { message JsAstToAstStringConfig {} -message JsAstToHirConfig {} +message JsAstToJsirConfig {} -message JsHirToAstConfig {} +message JsirToAstConfig {} // ============================================================================= // Analysis diff --git a/maldoca/js/driver/internal/conversions.cc b/maldoca/js/driver/internal/conversions.cc index e40b0ddf..c6ff1103 100644 --- a/maldoca/js/driver/internal/conversions.cc +++ b/maldoca/js/driver/internal/conversions.cc @@ -72,13 +72,13 @@ absl::StatusOr> JsConversion::Create( return std::make_unique(); } - case JsConversionConfig::KindCase::kJsAstToHir: { + case JsConversionConfig::KindCase::kJsAstToJsir: { MALDOCA_RET_CHECK(mlir_context != nullptr); - return std::make_unique(mlir_context); + return std::make_unique(mlir_context); } - case JsConversionConfig::KindCase::kJsHirToAst: { - return std::make_unique(); + case JsConversionConfig::KindCase::kJsirToAst: { + return std::make_unique(); } } } @@ -168,20 +168,20 @@ absl::StatusOr> JsAstToAstString::Convert( // JsAstToHir // ============================================================================= -absl::StatusOr> JsAstToHir::Convert( - const JsAstRepr &from) { - ABSL_ASSIGN_OR_RETURN(auto op, AstToJshirFile(*from.ast, mlir_context_)); - return std::make_unique(std::move(op), from.scopes, - from.source_map); +absl::StatusOr> JsAstToJsir::Convert( + const JsAstRepr& from) { + ABSL_ASSIGN_OR_RETURN(auto op, AstToJsirFile(*from.ast, mlir_context_)); + return std::make_unique(std::move(op), from.scopes, + from.source_map); } // ============================================================================= // JsHirToAst // ============================================================================= -absl::StatusOr> JsHirToAst::Convert( - const JsHirRepr &from) { - ABSL_ASSIGN_OR_RETURN(auto ast, JshirFileToAst(*from.op)); +absl::StatusOr> JsirToAst::Convert( + const JsirRepr& from) { + ABSL_ASSIGN_OR_RETURN(auto ast, JsirFileToAst(*from.op)); return std::make_unique(std::move(ast), from.scopes, from.source_map); } diff --git a/maldoca/js/driver/internal/conversions.h b/maldoca/js/driver/internal/conversions.h index bfb04203..e0bf77fb 100644 --- a/maldoca/js/driver/internal/conversions.h +++ b/maldoca/js/driver/internal/conversions.h @@ -176,16 +176,16 @@ class JsAstToAstString final // +------+-----------------------------+-------------------------------+ // | To | mlir::OwningOpRef | JavaScript high-level IR | // +------+-----------------------------+-------------------------------+ -class JsAstToHir final : public JsConversionTmpl { +class JsAstToJsir final : public JsConversionTmpl { public: - explicit JsAstToHir(mlir::MLIRContext *absl_nonnull mlir_context) + explicit JsAstToJsir(mlir::MLIRContext* absl_nonnull mlir_context) : mlir_context_(*mlir_context) {} - std::string name() const override { return "JsAstToHir"; } + std::string name() const override { return "JsAstToJsir"; } private: - absl::StatusOr> Convert( - const JsAstRepr &from) override; + absl::StatusOr> Convert( + const JsAstRepr& from) override; mlir::MLIRContext &mlir_context_; }; @@ -197,15 +197,15 @@ class JsAstToHir final : public JsConversionTmpl { // +------+-------------------------------+-------------------------------+ // | To | std::unique_ptr | JavaScript AST | // +------+-------------------------------+-------------------------------+ -class JsHirToAst final : public JsConversionTmpl { +class JsirToAst final : public JsConversionTmpl { public: - explicit JsHirToAst() = default; + explicit JsirToAst() = default; - std::string name() const override { return "JsHirToAst"; } + std::string name() const override { return "JsirToAst"; } private: absl::StatusOr> Convert( - const JsHirRepr &from) override; + const JsirRepr& from) override; }; } // namespace maldoca diff --git a/maldoca/js/ir/BUILD b/maldoca/js/ir/BUILD index 7bb11954..55a64391 100644 --- a/maldoca/js/ir/BUILD +++ b/maldoca/js/ir/BUILD @@ -86,20 +86,6 @@ gentbl_cc_library( ], "jsir_dialect.cc.inc", ), - ( - [ - "-gen-dialect-decls", - "-dialect=jshir", - ], - "jshir_dialect.h.inc", - ), - ( - [ - "-gen-dialect-defs", - "-dialect=jshir", - ], - "jshir_dialect.cc.inc", - ), ], tblgen = "@llvm-project//mlir:mlir-tblgen", td_file = "jsir_attrs.td", @@ -207,31 +193,15 @@ gentbl_cc_library( ( [ "-gen-op-decls", - "-op-include-regex=jsir", ], "jsir_ops.h.inc", ), ( [ "-gen-op-defs", - "-op-include-regex=jsir", ], "jsir_ops.cc.inc", ), - ( - [ - "-gen-op-decls", - "-op-include-regex=jshir", - ], - "jshir_ops.h.inc", - ), - ( - [ - "-gen-op-defs", - "-op-include-regex=jshir", - ], - "jshir_ops.cc.inc", - ), ], tblgen = "@llvm-project//mlir:mlir-tblgen", td_file = "jsir_ops.td", @@ -244,7 +214,6 @@ cc_library( name = "ir", srcs = [ "ir.cc", - "jshir_ops.cc", "jsir_ops.cc", ], hdrs = ["ir.h"], diff --git a/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h b/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h index 78eeda80..ef5ed9e9 100644 --- a/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h +++ b/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h @@ -114,18 +114,17 @@ void JsirConditionalForwardDataFlowAnalysis::VisitOp( // Don't call the user-defined `VisitOp` if this is an op with a fixed // standard visitor. // TODO(b/425421947): Create MLIR trait rather than having a list of ops here. - if (llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op)) { + if (llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || llvm::isa(op) || + llvm::isa(op) || llvm::isa(op) || + llvm::isa(op)) { return; } VisitOp(op, operands, before, result_state_refs, after_state_ref); diff --git a/maldoca/js/ir/analyses/conditional_forward_per_var_dataflow_analysis.h b/maldoca/js/ir/analyses/conditional_forward_per_var_dataflow_analysis.h index 957b23cb..d4f1d9ae 100644 --- a/maldoca/js/ir/analyses/conditional_forward_per_var_dataflow_analysis.h +++ b/maldoca/js/ir/analyses/conditional_forward_per_var_dataflow_analysis.h @@ -67,7 +67,7 @@ class JsirConditionalForwardPerVarDataFlowAnalysis // // ``` // - // jshir.if_statement (%cond) { + // jsir.if_statement (%cond) { // // }, { // diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/and/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/and/README.generated.md index 58220b3f..397963c7 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/and/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/and/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/and/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/and/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/and/output.generated.txt index 8dda7939..7ee8093b 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/and/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/and/output.generated.txt @@ -1,254 +1,254 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "&&"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "&&"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "&&"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "&&"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 93, 96, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 109, 112, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 125, 128, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () -// JSHIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 141, 144, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %17 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"&&"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %20 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %17 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"&&"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %20 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"c"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"x"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"&&"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %20 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"d"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"x"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"&&"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %20 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 93, 96, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"a"} -// JSHIR-NEXT: // %2 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 109, 112, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"b"} -// JSHIR-NEXT: // %6 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"console"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 125, 128, 0, "log">} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier {"c"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.call_expression (%9, %10) -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%11) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier {"console"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 141, 144, 0, "log">} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.identifier {"d"} -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.call_expression (%13, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "&&"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "&&"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "&&"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "&&"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 93, 96, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 109, 112, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 125, 128, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () +// JSIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 141, 144, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.boolean_literal {false} +// JSIR-NEXT: // %17 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"&&"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {true} +// JSIR-NEXT: // %20 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.boolean_literal {true} +// JSIR-NEXT: // %17 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"&&"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {false} +// JSIR-NEXT: // %20 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"c"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"x"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"&&"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {true} +// JSIR-NEXT: // %20 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"d"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"x"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"&&"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {false} +// JSIR-NEXT: // %20 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 93, 96, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"a"} +// JSIR-NEXT: // %2 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 109, 112, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"b"} +// JSIR-NEXT: // %6 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"console"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 125, 128, 0, "log">} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier {"c"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.call_expression (%9, %10) +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%11) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier {"console"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 141, 144, 0, "log">} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.identifier {"d"} +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.call_expression (%13, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/and/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/and/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/and/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/and/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/break/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/break/README.generated.md index 5e7bd680..c0e0340b 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/break/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/break/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/break/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/break/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/break/output.generated.txt index 611b049c..76d06067 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/break/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/break/output.generated.txt @@ -1,116 +1,116 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 54, 57, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %4 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.break_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 54, 57, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 54, 57, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %5 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.boolean_literal {true} +// JSIR-NEXT: // %4 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.break_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %5 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 54, 57, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/break/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/break/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/break/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/break/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/README.generated.md index c0701db2..b68a61de 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/conditional/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/output.generated.txt index f96d1a0d..7c866e7c 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/output.generated.txt @@ -1,232 +1,232 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jshir.conditional_expression"(%13) ({ -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jshir.conditional_expression"(%13) ({ -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jshir.conditional_expression"(%13) ({ -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 6.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 72, 75, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 88, 91, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 104, 107, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %13 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jshir.conditional_expression (%13) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %16 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %14 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.variable_declarator (%12, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %13 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jshir.conditional_expression (%13) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} -// JSHIR-NEXT: // %16 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %14 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.variable_declarator (%12, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier_ref {"c"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.identifier {"x"} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jshir.conditional_expression (%13) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 6.000000e+00 : f64} -// JSHIR-NEXT: // %16 = 6.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.numeric_literal {#jsir, 5.000000e+00 : f64} -// JSHIR-NEXT: // %16 = 5.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%16) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.variable_declarator (%12, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 72, 75, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"a"} -// JSHIR-NEXT: // %2 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 88, 91, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"b"} -// JSHIR-NEXT: // %6 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"console"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 104, 107, 0, "log">} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier {"c"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.call_expression (%9, %10) -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%11) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.conditional_expression"(%13) ({ +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.conditional_expression"(%13) ({ +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %12 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.conditional_expression"(%13) ({ +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 6.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %16 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%16) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %15 = "jsir.variable_declarator"(%12, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 72, 75, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 88, 91, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 104, 107, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.boolean_literal {true} +// JSIR-NEXT: // %13 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.conditional_expression (%13) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %16 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %14 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.variable_declarator (%12, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.boolean_literal {false} +// JSIR-NEXT: // %13 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.conditional_expression (%13) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} +// JSIR-NEXT: // %16 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %14 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.variable_declarator (%12, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier_ref {"c"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.identifier {"x"} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.conditional_expression (%13) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 6.000000e+00 : f64} +// JSIR-NEXT: // %16 = 6.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.numeric_literal {#jsir, 5.000000e+00 : f64} +// JSIR-NEXT: // %16 = 5.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%16) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.variable_declarator (%12, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 72, 75, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"a"} +// JSIR-NEXT: // %2 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 88, 91, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"b"} +// JSIR-NEXT: // %6 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"console"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 104, 107, 0, "log">} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier {"c"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.call_expression (%9, %10) +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%11) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/continue/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/continue/README.generated.md index 1e7c3068..4b9e9b29 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/continue/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/continue/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/continue/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/continue/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/continue/output.generated.txt index 9690c73e..2065ee6a 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/continue/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/continue/output.generated.txt @@ -1,168 +1,168 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+01 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "<"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.update_expression"(%4) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: "jshir.continue_statement"() : () -> () -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 73, 76, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.for_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"i"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"i"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+01 : f64} -// JSHIR-NEXT: // %5 = 1.000000e+01 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.binary_expression (%4, %5) {"<"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"i"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.update_expression (%4) {"++", false} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.continue_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 73, 76, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+01 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "<"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.update_expression"(%4) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: "jsir.continue_statement"() : () -> () +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 73, 76, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %5 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.for_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"i"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %5 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"i"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+01 : f64} +// JSIR-NEXT: // %5 = 1.000000e+01 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.binary_expression (%4, %5) {"<"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"i"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.update_expression (%4) {"++", false} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.continue_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} +// JSIR-NEXT: // %5 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 73, 76, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/continue/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/continue/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/continue/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/continue/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/README.generated.md index b5f63baa..6fc9b383 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/do_while/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/output.generated.txt index 76c1161e..058b01fa 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/output.generated.txt @@ -1,163 +1,163 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.do_while_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.assignment_expression"(%8, %11) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%12) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "z"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 61, 64, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 77, 80, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %9 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.variable_declarator (%8, %9) -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%10) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"y"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %9 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.variable_declarator (%8, %9) -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%10) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.do_while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.identifier {"x"} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %10 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.assignment_expression (%8, %11) {"="} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%12) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"z"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%8) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 61, 64, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 77, 80, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"y"} -// JSHIR-NEXT: // %6 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.do_while_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.assignment_expression"(%8, %11) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%12) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "z"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%8) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 61, 64, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 77, 80, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %9 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.variable_declarator (%8, %9) +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%10) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"y"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %9 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.variable_declarator (%8, %9) +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%10) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.do_while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.identifier {"x"} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %10 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.assignment_expression (%8, %11) {"="} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%12) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"z"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%8) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 61, 64, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 77, 80, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"y"} +// JSIR-NEXT: // %6 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/for/README.generated.md index 3311917c..577d7cbf 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/for/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/for/output.generated.txt index 3969dc60..ac1b5dc5 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for/output.generated.txt @@ -1,113 +1,113 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+01 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "<"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.update_expression"(%0) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 39, 42, 1, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.for_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"i"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.variable_declarator (%0, %1) -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"i"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+01 : f64} -// JSHIR-NEXT: // %1 = 1.000000e+01 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"<"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"i"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.update_expression (%0) {"++", false} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%1) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 39, 42, 1, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"i"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+01 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "<"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.update_expression"(%0) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 39, 42, 1, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "i"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.for_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"i"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %1 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.variable_declarator (%0, %1) +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"i"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+01 : f64} +// JSIR-NEXT: // %1 = 1.000000e+01 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"<"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"i"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.update_expression (%0) {"++", false} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%1) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 39, 42, 1, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"i"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/for/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/README.generated.md index 4008045a..67edeef4 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/for_in/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/output.generated.txt index 04dfebfc..e7774f6d 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/output.generated.txt @@ -1,163 +1,163 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.variable_declarator"(%6, %7) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "key"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "object"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_in_statement"(%0, %1) <{left_declaration = #jsir, , 16, 23, 1, , , 20, 23, 1, "key", 0, "var">}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.member_expression"(%6) <{literal_property = #jsir, , "log", 47, 50, 2, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "key"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.call_expression"(%7, %8) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.member_expression"(%10) <{literal_property = #jsir, , "log", 67, 70, 2, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.identifier"() <{name = "object"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.identifier"() <{name = "key"}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.member_expression"(%12, %13) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.call_expression"(%11, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.binary_expression"(%17, %18) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %20 = "jsir.assignment_expression"(%16, %19) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "log", 108, 111, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.call_expression"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier_ref {"y"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %7 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.variable_declarator (%6, %7) -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%8) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"key"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier {"object"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.for_in_statement (%0, %1) {#jsir, , 16, 23, 1, , , 20, 23, 1, "key", 0, "var">} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"console"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 47, 50, 2, "log">} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"key"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.call_expression (%7, %8) -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%9) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier {"console"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 67, 70, 2, "log">} -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier {"object"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.identifier {"key"} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.member_expression (%12, %13) -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.call_expression (%11, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"y"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"y"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %18 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.binary_expression (%17, %18) {"+"} -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.assignment_expression (%16, %19) {"="} -// JSHIR-NEXT: // %20 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"console"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.member_expression (%2) {#jsir, , "log", 108, 111, 0, "log">} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"y"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.call_expression (%3, %4) -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.variable_declarator"(%6, %7) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%8) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "key"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "object"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_in_statement"(%0, %1) <{left_declaration = #jsir, , 16, 23, 1, , , 20, 23, 1, "key", 0, "var">}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.member_expression"(%6) <{literal_property = #jsir, , "log", 47, 50, 2, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "key"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.call_expression"(%7, %8) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.member_expression"(%10) <{literal_property = #jsir, , "log", 67, 70, 2, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.identifier"() <{name = "object"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.identifier"() <{name = "key"}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.member_expression"(%12, %13) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %15 = "jsir.call_expression"(%11, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %19 = "jsir.binary_expression"(%17, %18) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %20 = "jsir.assignment_expression"(%16, %19) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "log", 108, 111, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.call_expression"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier_ref {"y"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %7 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.variable_declarator (%6, %7) +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%8) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"key"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier {"object"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.for_in_statement (%0, %1) {#jsir, , 16, 23, 1, , , 20, 23, 1, "key", 0, "var">} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"console"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 47, 50, 2, "log">} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"key"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.call_expression (%7, %8) +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%9) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier {"console"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 67, 70, 2, "log">} +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier {"object"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.identifier {"key"} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.member_expression (%12, %13) +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.call_expression (%11, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"y"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"y"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %18 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.binary_expression (%17, %18) {"+"} +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.assignment_expression (%16, %19) {"="} +// JSIR-NEXT: // %20 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"console"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.member_expression (%2) {#jsir, , "log", 108, 111, 0, "log">} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"y"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.call_expression (%3, %4) +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/README.generated.md index a6e296b5..cb7b5773 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/for_of/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/output.generated.txt index a73716da..889caeb9 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/output.generated.txt @@ -1,136 +1,136 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.variable_declarator"(%6, %7) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "array"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_of_statement"(%0, %1) <{await = false, left_declaration = #jsir, , 16, 21, 1, , , 20, 21, 1, "x", 0, "var">}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.member_expression"(%6) <{literal_property = #jsir, , "log", 44, 47, 2, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.call_expression"(%7, %8) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () -// JSHIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.binary_expression"(%11, %12) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.assignment_expression"(%10, %13) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%14) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "log", 75, 78, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.call_expression"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier_ref {"y"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %7 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.variable_declarator (%6, %7) -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%8) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier {"array"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.for_of_statement (%0, %1) {false, #jsir, , 16, 21, 1, , , 20, 21, 1, "x", 0, "var">} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"console"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 44, 47, 2, "log">} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"x"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.call_expression (%7, %8) -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%9) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier_ref {"y"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.identifier {"y"} -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %12 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.binary_expression (%11, %12) {"+"} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.assignment_expression (%10, %13) {"="} -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%14) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"console"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.member_expression (%2) {#jsir, , "log", 75, 78, 0, "log">} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"y"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.call_expression (%3, %4) -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.variable_declarator"(%6, %7) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%8) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "array"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_of_statement"(%0, %1) <{await = false, left_declaration = #jsir, , 16, 21, 1, , , 20, 21, 1, "x", 0, "var">}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.member_expression"(%6) <{literal_property = #jsir, , "log", 44, 47, 2, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.call_expression"(%7, %8) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () +// JSIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %12 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.binary_expression"(%11, %12) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %14 = "jsir.assignment_expression"(%10, %13) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%14) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "log", 75, 78, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.call_expression"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier_ref {"y"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %7 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.variable_declarator (%6, %7) +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%8) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier {"array"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.for_of_statement (%0, %1) {false, #jsir, , 16, 21, 1, , , 20, 21, 1, "x", 0, "var">} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"console"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 44, 47, 2, "log">} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"x"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.call_expression (%7, %8) +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%9) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier_ref {"y"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.identifier {"y"} +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %12 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.binary_expression (%11, %12) {"+"} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.assignment_expression (%10, %13) {"="} +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%14) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"console"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.member_expression (%2) {#jsir, , "log", 75, 78, 0, "log">} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"y"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.call_expression (%3, %4) +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/function/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/function/README.generated.md index 6bbfd175..6487c41e 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/function/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/function/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/function/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/function/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/function/output.generated.txt index 1caf95c0..e80f216e 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/function/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/function/output.generated.txt @@ -1,117 +1,117 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "foo", 9, 12, 1, "foo">}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "arg"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %1 = "jsir.identifier_ref"() <{name = "is_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.variable_declarator"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %1 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "arg"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.variable_declarator"(%1, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "is_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 9, 12, 1, "foo">} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"arg"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%0) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier_ref {"is_a_const"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %2 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.variable_declarator (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier_ref {"not_a_const"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"arg"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %3 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.binary_expression (%2, %3) {"+"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.variable_declarator (%1, %4) -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"is_a_const"} -// JSHIR-NEXT: // %0 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.return_statement (%0) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "foo", 9, 12, 1, "foo">}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "arg"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %1 = "jsir.identifier_ref"() <{name = "is_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.variable_declarator"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %1 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "arg"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %5 = "jsir.variable_declarator"(%1, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "is_a_const"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 9, 12, 1, "foo">} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"arg"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%0) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier_ref {"is_a_const"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %2 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.variable_declarator (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier_ref {"not_a_const"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"arg"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %3 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.binary_expression (%2, %3) {"+"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.variable_declarator (%1, %4) +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"is_a_const"} +// JSIR-NEXT: // %0 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.return_statement (%0) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/function/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/function/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/function/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/function/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/if/README.generated.md index 2a27cefe..b0de6e8a 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/if/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/if/output.generated.txt index e6b1a3ce..6e050d06 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if/output.generated.txt @@ -1,69 +1,69 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "=="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%4) ({ -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %0 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} -// JSHIR-NEXT: // %2 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %3 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.binary_expression (%2, %3) {"=="} -// JSHIR-NEXT: // %4 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.if_statement (%4) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier {"a"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier {"b"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "=="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%4) ({ +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %0 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %1 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} +// JSIR-NEXT: // %2 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %3 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.binary_expression (%2, %3) {"=="} +// JSIR-NEXT: // %4 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.if_statement (%4) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier {"a"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier {"b"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/if/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/README.generated.md index 4bbfce82..a7de9a6e 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/output.generated.txt index d73c8b9f..cecbe15a 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/output.generated.txt @@ -1,95 +1,95 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 44, 58, " Should be 1">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.variable_declarator"(%2) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%0) ({ -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[#jsir, , 44, 58, " Should be 1">]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.variable_declarator (%2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %0 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.if_statement (%0) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %3 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier {"a"} -// JSHIR-NEXT: // %1 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%1) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = [#jsir, , 44, 58, " Should be 1">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.variable_declarator"(%2) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%0) ({ +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[#jsir, , 44, 58, " Should be 1">]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.variable_declarator (%2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.boolean_literal {true} +// JSIR-NEXT: // %0 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.if_statement (%0) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %3 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier {"a"} +// JSIR-NEXT: // %1 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%1) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/README.generated.md index 353ccd60..78c689b2 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/output.generated.txt index ea6835bd..fb23f784 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/output.generated.txt @@ -1,95 +1,95 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 41, 62, " Should be unknown.">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.variable_declarator"(%2) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%0) ({ -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[#jsir, , 41, 62, " Should be unknown.">]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.variable_declarator (%2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"x"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.if_statement (%0) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %3 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %3 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier {"a"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%1) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = [#jsir, , 41, 62, " Should be unknown.">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.variable_declarator"(%2) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%0) ({ +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.assignment_expression"(%2, %3) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[#jsir, , 41, 62, " Should be unknown.">]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.variable_declarator (%2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"x"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.if_statement (%0) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %3 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %3 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.assignment_expression (%2, %3) {"="} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier {"a"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%1) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/label/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/label/README.generated.md index e74696a1..85614870 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/label/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/label/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/label/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/label/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/label/output.generated.txt index 80184a4e..22be0b31 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/label/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/label/output.generated.txt @@ -1,173 +1,173 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "my_label", 11, 19, 0, "my_label">}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %10 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%10) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: "jshir.break_statement"() <{label = #jsir, , "my_label", 72, 80, 4, "my_label">}> : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %7 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.assignment_expression"(%7, %8) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 105, 108, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.labeled_statement {#jsir, , "my_label", 11, 19, 0, "my_label">} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %4 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %10 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%10) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.break_statement {#jsir, , "my_label", 72, 80, 4, "my_label">} -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %8 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.assignment_expression (%7, %8) {"="} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%9) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 105, 108, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "my_label", 11, 19, 0, "my_label">}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %10 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%10) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: "jsir.break_statement"() <{label = #jsir, , "my_label", 72, 80, 4, "my_label">}> : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %7 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.assignment_expression"(%7, %8) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 105, 108, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %5 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.labeled_statement {#jsir, , "my_label", 11, 19, 0, "my_label">} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.boolean_literal {true} +// JSIR-NEXT: // %4 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %5 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.boolean_literal {true} +// JSIR-NEXT: // %10 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%10) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.break_statement {#jsir, , "my_label", 72, 80, 4, "my_label">} +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %8 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.assignment_expression (%7, %8) {"="} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%9) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 105, 108, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/label/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/label/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/label/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/label/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/literal/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/literal/README.generated.md index 1e7542e7..5652ad09 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/literal/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/literal/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/literal/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/literal/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/literal/output.generated.txt index cd520ab7..4a032181 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/literal/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/literal/output.generated.txt @@ -1,64 +1,64 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.reg_exp_literal"() <{extra = #jsir, flags = "", pattern = "1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.null_literal"() : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: %5 = "jsir.big_int_literal"() <{extra = #jsir, value = "1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.reg_exp_literal {#jsir, "", "1"} -// JSHIR-NEXT: // %0 = #jsir -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%0) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.null_literal -// JSHIR-NEXT: // %1 = #jsir.null_literal -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%1) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.string_literal {#jsir, "a"} -// JSHIR-NEXT: // %2 = "a" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %3 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %4 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.big_int_literal {#jsir, "1"} -// JSHIR-NEXT: // %5 = #jsir -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.reg_exp_literal"() <{extra = #jsir, flags = "", pattern = "1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.null_literal"() : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: %5 = "jsir.big_int_literal"() <{extra = #jsir, value = "1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.reg_exp_literal {#jsir, "", "1"} +// JSIR-NEXT: // %0 = #jsir +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%0) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.null_literal +// JSIR-NEXT: // %1 = #jsir.null_literal +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%1) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.string_literal {#jsir, "a"} +// JSIR-NEXT: // %2 = "a" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.boolean_literal {true} +// JSIR-NEXT: // %3 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %4 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.big_int_literal {#jsir, "1"} +// JSIR-NEXT: // %5 = #jsir +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/literal/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/literal/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/literal/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/literal/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/README.generated.md index ed47f8fe..bde87c24 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/output.generated.txt index b8d60e6d..17598cb5 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/output.generated.txt @@ -1,254 +1,254 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.null_literal"() : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "??"}> ({ -// JSHIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "??"}> ({ -// JSHIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.200000e+01 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "??"}> ({ -// JSHIR-NEXT: %20 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "??"}> ({ -// JSHIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for d"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 119, 122, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 135, 138, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 151, 154, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () -// JSHIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 167, 170, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.null_literal -// JSHIR-NEXT: // %17 = #jsir.null_literal -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"??"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.string_literal {#jsir, "default for a"} -// JSHIR-NEXT: // %20 = "default for a" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = "default for a" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.string_literal {#jsir, ""} -// JSHIR-NEXT: // %17 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"??"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.string_literal {#jsir, "default for b"} -// JSHIR-NEXT: // %20 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"c"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.numeric_literal {#jsir, 4.200000e+01 : f64} -// JSHIR-NEXT: // %17 = 4.200000e+01 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"??"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %20 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = 4.200000e+01 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"d"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"x"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"??"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.string_literal {#jsir, "default for d"} -// JSHIR-NEXT: // %20 = "default for d" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 119, 122, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"a"} -// JSHIR-NEXT: // %2 = "default for a" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 135, 138, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"b"} -// JSHIR-NEXT: // %6 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"console"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 151, 154, 0, "log">} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier {"c"} -// JSHIR-NEXT: // %10 = 4.200000e+01 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.call_expression (%9, %10) -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%11) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier {"console"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 167, 170, 0, "log">} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.identifier {"d"} -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.call_expression (%13, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.null_literal"() : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "??"}> ({ +// JSIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "??"}> ({ +// JSIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.200000e+01 : f64}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "??"}> ({ +// JSIR-NEXT: %20 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "??"}> ({ +// JSIR-NEXT: %20 = "jsir.string_literal"() <{extra = #jsir, value = "default for d"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 119, 122, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 135, 138, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 151, 154, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () +// JSIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 167, 170, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.null_literal +// JSIR-NEXT: // %17 = #jsir.null_literal +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"??"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.string_literal {#jsir, "default for a"} +// JSIR-NEXT: // %20 = "default for a" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = "default for a" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.string_literal {#jsir, ""} +// JSIR-NEXT: // %17 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"??"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.string_literal {#jsir, "default for b"} +// JSIR-NEXT: // %20 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"c"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.numeric_literal {#jsir, 4.200000e+01 : f64} +// JSIR-NEXT: // %17 = 4.200000e+01 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"??"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %20 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = 4.200000e+01 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"d"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"x"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"??"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.string_literal {#jsir, "default for d"} +// JSIR-NEXT: // %20 = "default for d" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 119, 122, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"a"} +// JSIR-NEXT: // %2 = "default for a" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 135, 138, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"b"} +// JSIR-NEXT: // %6 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"console"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 151, 154, 0, "log">} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier {"c"} +// JSIR-NEXT: // %10 = 4.200000e+01 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.call_expression (%9, %10) +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%11) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier {"console"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 167, 170, 0, "log">} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.identifier {"d"} +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.call_expression (%13, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/README.generated.md index fbd781f2..7172c6d8 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/output.generated.txt index 7ca274fb..0a6badcc 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/output.generated.txt @@ -1,221 +1,221 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 27, 31, " s">, #jsir, , 62, 66, " e">, #jsir, , 87, 91, " l">, #jsir, , 112, 116, " l">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.parenthesized_expression"(%2) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.binary_expression"(%6, %7) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.member_expression"(%3, %8) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.string_literal"() <{extra = #jsir, value = "h"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.unary_expression"(%12) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.binary_expression"(%13, %14) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %16 = "jsir.parenthesized_expression"(%15) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jsir.unary_expression"(%17) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %20 = "jsir.unary_expression"(%19) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %21 = "jsir.binary_expression"(%18, %20) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %22 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %23 = "jsir.unary_expression"(%22) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %24 = "jsir.binary_expression"(%21, %23) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %25 = "jsir.member_expression"(%16, %24) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %26 = "jsir.binary_expression"(%11, %25) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %27 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %28 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any -// JSHIR-NEXT: %29 = "jsir.binary_expression"(%27, %28) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %30 = "jsir.parenthesized_expression"(%29) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %31 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %32 = "jsir.unary_expression"(%31) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %33 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %34 = "jsir.unary_expression"(%33) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %35 = "jsir.binary_expression"(%32, %34) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %36 = "jsir.member_expression"(%30, %35) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %37 = "jsir.binary_expression"(%26, %36) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %38 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %39 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any -// JSHIR-NEXT: %40 = "jsir.binary_expression"(%38, %39) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %41 = "jsir.parenthesized_expression"(%40) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %42 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %43 = "jsir.unary_expression"(%42) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %44 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %45 = "jsir.unary_expression"(%44) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %46 = "jsir.binary_expression"(%43, %45) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %47 = "jsir.member_expression"(%41, %46) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %48 = "jsir.binary_expression"(%37, %47) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%48) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[#jsir, , 27, 31, " s">, #jsir, , 62, 66, " e">, #jsir, , 87, 91, " l">, #jsir, , 112, 116, " l">]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %0 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.string_literal {#jsir, ""} -// JSHIR-NEXT: // %1 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} -// JSHIR-NEXT: // %2 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.parenthesized_expression (%2) -// JSHIR-NEXT: // %3 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %4 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %5 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.binary_expression (%4, %5) {"+"} -// JSHIR-NEXT: // %6 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %7 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.binary_expression (%6, %7) {"+"} -// JSHIR-NEXT: // %8 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.member_expression (%3, %8) -// JSHIR-NEXT: // %9 = "s" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.string_literal {#jsir, "h"} -// JSHIR-NEXT: // %10 = "h" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} -// JSHIR-NEXT: // %11 = "sh" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %12 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.unary_expression (%12) {"!", true} -// JSHIR-NEXT: // %13 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.string_literal {#jsir, ""} -// JSHIR-NEXT: // %14 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.binary_expression (%13, %14) {"+"} -// JSHIR-NEXT: // %15 = "true" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.parenthesized_expression (%15) -// JSHIR-NEXT: // %16 = "true" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %17 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jsir.unary_expression (%17) {"!", true} -// JSHIR-NEXT: // %18 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %19 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.unary_expression (%19) {"!", true} -// JSHIR-NEXT: // %20 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %21 = jsir.binary_expression (%18, %20) {"+"} -// JSHIR-NEXT: // %21 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %22 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %22 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %23 = jsir.unary_expression (%22) {"!", true} -// JSHIR-NEXT: // %23 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %24 = jsir.binary_expression (%21, %23) {"+"} -// JSHIR-NEXT: // %24 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %25 = jsir.member_expression (%16, %24) -// JSHIR-NEXT: // %25 = "e" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %26 = jsir.binary_expression (%11, %25) {"+"} -// JSHIR-NEXT: // %26 = "she" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %27 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %27 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %28 = jsir.string_literal {#jsir, ""} -// JSHIR-NEXT: // %28 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %29 = jsir.binary_expression (%27, %28) {"+"} -// JSHIR-NEXT: // %29 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %30 = jsir.parenthesized_expression (%29) -// JSHIR-NEXT: // %30 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %31 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %31 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %32 = jsir.unary_expression (%31) {"!", true} -// JSHIR-NEXT: // %32 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %33 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %33 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %34 = jsir.unary_expression (%33) {"!", true} -// JSHIR-NEXT: // %34 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %35 = jsir.binary_expression (%32, %34) {"+"} -// JSHIR-NEXT: // %35 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %36 = jsir.member_expression (%30, %35) -// JSHIR-NEXT: // %36 = "l" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %37 = jsir.binary_expression (%26, %36) {"+"} -// JSHIR-NEXT: // %37 = "shel" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %38 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %38 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %39 = jsir.string_literal {#jsir, ""} -// JSHIR-NEXT: // %39 = "" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %40 = jsir.binary_expression (%38, %39) {"+"} -// JSHIR-NEXT: // %40 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %41 = jsir.parenthesized_expression (%40) -// JSHIR-NEXT: // %41 = "false" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %42 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %42 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %43 = jsir.unary_expression (%42) {"!", true} -// JSHIR-NEXT: // %43 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %44 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %44 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %45 = jsir.unary_expression (%44) {"!", true} -// JSHIR-NEXT: // %45 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %46 = jsir.binary_expression (%43, %45) {"+"} -// JSHIR-NEXT: // %46 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %47 = jsir.member_expression (%41, %46) -// JSHIR-NEXT: // %47 = "l" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %48 = jsir.binary_expression (%37, %47) {"+"} -// JSHIR-NEXT: // %48 = "shell" -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%48) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = [#jsir, , 27, 31, " s">, #jsir, , 62, 66, " e">, #jsir, , 87, 91, " l">, #jsir, , 112, 116, " l">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.parenthesized_expression"(%2) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %7 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.binary_expression"(%6, %7) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %9 = "jsir.member_expression"(%3, %8) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.string_literal"() <{extra = #jsir, value = "h"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.unary_expression"(%12) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %14 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.binary_expression"(%13, %14) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %16 = "jsir.parenthesized_expression"(%15) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %17 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.unary_expression"(%17) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %20 = "jsir.unary_expression"(%19) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %21 = "jsir.binary_expression"(%18, %20) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %22 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %23 = "jsir.unary_expression"(%22) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %24 = "jsir.binary_expression"(%21, %23) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %25 = "jsir.member_expression"(%16, %24) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %26 = "jsir.binary_expression"(%11, %25) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %27 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %28 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any +// JSIR-NEXT: %29 = "jsir.binary_expression"(%27, %28) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %30 = "jsir.parenthesized_expression"(%29) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %31 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %32 = "jsir.unary_expression"(%31) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %33 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %34 = "jsir.unary_expression"(%33) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %35 = "jsir.binary_expression"(%32, %34) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %36 = "jsir.member_expression"(%30, %35) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %37 = "jsir.binary_expression"(%26, %36) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %38 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %39 = "jsir.string_literal"() <{extra = #jsir, value = ""}> : () -> !jsir.any +// JSIR-NEXT: %40 = "jsir.binary_expression"(%38, %39) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %41 = "jsir.parenthesized_expression"(%40) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %42 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %43 = "jsir.unary_expression"(%42) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %44 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %45 = "jsir.unary_expression"(%44) <{operator_ = "!", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %46 = "jsir.binary_expression"(%43, %45) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %47 = "jsir.member_expression"(%41, %46) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %48 = "jsir.binary_expression"(%37, %47) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%48) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[#jsir, , 27, 31, " s">, #jsir, , 62, 66, " e">, #jsir, , 87, 91, " l">, #jsir, , 112, 116, " l">]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.boolean_literal {false} +// JSIR-NEXT: // %0 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.string_literal {#jsir, ""} +// JSIR-NEXT: // %1 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} +// JSIR-NEXT: // %2 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.parenthesized_expression (%2) +// JSIR-NEXT: // %3 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.boolean_literal {true} +// JSIR-NEXT: // %4 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.boolean_literal {true} +// JSIR-NEXT: // %5 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.binary_expression (%4, %5) {"+"} +// JSIR-NEXT: // %6 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.boolean_literal {true} +// JSIR-NEXT: // %7 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.binary_expression (%6, %7) {"+"} +// JSIR-NEXT: // %8 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.member_expression (%3, %8) +// JSIR-NEXT: // %9 = "s" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.string_literal {#jsir, "h"} +// JSIR-NEXT: // %10 = "h" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} +// JSIR-NEXT: // %11 = "sh" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.boolean_literal {false} +// JSIR-NEXT: // %12 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.unary_expression (%12) {"!", true} +// JSIR-NEXT: // %13 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.string_literal {#jsir, ""} +// JSIR-NEXT: // %14 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.binary_expression (%13, %14) {"+"} +// JSIR-NEXT: // %15 = "true" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.parenthesized_expression (%15) +// JSIR-NEXT: // %16 = "true" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %17 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.unary_expression (%17) {"!", true} +// JSIR-NEXT: // %18 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %19 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.unary_expression (%19) {"!", true} +// JSIR-NEXT: // %20 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %21 = jsir.binary_expression (%18, %20) {"+"} +// JSIR-NEXT: // %21 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %22 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %22 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %23 = jsir.unary_expression (%22) {"!", true} +// JSIR-NEXT: // %23 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %24 = jsir.binary_expression (%21, %23) {"+"} +// JSIR-NEXT: // %24 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %25 = jsir.member_expression (%16, %24) +// JSIR-NEXT: // %25 = "e" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %26 = jsir.binary_expression (%11, %25) {"+"} +// JSIR-NEXT: // %26 = "she" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %27 = jsir.boolean_literal {false} +// JSIR-NEXT: // %27 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %28 = jsir.string_literal {#jsir, ""} +// JSIR-NEXT: // %28 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %29 = jsir.binary_expression (%27, %28) {"+"} +// JSIR-NEXT: // %29 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %30 = jsir.parenthesized_expression (%29) +// JSIR-NEXT: // %30 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %31 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %31 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %32 = jsir.unary_expression (%31) {"!", true} +// JSIR-NEXT: // %32 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %33 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %33 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %34 = jsir.unary_expression (%33) {"!", true} +// JSIR-NEXT: // %34 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %35 = jsir.binary_expression (%32, %34) {"+"} +// JSIR-NEXT: // %35 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %36 = jsir.member_expression (%30, %35) +// JSIR-NEXT: // %36 = "l" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %37 = jsir.binary_expression (%26, %36) {"+"} +// JSIR-NEXT: // %37 = "shel" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %38 = jsir.boolean_literal {false} +// JSIR-NEXT: // %38 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %39 = jsir.string_literal {#jsir, ""} +// JSIR-NEXT: // %39 = "" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %40 = jsir.binary_expression (%38, %39) {"+"} +// JSIR-NEXT: // %40 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %41 = jsir.parenthesized_expression (%40) +// JSIR-NEXT: // %41 = "false" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %42 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %42 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %43 = jsir.unary_expression (%42) {"!", true} +// JSIR-NEXT: // %43 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %44 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %44 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %45 = jsir.unary_expression (%44) {"!", true} +// JSIR-NEXT: // %45 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %46 = jsir.binary_expression (%43, %45) {"+"} +// JSIR-NEXT: // %46 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %47 = jsir.member_expression (%41, %46) +// JSIR-NEXT: // %47 = "l" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %48 = jsir.binary_expression (%37, %47) {"+"} +// JSIR-NEXT: // %48 = "shell" +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%48) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/or/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/or/README.generated.md index cb8336a5..b83fd0e4 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/or/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/or/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/or/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/or/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/or/output.generated.txt index 894e0b7c..a8f59e9a 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/or/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/or/output.generated.txt @@ -1,254 +1,254 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "||"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "||"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "||"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %18 = "jshir.logical_expression"(%17) <{operator_ = "||"}> ({ -// JSHIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 93, 96, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 109, 112, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 125, 128, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () -// JSHIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 141, 144, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %17 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"||"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %20 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %17 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"||"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %20 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"c"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"x"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"||"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {true} -// JSHIR-NEXT: // %20 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.identifier_ref {"d"} -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.identifier {"x"} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jshir.logical_expression (%17) {"||"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %20 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %20 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%20) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.variable_declarator (%16, %18) -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 93, 96, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"a"} -// JSHIR-NEXT: // %2 = true -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 109, 112, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"b"} -// JSHIR-NEXT: // %6 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"console"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 125, 128, 0, "log">} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier {"c"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.call_expression (%9, %10) -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%11) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.identifier {"console"} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 141, 144, 0, "log">} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.identifier {"d"} -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.call_expression (%13, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "||"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "||"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "||"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %16 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %18 = "jsir.logical_expression"(%17) <{operator_ = "||"}> ({ +// JSIR-NEXT: %20 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%20) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %19 = "jsir.variable_declarator"(%16, %18) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 93, 96, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 109, 112, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.member_expression"(%8) <{literal_property = #jsir, , "log", 125, 128, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.call_expression"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%11) : (!jsir.any) -> () +// JSIR-NEXT: %12 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.member_expression"(%12) <{literal_property = #jsir, , "log", 141, 144, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %14 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.call_expression"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.boolean_literal {true} +// JSIR-NEXT: // %17 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"||"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {true} +// JSIR-NEXT: // %20 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.boolean_literal {false} +// JSIR-NEXT: // %17 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"||"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {false} +// JSIR-NEXT: // %20 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"c"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"x"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"||"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {true} +// JSIR-NEXT: // %20 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.identifier_ref {"d"} +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.identifier {"x"} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.logical_expression (%17) {"||"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %20 = jsir.boolean_literal {false} +// JSIR-NEXT: // %20 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%20) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.variable_declarator (%16, %18) +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 93, 96, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"a"} +// JSIR-NEXT: // %2 = true +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 109, 112, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"b"} +// JSIR-NEXT: // %6 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"console"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.member_expression (%8) {#jsir, , "log", 125, 128, 0, "log">} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier {"c"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.call_expression (%9, %10) +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%11) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.identifier {"console"} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 141, 144, 0, "log">} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.identifier {"d"} +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.call_expression (%13, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/or/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/or/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/or/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/or/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/simple/README.generated.md index 7fec99ba..8ba35097 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/simple/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/simple/output.generated.txt index 89cd31cd..0ee47017 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple/output.generated.txt @@ -1,37 +1,37 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %0 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} -// JSHIR-NEXT: // %2 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %0 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %1 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} +// JSIR-NEXT: // %2 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/simple/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/README.generated.md index 7af6eb54..e21ece92 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/output.generated.txt index 3022e99a..8decb5e1 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/output.generated.txt @@ -1,60 +1,60 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %4 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.variable_declarator (%3, %4) -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"a"} -// JSHIR-NEXT: // %0 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} -// JSHIR-NEXT: // %2 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %4 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.variable_declarator (%3, %4) +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"a"} +// JSIR-NEXT: // %0 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %1 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.binary_expression (%0, %1) {"+"} +// JSIR-NEXT: // %2 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/switch/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/switch/README.generated.md index 9ec393f9..3a8be37e 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/switch/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/switch/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/switch/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/switch/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/switch/output.generated.txt index b277b03f..c22a2f9f 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/switch/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/switch/output.generated.txt @@ -1,199 +1,199 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.variable_declarator"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.switch_statement"(%0) ({ -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: "jsir.empty_statement"() : () -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.member_expression"(%1) <{literal_property = #jsir, , "log", 130, 133, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.call_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %6 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.variable_declarator (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"x"} -// JSHIR-NEXT: // %0 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.switch_statement (%0) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.switch_case ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.break_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.switch_case ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.switch_case ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 3.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} -// JSHIR-NEXT: // %6 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.break_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.switch_case ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.numeric_literal {#jsir, 5.000000e+00 : f64} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.break_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.empty_statement -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.identifier {"console"} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.member_expression (%1) {#jsir, , "log", 130, 133, 0, "log">} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.identifier {"x"} -// JSHIR-NEXT: // %3 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.call_expression (%2, %3) -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.variable_declarator"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.switch_statement"(%0) ({ +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.empty_statement"() : () -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.member_expression"(%1) <{literal_property = #jsir, , "log", 130, 133, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.call_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %6 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.variable_declarator (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"x"} +// JSIR-NEXT: // %0 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.switch_statement (%0) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.switch_case ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %5 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.break_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.switch_case ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %5 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.switch_case ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %5 = 3.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} +// JSIR-NEXT: // %6 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.break_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.switch_case ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} +// JSIR-NEXT: // %5 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.numeric_literal {#jsir, 5.000000e+00 : f64} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.break_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.empty_statement +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.identifier {"console"} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.member_expression (%1) {#jsir, , "log", 130, 133, 0, "log">} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.identifier {"x"} +// JSIR-NEXT: // %3 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.call_expression (%2, %3) +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/switch/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/switch/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/switch/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/switch/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/test_config.json b/maldoca/js/ir/analyses/constant_propagation/tests/test_config.json new file mode 100644 index 00000000..25da8e72 --- /dev/null +++ b/maldoca/js/ir/analyses/constant_propagation/tests/test_config.json @@ -0,0 +1,11 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir", + "jsir_analysis": "constant_propagation", + "prefix": "JSIR" + } + ], + "build_template": "../../BUILD.general.template" +} diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/README.generated.md index d85f0d9f..b8762b39 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/output.generated.txt index e7e1c7c8..bc26d507 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/output.generated.txt @@ -1,181 +1,181 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.try_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "e"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.catch_clause"(%4) ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 80, 83, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.try_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 2.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"e"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.catch_clause (%4) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 80, 83, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = 4.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.try_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "e"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.catch_clause"(%4) ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 80, 83, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %5 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.try_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %5 = 2.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"e"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.catch_clause (%4) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 4.000000e+00 : f64} +// JSIR-NEXT: // %5 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 80, 83, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = 4.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/README.generated.md index c4ab2b4c..2510a717 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/output.generated.txt index 9a2fc7aa..518643f7 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/output.generated.txt @@ -1,60 +1,60 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.assignment_expression (%0, %1) {"="} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.identifier_ref {"c"} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"a"} -// JSHIR-NEXT: // %4 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.variable_declarator (%3, %4) -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%5) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %1 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.assignment_expression (%0, %1) {"="} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.identifier_ref {"c"} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"a"} +// JSIR-NEXT: // %4 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.variable_declarator (%3, %4) +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%5) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/README.generated.md index d3013bbb..77e38ce4 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/output.generated.txt index 5865606c..aabdbc88 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/output.generated.txt @@ -1,123 +1,123 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.update_expression"(%3) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.update_expression"(%8) <{operator_ = "++", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () -// JSHIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "should_be_0"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.update_expression"(%11) <{operator_ = "--", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.assignment_expression"(%10, %12) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%13) : (!jsir.any) -> () -// JSHIR-NEXT: %14 = "jsir.identifier_ref"() <{name = "unknown"}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.identifier"() <{name = "getUnknown"}> : () -> !jsir.any -// JSHIR-NEXT: %16 = "jsir.call_expression"(%15) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.assignment_expression"(%14, %16) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%17) : (!jsir.any) -> () -// JSHIR-NEXT: %18 = "jsir.identifier_ref"() <{name = "unknown"}> : () -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.update_expression"(%18) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%19) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.assignment_expression (%0, %1) {"="} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%2) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.update_expression (%3) {"++", false} -// JSHIR-NEXT: // %4 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %6 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"b"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.update_expression (%8) {"++", true} -// JSHIR-NEXT: // %9 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%9) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.identifier_ref {"should_be_0"} -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.update_expression (%11) {"--", true} -// JSHIR-NEXT: // %12 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.assignment_expression (%10, %12) {"="} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%13) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.identifier_ref {"unknown"} -// JSHIR-NEXT: // %14 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.identifier {"getUnknown"} -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %16 = jsir.call_expression (%15) -// JSHIR-NEXT: // %16 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %17 = jsir.assignment_expression (%14, %16) {"="} -// JSHIR-NEXT: // %17 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%17) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %18 = jsir.identifier_ref {"unknown"} -// JSHIR-NEXT: // %18 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %19 = jsir.update_expression (%18) {"++", false} -// JSHIR-NEXT: // %19 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%19) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.update_expression"(%3) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: %5 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.assignment_expression"(%5, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.update_expression"(%8) <{operator_ = "++", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%9) : (!jsir.any) -> () +// JSIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "should_be_0"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %12 = "jsir.update_expression"(%11) <{operator_ = "--", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %13 = "jsir.assignment_expression"(%10, %12) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%13) : (!jsir.any) -> () +// JSIR-NEXT: %14 = "jsir.identifier_ref"() <{name = "unknown"}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.identifier"() <{name = "getUnknown"}> : () -> !jsir.any +// JSIR-NEXT: %16 = "jsir.call_expression"(%15) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %17 = "jsir.assignment_expression"(%14, %16) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%17) : (!jsir.any) -> () +// JSIR-NEXT: %18 = "jsir.identifier_ref"() <{name = "unknown"}> : () -> !jsir.any +// JSIR-NEXT: %19 = "jsir.update_expression"(%18) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%19) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %1 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.assignment_expression (%0, %1) {"="} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%2) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.update_expression (%3) {"++", false} +// JSIR-NEXT: // %4 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %6 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.assignment_expression (%5, %6) {"="} +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"b"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.update_expression (%8) {"++", true} +// JSIR-NEXT: // %9 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%9) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.identifier_ref {"should_be_0"} +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.update_expression (%11) {"--", true} +// JSIR-NEXT: // %12 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.assignment_expression (%10, %12) {"="} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%13) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.identifier_ref {"unknown"} +// JSIR-NEXT: // %14 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.identifier {"getUnknown"} +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %16 = jsir.call_expression (%15) +// JSIR-NEXT: // %16 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %17 = jsir.assignment_expression (%14, %16) {"="} +// JSIR-NEXT: // %17 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%17) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %18 = jsir.identifier_ref {"unknown"} +// JSIR-NEXT: // %18 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %19 = jsir.update_expression (%18) {"++", false} +// JSIR-NEXT: // %19 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%19) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/README.generated.md index 276cc6a3..88d7cfb0 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/void_0/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/output.generated.txt index 0c2cf4b0..c587bffc 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/output.generated.txt @@ -1,49 +1,49 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.unary_expression"(%1) <{operator_ = "void", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.variable_declarator"(%0, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier_ref {"a"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} -// JSHIR-NEXT: // %1 = 0.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.unary_expression (%1) {"void", true} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.variable_declarator (%0, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.unary_expression"(%1) <{operator_ = "void", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.variable_declarator"(%0, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier_ref {"a"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} +// JSIR-NEXT: // %1 = 0.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.unary_expression (%1) {"void", true} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.variable_declarator (%0, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/while/README.generated.md index 5ac421b2..36f6753d 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/while/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/while/output.generated.txt index cb38535b..9d526fa5 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while/output.generated.txt @@ -1,163 +1,163 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 53, " TODO(b/217662731): `is_a_const` should be a const.">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.identifier"() <{name = "not_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.assignment_expression"(%8, %11) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%12) : (!jsir.any) -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %13 = "jsir.identifier_ref"() <{name = "is_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.variable_declarator"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 153, 156, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "not_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 179, 182, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "is_a_const"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[#jsir, , 0, 53, " TODO(b/217662731): `is_a_const` should be a const.">]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"not_a_const"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %9 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.variable_declarator (%8, %9) -// JSHIR-NEXT: // %10 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%10) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier {"x"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%8) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %8 = jsir.identifier_ref {"not_a_const"} -// JSHIR-NEXT: // %8 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %9 = jsir.identifier {"not_a_const"} -// JSHIR-NEXT: // %9 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %10 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %10 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} -// JSHIR-NEXT: // %11 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %12 = jsir.assignment_expression (%8, %11) {"="} -// JSHIR-NEXT: // %12 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%12) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %13 = jsir.identifier_ref {"is_a_const"} -// JSHIR-NEXT: // %13 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %14 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %14 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %15 = jsir.variable_declarator (%13, %14) -// JSHIR-NEXT: // %15 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%15) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 153, 156, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"not_a_const"} -// JSHIR-NEXT: // %2 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier {"console"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 179, 182, 0, "log">} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.identifier {"is_a_const"} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %7 = jsir.call_expression (%5, %6) -// JSHIR-NEXT: // %7 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%7) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 53, " TODO(b/217662731): `is_a_const` should be a const.">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.variable_declarator"(%8, %9) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%10) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%8) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "not_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.identifier"() <{name = "not_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.binary_expression"(%9, %10) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.assignment_expression"(%8, %11) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%12) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %13 = "jsir.identifier_ref"() <{name = "is_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.variable_declarator"(%13, %14) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%15) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 153, 156, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "not_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.member_expression"(%4) <{literal_property = #jsir, , "log", 179, 182, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "is_a_const"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%5, %6) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[#jsir, , 0, 53, " TODO(b/217662731): `is_a_const` should be a const.">]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"not_a_const"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %9 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.variable_declarator (%8, %9) +// JSIR-NEXT: // %10 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%10) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier {"x"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%8) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %8 = jsir.identifier_ref {"not_a_const"} +// JSIR-NEXT: // %8 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %9 = jsir.identifier {"not_a_const"} +// JSIR-NEXT: // %9 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %10 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %10 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %11 = jsir.binary_expression (%9, %10) {"+"} +// JSIR-NEXT: // %11 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %12 = jsir.assignment_expression (%8, %11) {"="} +// JSIR-NEXT: // %12 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%12) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %13 = jsir.identifier_ref {"is_a_const"} +// JSIR-NEXT: // %13 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %14 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %14 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %15 = jsir.variable_declarator (%13, %14) +// JSIR-NEXT: // %15 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%15) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 153, 156, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"not_a_const"} +// JSIR-NEXT: // %2 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier {"console"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.member_expression (%4) {#jsir, , "log", 179, 182, 0, "log">} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.identifier {"is_a_const"} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %7 = jsir.call_expression (%5, %6) +// JSIR-NEXT: // %7 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%7) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/while/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/README.generated.md b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/README.generated.md index 74e197cd..fdf21afa 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/README.generated.md +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/README.generated.md @@ -3,6 +3,6 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/input.js \ - --passes "source2ast,ast2hir" \ + --passes "source2ast,ast2jsir" \ --jsir_analysis constant_propagation ``` diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/output.generated.txt b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/output.generated.txt index f78bb92e..726f2024 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/output.generated.txt +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/output.generated.txt @@ -1,113 +1,113 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 46, 49, 0, "log">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: jsir.file {[]} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.program {"script"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.variable_declaration {"var"} ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} -// JSHIR-NEXT: // %5 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.variable_declarator (%4, %5) -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.exprs_region_end (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.while_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.boolean_literal {false} -// JSHIR-NEXT: // %4 = false -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expr_region_end (%4) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jshir.block_statement ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %4 = jsir.identifier_ref {"x"} -// JSHIR-NEXT: // %4 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} -// JSHIR-NEXT: // %5 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} -// JSHIR-NEXT: // %6 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%6) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %0 = jsir.identifier {"console"} -// JSHIR-NEXT: // %0 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 46, 49, 0, "log">} -// JSHIR-NEXT: // %1 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %2 = jsir.identifier {"x"} -// JSHIR-NEXT: // %2 = 1.000000e+00 : f64 -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: %3 = jsir.call_expression (%1, %2) -// JSHIR-NEXT: // %3 = -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: jsir.expression_statement (%3) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: // -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } -// JSHIR-NEXT: }) -// JSHIR-NEXT: // State [default = ] { } +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.variable_declarator"(%4, %5) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %4 = "jsir.boolean_literal"() <{value = false}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.assignment_expression"(%4, %5) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "console"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "log", 46, 49, 0, "log">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.call_expression"(%1, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: jsir.file {[]} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.program {"script"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.variable_declaration {"var"} ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} +// JSIR-NEXT: // %5 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.variable_declarator (%4, %5) +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.exprs_region_end (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.while_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.boolean_literal {false} +// JSIR-NEXT: // %4 = false +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expr_region_end (%4) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.block_statement ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %4 = jsir.identifier_ref {"x"} +// JSIR-NEXT: // %4 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %5 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} +// JSIR-NEXT: // %5 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %6 = jsir.assignment_expression (%4, %5) {"="} +// JSIR-NEXT: // %6 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%6) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %0 = jsir.identifier {"console"} +// JSIR-NEXT: // %0 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 46, 49, 0, "log">} +// JSIR-NEXT: // %1 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %2 = jsir.identifier {"x"} +// JSIR-NEXT: // %2 = 1.000000e+00 : f64 +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: %3 = jsir.call_expression (%1, %2) +// JSIR-NEXT: // %3 = +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: jsir.expression_statement (%3) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: // +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } +// JSIR-NEXT: }) +// JSIR-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/run.generated.lit b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/run.generated.lit index f120aee7..cb71d6ad 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/run.generated.lit +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/run.generated.lit @@ -1,5 +1,5 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ +// RUN: --passes "source2ast,ast2jsir" \ // RUN: --jsir_analysis constant_propagation \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname %s)"/output.generated.txt +// RUN: | FileCheck --check-prefix JSIR "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/analyses/dataflow_analysis.h b/maldoca/js/ir/analyses/dataflow_analysis.h index bb6ec455..3284a1ad 100644 --- a/maldoca/js/ir/analyses/dataflow_analysis.h +++ b/maldoca/js/ir/analyses/dataflow_analysis.h @@ -460,8 +460,8 @@ class JsirDataFlowAnalysis : public mlir::DataFlowAnalysis, if (getProgramPointBefore(&op) == from) { break; } - if (llvm::isa(op) || - llvm::isa(op)) { + if (llvm::isa(op) || + llvm::isa(op)) { return; } } @@ -618,7 +618,7 @@ class JsirDataFlowAnalysis : public mlir::DataFlowAnalysis, } static mlir::Region& GetForStatementContinueTargetRegion( - JshirForStatementOp for_stmt) { + JsirForStatementOp for_stmt) { if (!for_stmt.getUpdate().empty()) { return for_stmt.getUpdate(); } @@ -642,7 +642,7 @@ class JsirDataFlowAnalysis : public mlir::DataFlowAnalysis, std::optional WithLabel( mlir::Operation* op) { - if (auto labeled_stmt = llvm::dyn_cast(op); + if (auto labeled_stmt = llvm::dyn_cast(op); labeled_stmt != nullptr) { return jump_env_.WithLabel(labeled_stmt.getLabel().getName()); } @@ -932,15 +932,15 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( llvm::isa(op) || llvm::isa(op) || llvm::isa(op) || - llvm::isa(op) || - llvm::isa(op) || + llvm::isa(op) || + llvm::isa(op) || llvm::isa(op) || llvm::isa(op) || llvm::isa(op) || llvm::isa(op) /* TODO Should this be here? */ || llvm::isa(op) || llvm::isa(op)) { - if (llvm::isa(op)) { + if (llvm::isa(op)) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(op), .unlabeled_break_target = std::nullopt, @@ -968,7 +968,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.if_statement ( + // │ jsir.if_statement ( // ├─────► ┌───────────────┐ // │ │ true region │ // │ ┌──◄ └───────────────┘ @@ -977,7 +977,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ├──◄ └───────────────┘ // │ ); // └──► - if (auto if_stmt = llvm::dyn_cast(op); + if (auto if_stmt = llvm::dyn_cast(op); if_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(if_stmt), @@ -1019,7 +1019,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.block_statement ( + // │ jsir.block_statement ( // └─────► ┌───────────────┐ // │ directives │ // ┌──◄ └───────────────┘ @@ -1028,7 +1028,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ┌─────◄ └───────────────┘ // │ ); // └─────► - if (auto block_stmt = llvm::dyn_cast(op); + if (auto block_stmt = llvm::dyn_cast(op); block_stmt != nullptr) { MaybeEmplaceCfgEdges({ .from = Before(block_stmt), @@ -1048,7 +1048,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.while_statement ( + // │ jsir.while_statement ( // ├─────► ┌───────────────┐ // │ │ test region │ // │ ┌──◄ └───────────────┘ @@ -1057,7 +1057,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // └──│──◄ └───────────────┘ // │ ); // └──► - if (auto while_stmt = llvm::dyn_cast(op); + if (auto while_stmt = llvm::dyn_cast(op); while_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(while_stmt), @@ -1091,7 +1091,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.do_while_statement ( + // │ jsir.do_while_statement ( // ├─────► ┌───────────────┐ // │ │ body region │ // │ ┌──◄ └───────────────┘ @@ -1100,7 +1100,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ├─────◄ └───────────────┘ // │ ); // └─────► - if (auto do_while_stmt = llvm::dyn_cast(op); + if (auto do_while_stmt = llvm::dyn_cast(op); do_while_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(do_while_stmt), @@ -1135,7 +1135,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.for_statement ( + // │ jsir.for_statement ( // └─────► ┌───────────────┐ // │ init region │ // ┌────────◄ └───────────────┘ @@ -1150,7 +1150,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // └──│─────◄ └───────────────┘ // │ ); // └─────► - if (auto for_stmt = llvm::dyn_cast(op); + if (auto for_stmt = llvm::dyn_cast(op); for_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(for_stmt), @@ -1219,13 +1219,13 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.for_in_statement ( + // │ jsir.for_in_statement ( // └──┬──► ┌───────────────┐ // │ │ body region │ // ┌──┴──◄ └───────────────┘ // │ ); // └─────► - if (auto for_in_stmt = llvm::dyn_cast(op); + if (auto for_in_stmt = llvm::dyn_cast(op); for_in_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(for_in_stmt), @@ -1251,13 +1251,13 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.for_of_statement ( + // │ jsir.for_of_statement ( // └──┬──► ┌───────────────┐ // │ │ body region │ // ┌──┴──◄ └───────────────┘ // │ ); // └─────► - if (auto for_of_stmt = llvm::dyn_cast(op); + if (auto for_of_stmt = llvm::dyn_cast(op); for_of_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(for_of_stmt), @@ -1283,13 +1283,13 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.logical_expression ( + // │ jsir.logical_expression ( // ├─────► ┌───────────────┐ // │ │ right region │ // │ ┌──◄ └───────────────┘ // │ │ ); // └──┴──► - if (auto logical_expr = llvm::dyn_cast(op); + if (auto logical_expr = llvm::dyn_cast(op); logical_expr != nullptr) { mlir::Attribute comparison_attr; switch (*StringToJsLogicalOperator(logical_expr.getOperator_())) { @@ -1333,7 +1333,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.conditional_expression ( + // │ jsir.conditional_expression ( // ├─────► ┌───────────────┐ // │ │ true region │ // │ ┌──◄ └───────────────┘ @@ -1342,7 +1342,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ├──◄ └───────────────┘ // │ ); // └──► - if (auto conditional_expr = llvm::dyn_cast(op); + if (auto conditional_expr = llvm::dyn_cast(op); conditional_expr != nullptr) { MaybeEmplaceCfgEdges({ .from = Before(conditional_expr), @@ -1372,7 +1372,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( }); } - if (auto break_stmt = llvm::dyn_cast(op); + if (auto break_stmt = llvm::dyn_cast(op); break_stmt != nullptr) { absl::StatusOr break_target; @@ -1392,7 +1392,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } } - if (auto continue_stmt = llvm::dyn_cast(op); + if (auto continue_stmt = llvm::dyn_cast(op); continue_stmt != nullptr) { absl::StatusOr continue_target; @@ -1413,7 +1413,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( } // ┌─────◄ - // │ jshir.try_statement ( + // │ jsir.try_statement ( // └─────► ┌───────────────┐ // │ block │ // ┌──◄ └───────────────┘ @@ -1425,7 +1425,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ┌──┴──◄ └───────────────┘ // │ ); // └─────► - if (auto try_stmt = llvm::dyn_cast(op); + if (auto try_stmt = llvm::dyn_cast(op); try_stmt != nullptr) { MaybeEmplaceCfgEdges({ .from = Before(try_stmt), @@ -1459,7 +1459,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ┌─────◄ └───────────────┘ // │ ); // └─────► - if (auto switch_stmt = llvm::dyn_cast(op); + if (auto switch_stmt = llvm::dyn_cast(op); switch_stmt != nullptr) { maybe_jump_targets = { .labeled_break_target = getProgramPointAfter(switch_stmt), @@ -1488,7 +1488,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // ┌─────◄ └───────────────┘ // │ ); // └─────► - if (auto switch_case = llvm::dyn_cast(op); + if (auto switch_case = llvm::dyn_cast(op); switch_case != nullptr) { if (switch_case.getTest().empty()) { MaybeEmplaceCfgEdges({ @@ -1507,7 +1507,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( .to = Before(switch_case.getConsequent()), .owner = &*switch_case, .liveness_info = LiveIfEqualOrUnknown( - switch_case->getParentOfType() + switch_case->getParentOfType() .getDiscriminant(), GetExprRegionEndValuesFromRegion(switch_case.getTest())[0]), }); @@ -1517,7 +1517,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( .to = After(switch_case), .owner = &*switch_case, .liveness_info = LiveIfNotEqualOrUnknown( - switch_case->getParentOfType() + switch_case->getParentOfType() .getDiscriminant(), GetExprRegionEndValuesFromRegion(switch_case.getTest())[0]), }); @@ -1525,7 +1525,7 @@ mlir::LogicalResult JsirDataFlowAnalysis::initialize( // If this is not the last case, we need fall-through to the next case. if (auto* next_node = switch_case->getNextNode(); next_node != nullptr) { - if (auto successor_case = llvm::dyn_cast(next_node); + if (auto successor_case = llvm::dyn_cast(next_node); successor_case != nullptr) { MaybeEmplaceCfgEdges({ .from = After(switch_case.getConsequent()), diff --git a/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc b/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc index 65d974e4..afcb4b2c 100644 --- a/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc +++ b/maldoca/js/ir/analyses/dynamic_constant_propagation/analysis_test.cc @@ -78,8 +78,8 @@ void RunTest(const JsirAnalysisConfig::DynamicConstantPropagation &config, mlir_context.loadDialect(); MALDOCA_ASSERT_OK_AND_ASSIGN(mlir::OwningOpRef op, - AstToJshirFile(ast, mlir_context)); - JsHirRepr repr{std::move(op), scopes, std::nullopt}; + AstToJsirFile(ast, mlir_context)); + JsirRepr repr{std::move(op), scopes, std::nullopt}; // Get the const bindings. absl::flat_hash_map const_bindings = diff --git a/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc b/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc index c5e224f8..4410a4d1 100644 --- a/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc +++ b/maldoca/js/ir/analyses/dynamic_constant_propagation/symbol_mutation_info_test.cc @@ -59,8 +59,8 @@ TEST_P(GetLvalueRootSymbolsTest, GetLvalueRootSymbols) { LoadNecessaryDialects(mlir_context); MALDOCA_ASSERT_OK_AND_ASSIGN( - JsHirRepr hir_repr, - ToJsHirRepr::FromJsSourceRepr( + JsirRepr hir_repr, + ToJsirRepr::FromJsSourceRepr( source_repr, request, absl::InfiniteDuration(), /*recursion_depth_limit=*/std::nullopt, babel, mlir_context)); @@ -148,8 +148,8 @@ TEST_P(GetSymbolMutationInfosTest, GetSymbolMutationInfos) { LoadNecessaryDialects(mlir_context); MALDOCA_ASSERT_OK_AND_ASSIGN( - JsHirRepr hir_repr, - ToJsHirRepr::FromJsSourceRepr( + JsirRepr hir_repr, + ToJsirRepr::FromJsSourceRepr( source_repr, request, absl::InfiniteDuration(), /*recursion_depth_limit=*/std::nullopt, babel, mlir_context)); diff --git a/maldoca/js/ir/conversion/ast_to_jsir.generated.cc b/maldoca/js/ir/conversion/ast_to_jsir.generated.cc index b95be6f0..47baf118 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.generated.cc +++ b/maldoca/js/ir/conversion/ast_to_jsir.generated.cc @@ -475,8 +475,8 @@ JsirStatementOpInterface AstToJsir::VisitStatement(mlir::OpBuilder &builder, con LOG(FATAL) << "Unreachable code."; } -JshirBlockStatementOp AstToJsir::VisitBlockStatement(mlir::OpBuilder &builder, const JsBlockStatement *node) { - auto op = CreateStmt(builder, node); +JsirBlockStatementOp AstToJsir::VisitBlockStatement(mlir::OpBuilder &builder, const JsBlockStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_body_region = op.getBody(); AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { for (const auto &element : *node->body()) { @@ -505,9 +505,9 @@ JsirDebuggerStatementOp AstToJsir::VisitDebuggerStatement(mlir::OpBuilder &build return CreateStmt(builder, node); } -JshirWithStatementOp AstToJsir::VisitWithStatement(mlir::OpBuilder &builder, const JsWithStatement *node) { +JsirWithStatementOp AstToJsir::VisitWithStatement(mlir::OpBuilder &builder, const JsWithStatement *node) { mlir::Value mlir_object = VisitExpression(builder, node->object()); - auto op = CreateStmt(builder, node, mlir_object); + auto op = CreateStmt(builder, node, mlir_object); mlir::Region &mlir_body_region = op.getBody(); AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { VisitStatement(builder, node->body()); @@ -523,9 +523,9 @@ JsirReturnStatementOp AstToJsir::VisitReturnStatement(mlir::OpBuilder &builder, return CreateStmt(builder, node, mlir_argument); } -JshirLabeledStatementOp AstToJsir::VisitLabeledStatement(mlir::OpBuilder &builder, const JsLabeledStatement *node) { +JsirLabeledStatementOp AstToJsir::VisitLabeledStatement(mlir::OpBuilder &builder, const JsLabeledStatement *node) { JsirIdentifierAttr mlir_label = VisitIdentifierAttr(builder, node->label()); - auto op = CreateStmt(builder, node, mlir_label); + auto op = CreateStmt(builder, node, mlir_label); mlir::Region &mlir_body_region = op.getBody(); AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { VisitStatement(builder, node->body()); @@ -533,9 +533,9 @@ JshirLabeledStatementOp AstToJsir::VisitLabeledStatement(mlir::OpBuilder &builde return op; } -JshirIfStatementOp AstToJsir::VisitIfStatement(mlir::OpBuilder &builder, const JsIfStatement *node) { +JsirIfStatementOp AstToJsir::VisitIfStatement(mlir::OpBuilder &builder, const JsIfStatement *node) { mlir::Value mlir_test = VisitExpression(builder, node->test()); - auto op = CreateStmt(builder, node, mlir_test); + auto op = CreateStmt(builder, node, mlir_test); mlir::Region &mlir_consequent_region = op.getConsequent(); AppendNewBlockAndPopulate(builder, mlir_consequent_region, [&] { VisitStatement(builder, node->consequent()); @@ -549,8 +549,8 @@ JshirIfStatementOp AstToJsir::VisitIfStatement(mlir::OpBuilder &builder, const J return op; } -JshirSwitchCaseOp AstToJsir::VisitSwitchCase(mlir::OpBuilder &builder, const JsSwitchCase *node) { - auto op = CreateStmt(builder, node); +JsirSwitchCaseOp AstToJsir::VisitSwitchCase(mlir::OpBuilder &builder, const JsSwitchCase *node) { + auto op = CreateStmt(builder, node); if (node->test().has_value()) { mlir::Region &mlir_test_region = op.getTest(); AppendNewBlockAndPopulate(builder, mlir_test_region, [&] { @@ -567,9 +567,9 @@ JshirSwitchCaseOp AstToJsir::VisitSwitchCase(mlir::OpBuilder &builder, const JsS return op; } -JshirSwitchStatementOp AstToJsir::VisitSwitchStatement(mlir::OpBuilder &builder, const JsSwitchStatement *node) { +JsirSwitchStatementOp AstToJsir::VisitSwitchStatement(mlir::OpBuilder &builder, const JsSwitchStatement *node) { mlir::Value mlir_discriminant = VisitExpression(builder, node->discriminant()); - auto op = CreateStmt(builder, node, mlir_discriminant); + auto op = CreateStmt(builder, node, mlir_discriminant); mlir::Region &mlir_cases_region = op.getCases(); AppendNewBlockAndPopulate(builder, mlir_cases_region, [&] { for (const auto &element : *node->cases()) { @@ -584,12 +584,12 @@ JsirThrowStatementOp AstToJsir::VisitThrowStatement(mlir::OpBuilder &builder, co return CreateStmt(builder, node, mlir_argument); } -JshirCatchClauseOp AstToJsir::VisitCatchClause(mlir::OpBuilder &builder, const JsCatchClause *node) { +JsirCatchClauseOp AstToJsir::VisitCatchClause(mlir::OpBuilder &builder, const JsCatchClause *node) { mlir::Value mlir_param; if (node->param().has_value()) { mlir_param = VisitPatternRef(builder, node->param().value()); } - auto op = CreateStmt(builder, node, mlir_param); + auto op = CreateStmt(builder, node, mlir_param); mlir::Region &mlir_body_region = op.getBody(); AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { VisitBlockStatement(builder, node->body()); @@ -597,8 +597,8 @@ JshirCatchClauseOp AstToJsir::VisitCatchClause(mlir::OpBuilder &builder, const J return op; } -JshirTryStatementOp AstToJsir::VisitTryStatement(mlir::OpBuilder &builder, const JsTryStatement *node) { - auto op = CreateStmt(builder, node); +JsirTryStatementOp AstToJsir::VisitTryStatement(mlir::OpBuilder &builder, const JsTryStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_block_region = op.getBlock(); AppendNewBlockAndPopulate(builder, mlir_block_region, [&] { VisitBlockStatement(builder, node->block()); @@ -618,8 +618,8 @@ JshirTryStatementOp AstToJsir::VisitTryStatement(mlir::OpBuilder &builder, const return op; } -JshirWhileStatementOp AstToJsir::VisitWhileStatement(mlir::OpBuilder &builder, const JsWhileStatement *node) { - auto op = CreateStmt(builder, node); +JsirWhileStatementOp AstToJsir::VisitWhileStatement(mlir::OpBuilder &builder, const JsWhileStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_test_region = op.getTest(); AppendNewBlockAndPopulate(builder, mlir_test_region, [&] { mlir::Value mlir_test = VisitExpression(builder, node->test()); @@ -632,8 +632,8 @@ JshirWhileStatementOp AstToJsir::VisitWhileStatement(mlir::OpBuilder &builder, c return op; } -JshirDoWhileStatementOp AstToJsir::VisitDoWhileStatement(mlir::OpBuilder &builder, const JsDoWhileStatement *node) { - auto op = CreateStmt(builder, node); +JsirDoWhileStatementOp AstToJsir::VisitDoWhileStatement(mlir::OpBuilder &builder, const JsDoWhileStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_body_region = op.getBody(); AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { VisitStatement(builder, node->body()); @@ -830,10 +830,10 @@ JsirAssignmentExpressionOp AstToJsir::VisitAssignmentExpression(mlir::OpBuilder return CreateExpr(builder, node, mlir_operator, mlir_left, mlir_right); } -JshirLogicalExpressionOp AstToJsir::VisitLogicalExpression(mlir::OpBuilder &builder, const JsLogicalExpression *node) { +JsirLogicalExpressionOp AstToJsir::VisitLogicalExpression(mlir::OpBuilder &builder, const JsLogicalExpression *node) { mlir::StringAttr mlir_operator = builder.getStringAttr(JsLogicalOperatorToString(node->operator_())); mlir::Value mlir_left = VisitExpression(builder, node->left()); - auto op = CreateExpr(builder, node, mlir_operator, mlir_left); + auto op = CreateExpr(builder, node, mlir_operator, mlir_left); mlir::Region &mlir_right_region = op.getRight(); AppendNewBlockAndPopulate(builder, mlir_right_region, [&] { mlir::Value mlir_right = VisitExpression(builder, node->right()); @@ -842,9 +842,9 @@ JshirLogicalExpressionOp AstToJsir::VisitLogicalExpression(mlir::OpBuilder &buil return op; } -JshirConditionalExpressionOp AstToJsir::VisitConditionalExpression(mlir::OpBuilder &builder, const JsConditionalExpression *node) { +JsirConditionalExpressionOp AstToJsir::VisitConditionalExpression(mlir::OpBuilder &builder, const JsConditionalExpression *node) { mlir::Value mlir_test = VisitExpression(builder, node->test()); - auto op = CreateExpr(builder, node, mlir_test); + auto op = CreateExpr(builder, node, mlir_test); mlir::Region &mlir_alternate_region = op.getAlternate(); AppendNewBlockAndPopulate(builder, mlir_alternate_region, [&] { mlir::Value mlir_alternate = VisitExpression(builder, node->alternate()); diff --git a/maldoca/js/ir/conversion/ast_to_jsir.h b/maldoca/js/ir/conversion/ast_to_jsir.h index d2e34a6f..dbaf56d2 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.h +++ b/maldoca/js/ir/conversion/ast_to_jsir.h @@ -44,9 +44,6 @@ class AstToJsir { // // static JshirBlockStatementOp VisitBlockStatement(mlir::OpBuilder &builder, // const JsBlockStatement *node); -#define DECLARE_HIR_OP_VISIT_FUNCTION(TYPE) \ - static Jshir##TYPE##Op Visit##TYPE(mlir::OpBuilder& builder, \ - const Js##TYPE* node); // Example: // @@ -65,13 +62,13 @@ class AstToJsir { const Js##TYPE* node); FOR_EACH_JSIR_CLASS(DECLARE_CIR_OP_VISIT_FUNCTION, - DECLARE_HIR_OP_VISIT_FUNCTION, + DECLARE_CIR_OP_VISIT_FUNCTION, DECLARE_REF_OP_VISIT_FUNCTION, DECLARE_ATTRIB_VISIT_FUNCTION) #undef DECLARE_CIR_OP_VISIT_FUNCTION #undef DECLARE_REF_OP_VISIT_FUNCTION -#undef DECLARE_HIR_OP_VISIT_FUNCTION + #undef DECLARE_ATTRIB_VISIT_FUNCTION static JsirProgramBodyElementOpInterface VisitProgramBodyElement( diff --git a/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc b/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc index 1f801e72..316c8097 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc +++ b/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc @@ -155,27 +155,27 @@ JsirBigIntLiteralAttr AstToJsir::VisitBigIntLiteralAttr( mlir_extra); } -JshirBreakStatementOp AstToJsir::VisitBreakStatement( +JsirBreakStatementOp AstToJsir::VisitBreakStatement( mlir::OpBuilder& builder, const JsBreakStatement* node) { JsirIdentifierAttr mlir_label; if (node->label().has_value()) { mlir_label = VisitIdentifierAttr(builder, node->label().value()); } - return CreateStmt(builder, node, mlir_label); + return CreateStmt(builder, node, mlir_label); } -JshirContinueStatementOp AstToJsir::VisitContinueStatement( +JsirContinueStatementOp AstToJsir::VisitContinueStatement( mlir::OpBuilder& builder, const JsContinueStatement* node) { JsirIdentifierAttr mlir_label; if (node->label().has_value()) { mlir_label = VisitIdentifierAttr(builder, node->label().value()); } - return CreateStmt(builder, node, mlir_label); + return CreateStmt(builder, node, mlir_label); } -JshirForStatementOp AstToJsir::VisitForStatement(mlir::OpBuilder& builder, - const JsForStatement* node) { - auto op = CreateStmt(builder, node); +JsirForStatementOp AstToJsir::VisitForStatement(mlir::OpBuilder& builder, + const JsForStatement* node) { + auto op = CreateStmt(builder, node); mlir::Region& init_region = op.getInit(); if (node->init().has_value()) { AppendNewBlockAndPopulate(builder, init_region, [&] { @@ -251,7 +251,7 @@ static absl::StatusOr GetForInOfLeft( }; } -JshirForInStatementOp AstToJsir::VisitForInStatement( +JsirForInStatementOp AstToJsir::VisitForInStatement( mlir::OpBuilder& builder, const JsForInStatement* node) { auto left = GetForInOfLeft(builder.getContext(), node->left()); if (!left.ok()) { @@ -264,7 +264,7 @@ JshirForInStatementOp AstToJsir::VisitForInStatement( mlir::Value mlir_right = VisitExpression(builder, node->right()); - auto op = CreateStmt( + auto op = CreateStmt( builder, node, left->declaration_attr.value_or(nullptr), mlir_left, mlir_right); @@ -274,7 +274,7 @@ JshirForInStatementOp AstToJsir::VisitForInStatement( return op; } -JshirForOfStatementOp AstToJsir::VisitForOfStatement( +JsirForOfStatementOp AstToJsir::VisitForOfStatement( mlir::OpBuilder& builder, const JsForOfStatement* node) { auto left = GetForInOfLeft(builder.getContext(), node->left()); if (!left.ok()) { @@ -289,7 +289,7 @@ JshirForOfStatementOp AstToJsir::VisitForOfStatement( mlir::Value mlir_right = VisitExpression(builder, node->right()); - auto op = CreateStmt( + auto op = CreateStmt( builder, node, left->declaration_attr.value_or(nullptr), mlir_left, mlir_right, mlir_await); diff --git a/maldoca/js/ir/conversion/jsir_to_ast.generated.cc b/maldoca/js/ir/conversion/jsir_to_ast.generated.cc index f59b2ce8..071753f0 100644 --- a/maldoca/js/ir/conversion/jsir_to_ast.generated.cc +++ b/maldoca/js/ir/conversion/jsir_to_ast.generated.cc @@ -62,7 +62,7 @@ JsirToAst::VisitProgramBodyElement(JsirProgramBodyElementOpInterface op) { .Case([&](JsirExpressionStatementOp op) { return VisitExpressionStatement(op); }) - .Case([&](JshirBlockStatementOp op) { + .Case([&](JsirBlockStatementOp op) { return VisitBlockStatement(op); }) .Case([&](JsirEmptyStatementOp op) { @@ -71,46 +71,46 @@ JsirToAst::VisitProgramBodyElement(JsirProgramBodyElementOpInterface op) { .Case([&](JsirDebuggerStatementOp op) { return VisitDebuggerStatement(op); }) - .Case([&](JshirWithStatementOp op) { + .Case([&](JsirWithStatementOp op) { return VisitWithStatement(op); }) .Case([&](JsirReturnStatementOp op) { return VisitReturnStatement(op); }) - .Case([&](JshirLabeledStatementOp op) { + .Case([&](JsirLabeledStatementOp op) { return VisitLabeledStatement(op); }) - .Case([&](JshirBreakStatementOp op) { + .Case([&](JsirBreakStatementOp op) { return VisitBreakStatement(op); }) - .Case([&](JshirContinueStatementOp op) { + .Case([&](JsirContinueStatementOp op) { return VisitContinueStatement(op); }) - .Case([&](JshirIfStatementOp op) { + .Case([&](JsirIfStatementOp op) { return VisitIfStatement(op); }) - .Case([&](JshirSwitchStatementOp op) { + .Case([&](JsirSwitchStatementOp op) { return VisitSwitchStatement(op); }) .Case([&](JsirThrowStatementOp op) { return VisitThrowStatement(op); }) - .Case([&](JshirTryStatementOp op) { + .Case([&](JsirTryStatementOp op) { return VisitTryStatement(op); }) - .Case([&](JshirWhileStatementOp op) { + .Case([&](JsirWhileStatementOp op) { return VisitWhileStatement(op); }) - .Case([&](JshirDoWhileStatementOp op) { + .Case([&](JsirDoWhileStatementOp op) { return VisitDoWhileStatement(op); }) - .Case([&](JshirForStatementOp op) { + .Case([&](JsirForStatementOp op) { return VisitForStatement(op); }) - .Case([&](JshirForInStatementOp op) { + .Case([&](JsirForInStatementOp op) { return VisitForInStatement(op); }) - .Case([&](JshirForOfStatementOp op) { + .Case([&](JsirForOfStatementOp op) { return VisitForOfStatement(op); }) .Case([&](JsirFunctionDeclarationOp op) { @@ -311,7 +311,7 @@ JsirToAst::VisitExpression(JsirExpressionOpInterface op) { .Case([&](JsirAssignmentExpressionOp op) { return VisitAssignmentExpression(op); }) - .Case([&](JshirLogicalExpressionOp op) { + .Case([&](JsirLogicalExpressionOp op) { return VisitLogicalExpression(op); }) .Case([&](JsirMemberExpressionOp op) { @@ -320,7 +320,7 @@ JsirToAst::VisitExpression(JsirExpressionOpInterface op) { .Case([&](JsirOptionalMemberExpressionOp op) { return VisitOptionalMemberExpression(op); }) - .Case([&](JshirConditionalExpressionOp op) { + .Case([&](JsirConditionalExpressionOp op) { return VisitConditionalExpression(op); }) .Case([&](JsirCallExpressionOp op) { @@ -615,7 +615,7 @@ JsirToAst::VisitStatement(JsirStatementOpInterface op) { .Case([&](JsirExpressionStatementOp op) { return VisitExpressionStatement(op); }) - .Case([&](JshirBlockStatementOp op) { + .Case([&](JsirBlockStatementOp op) { return VisitBlockStatement(op); }) .Case([&](JsirEmptyStatementOp op) { @@ -624,46 +624,46 @@ JsirToAst::VisitStatement(JsirStatementOpInterface op) { .Case([&](JsirDebuggerStatementOp op) { return VisitDebuggerStatement(op); }) - .Case([&](JshirWithStatementOp op) { + .Case([&](JsirWithStatementOp op) { return VisitWithStatement(op); }) .Case([&](JsirReturnStatementOp op) { return VisitReturnStatement(op); }) - .Case([&](JshirLabeledStatementOp op) { + .Case([&](JsirLabeledStatementOp op) { return VisitLabeledStatement(op); }) - .Case([&](JshirBreakStatementOp op) { + .Case([&](JsirBreakStatementOp op) { return VisitBreakStatement(op); }) - .Case([&](JshirContinueStatementOp op) { + .Case([&](JsirContinueStatementOp op) { return VisitContinueStatement(op); }) - .Case([&](JshirIfStatementOp op) { + .Case([&](JsirIfStatementOp op) { return VisitIfStatement(op); }) - .Case([&](JshirSwitchStatementOp op) { + .Case([&](JsirSwitchStatementOp op) { return VisitSwitchStatement(op); }) .Case([&](JsirThrowStatementOp op) { return VisitThrowStatement(op); }) - .Case([&](JshirTryStatementOp op) { + .Case([&](JsirTryStatementOp op) { return VisitTryStatement(op); }) - .Case([&](JshirWhileStatementOp op) { + .Case([&](JsirWhileStatementOp op) { return VisitWhileStatement(op); }) - .Case([&](JshirDoWhileStatementOp op) { + .Case([&](JsirDoWhileStatementOp op) { return VisitDoWhileStatement(op); }) - .Case([&](JshirForStatementOp op) { + .Case([&](JsirForStatementOp op) { return VisitForStatement(op); }) - .Case([&](JshirForInStatementOp op) { + .Case([&](JsirForInStatementOp op) { return VisitForInStatement(op); }) - .Case([&](JshirForOfStatementOp op) { + .Case([&](JsirForOfStatementOp op) { return VisitForOfStatement(op); }) .Case([&](JsirFunctionDeclarationOp op) { @@ -681,7 +681,7 @@ JsirToAst::VisitStatement(JsirStatementOpInterface op) { } absl::StatusOr> -JsirToAst::VisitBlockStatement(JshirBlockStatementOp op) { +JsirToAst::VisitBlockStatement(JsirBlockStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto body, Convert( @@ -737,7 +737,7 @@ JsirToAst::VisitDebuggerStatement(JsirDebuggerStatementOp op) { } absl::StatusOr> -JsirToAst::VisitWithStatement(JshirWithStatementOp op) { +JsirToAst::VisitWithStatement(JsirWithStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto object, Convert( @@ -777,7 +777,7 @@ JsirToAst::VisitReturnStatement(JsirReturnStatementOp op) { } absl::StatusOr> -JsirToAst::VisitLabeledStatement(JshirLabeledStatementOp op) { +JsirToAst::VisitLabeledStatement(JsirLabeledStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto label, Convert( @@ -801,7 +801,7 @@ JsirToAst::VisitLabeledStatement(JshirLabeledStatementOp op) { } absl::StatusOr> -JsirToAst::VisitIfStatement(JshirIfStatementOp op) { +JsirToAst::VisitIfStatement(JsirIfStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto test, Convert( @@ -837,7 +837,7 @@ JsirToAst::VisitIfStatement(JshirIfStatementOp op) { } absl::StatusOr> -JsirToAst::VisitSwitchCase(JshirSwitchCaseOp op) { +JsirToAst::VisitSwitchCase(JsirSwitchCaseOp op) { ABSL_ASSIGN_OR_RETURN( auto test, Convert( @@ -867,7 +867,7 @@ JsirToAst::VisitSwitchCase(JshirSwitchCaseOp op) { } absl::StatusOr> -JsirToAst::VisitSwitchStatement(JshirSwitchStatementOp op) { +JsirToAst::VisitSwitchStatement(JsirSwitchStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto discriminant, Convert( @@ -907,7 +907,7 @@ JsirToAst::VisitThrowStatement(JsirThrowStatementOp op) { } absl::StatusOr> -JsirToAst::VisitCatchClause(JshirCatchClauseOp op) { +JsirToAst::VisitCatchClause(JsirCatchClauseOp op) { ABSL_ASSIGN_OR_RETURN( auto param, Convert( @@ -933,7 +933,7 @@ JsirToAst::VisitCatchClause(JshirCatchClauseOp op) { } absl::StatusOr> -JsirToAst::VisitTryStatement(JshirTryStatementOp op) { +JsirToAst::VisitTryStatement(JsirTryStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto block, Convert( @@ -973,7 +973,7 @@ JsirToAst::VisitTryStatement(JshirTryStatementOp op) { } absl::StatusOr> -JsirToAst::VisitWhileStatement(JshirWhileStatementOp op) { +JsirToAst::VisitWhileStatement(JsirWhileStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto test, Convert( @@ -999,7 +999,7 @@ JsirToAst::VisitWhileStatement(JshirWhileStatementOp op) { } absl::StatusOr> -JsirToAst::VisitDoWhileStatement(JshirDoWhileStatementOp op) { +JsirToAst::VisitDoWhileStatement(JsirDoWhileStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto body, Convert( @@ -1417,7 +1417,7 @@ JsirToAst::VisitAssignmentExpression(JsirAssignmentExpressionOp op) { } absl::StatusOr> -JsirToAst::VisitLogicalExpression(JshirLogicalExpressionOp op) { +JsirToAst::VisitLogicalExpression(JsirLogicalExpressionOp op) { ABSL_ASSIGN_OR_RETURN( auto operator_, Convert( @@ -1449,7 +1449,7 @@ JsirToAst::VisitLogicalExpression(JshirLogicalExpressionOp op) { } absl::StatusOr> -JsirToAst::VisitConditionalExpression(JshirConditionalExpressionOp op) { +JsirToAst::VisitConditionalExpression(JsirConditionalExpressionOp op) { ABSL_ASSIGN_OR_RETURN( auto test, Convert( diff --git a/maldoca/js/ir/conversion/jsir_to_ast.h b/maldoca/js/ir/conversion/jsir_to_ast.h index 710b66ef..e705f3d6 100644 --- a/maldoca/js/ir/conversion/jsir_to_ast.h +++ b/maldoca/js/ir/conversion/jsir_to_ast.h @@ -55,14 +55,6 @@ class JsirToAst { static absl::StatusOr> Visit##TYPE( \ Jsir##TYPE##Op op); -// Example: -// -// absl::StatusOr> -// VisitBlockStatement(JshirBlockStatementOp op); -#define DECLARE_HIR_OP_VISIT_FUNCTION(TYPE) \ - static absl::StatusOr> Visit##TYPE( \ - Jshir##TYPE##Op op); - // Example: // // absl::StatusOr> @@ -80,13 +72,13 @@ class JsirToAst { Jsir##TYPE##Attr attr); FOR_EACH_JSIR_CLASS(DECLARE_CIR_OP_VISIT_FUNCTION, - DECLARE_HIR_OP_VISIT_FUNCTION, + DECLARE_CIR_OP_VISIT_FUNCTION, DECLARE_REF_OP_VISIT_FUNCTION, DECLARE_ATTRIB_VISIT_FUNCTION) #undef DECLARE_CIR_OP_VISIT_FUNCTION #undef DECLARE_REF_OP_VISIT_FUNCTION -#undef DECLARE_HIR_OP_VISIT_FUNCTION + #undef DECLARE_ATTRIB_VISIT_FUNCTION static absl::StatusOr> diff --git a/maldoca/js/ir/conversion/jsir_to_ast.handwritten.cc b/maldoca/js/ir/conversion/jsir_to_ast.handwritten.cc index 977bf50f..cd2949ab 100644 --- a/maldoca/js/ir/conversion/jsir_to_ast.handwritten.cc +++ b/maldoca/js/ir/conversion/jsir_to_ast.handwritten.cc @@ -110,7 +110,7 @@ JsirToAst::VisitBigIntLiteralAttr(JsirBigIntLiteralAttr attr) { } absl::StatusOr> -JsirToAst::VisitBreakStatement(JshirBreakStatementOp op) { +JsirToAst::VisitBreakStatement(JsirBreakStatementOp op) { std::optional> label; if (op.getLabel().has_value()) { ABSL_ASSIGN_OR_RETURN(label, VisitIdentifierAttr(op.getLabel().value())); @@ -119,7 +119,7 @@ JsirToAst::VisitBreakStatement(JshirBreakStatementOp op) { } absl::StatusOr> -JsirToAst::VisitContinueStatement(JshirContinueStatementOp op) { +JsirToAst::VisitContinueStatement(JsirContinueStatementOp op) { std::optional> label; if (op.getLabel().has_value()) { ABSL_ASSIGN_OR_RETURN(label, VisitIdentifierAttr(op.getLabel().value())); @@ -128,7 +128,7 @@ JsirToAst::VisitContinueStatement(JshirContinueStatementOp op) { } absl::StatusOr> JsirToAst::VisitForStatement( - maldoca::JshirForStatementOp op) { + maldoca::JsirForStatementOp op) { std::optional, std::unique_ptr>> init; @@ -193,7 +193,7 @@ JsirToAst::VisitForInOfStatement( } absl::StatusOr> -JsirToAst::VisitForInStatement(JshirForInStatementOp op) { +JsirToAst::VisitForInStatement(JsirForInStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto fields, VisitForInOfStatement(op.getLeftDeclaration(), op.getLeftLval(), @@ -204,7 +204,7 @@ JsirToAst::VisitForInStatement(JshirForInStatementOp op) { } absl::StatusOr> -JsirToAst::VisitForOfStatement(JshirForOfStatementOp op) { +JsirToAst::VisitForOfStatement(JsirForOfStatementOp op) { ABSL_ASSIGN_OR_RETURN( auto fields, VisitForInOfStatement(op.getLeftDeclaration(), op.getLeftLval(), diff --git a/maldoca/js/ir/conversion/tests/BUILD.template.bzl b/maldoca/js/ir/conversion/tests/BUILD.template.bzl index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/BUILD.template.bzl +++ b/maldoca/js/ir/conversion/tests/BUILD.template.bzl @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/array_expression/BUILD b/maldoca/js/ir/conversion/tests/array_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/array_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/array_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/array_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/array_expression/jshir.mlir deleted file mode 100644 index ba793456..00000000 --- a/maldoca/js/ir/conversion/tests/array_expression/jshir.mlir +++ /dev/null @@ -1,13 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.none"() : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.spread_element"(%3) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.array_expression"(%0, %1, %2, %4) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/array_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/array_expression/jsir.mlir new file mode 100644 index 00000000..b32bb24a --- /dev/null +++ b/maldoca/js/ir/conversion/tests/array_expression/jsir.mlir @@ -0,0 +1,13 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.none"() : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.spread_element"(%3) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %5 = "jsir.array_expression"(%0, %1, %2, %4) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/array_expression/run.lit b/maldoca/js/ir/conversion/tests/array_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/array_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/array_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/array_pattern/BUILD b/maldoca/js/ir/conversion/tests/array_pattern/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/array_pattern/BUILD +++ b/maldoca/js/ir/conversion/tests/array_pattern/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/array_pattern/jshir.mlir b/maldoca/js/ir/conversion/tests/array_pattern/jshir.mlir deleted file mode 100644 index 2b600e78..00000000 --- a/maldoca/js/ir/conversion/tests/array_pattern/jshir.mlir +++ /dev/null @@ -1,15 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.none"() : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.array_pattern_ref"(%0, %1, %2) : (!jsir.any, !jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/array_pattern/jsir.mlir b/maldoca/js/ir/conversion/tests/array_pattern/jsir.mlir new file mode 100644 index 00000000..bee211e0 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/array_pattern/jsir.mlir @@ -0,0 +1,15 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.none"() : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.array_pattern_ref"(%0, %1, %2) : (!jsir.any, !jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/array_pattern/run.lit b/maldoca/js/ir/conversion/tests/array_pattern/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/array_pattern/run.lit +++ b/maldoca/js/ir/conversion/tests/array_pattern/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD b/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/arrow_function_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/arrow_function_expression/jshir.mlir deleted file mode 100644 index 4970597f..00000000 --- a/maldoca/js/ir/conversion/tests/arrow_function_expression/jshir.mlir +++ /dev/null @@ -1,22 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.arrow_function_expression"(%0) <{async = false, generator = false, operandSegmentSizes = array}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.arrow_function_expression"(%2) <{async = false, generator = false, operandSegmentSizes = array}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/arrow_function_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/arrow_function_expression/jsir.mlir new file mode 100644 index 00000000..47ad8168 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/arrow_function_expression/jsir.mlir @@ -0,0 +1,22 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.arrow_function_expression"(%0) <{async = false, generator = false, operandSegmentSizes = array}> ({ +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "x"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.arrow_function_expression"(%2) <{async = false, generator = false, operandSegmentSizes = array}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "y"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/arrow_function_expression/run.lit b/maldoca/js/ir/conversion/tests/arrow_function_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/arrow_function_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/arrow_function_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/binary_expression/BUILD b/maldoca/js/ir/conversion/tests/binary_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/binary_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/binary_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/binary_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/binary_expression/jshir.mlir deleted file mode 100644 index ca61bd1d..00000000 --- a/maldoca/js/ir/conversion/tests/binary_expression/jshir.mlir +++ /dev/null @@ -1,12 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/binary_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/binary_expression/jsir.mlir new file mode 100644 index 00000000..ac55f88f --- /dev/null +++ b/maldoca/js/ir/conversion/tests/binary_expression/jsir.mlir @@ -0,0 +1,12 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.binary_expression"(%0, %1) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.binary_expression"(%2, %3) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/binary_expression/run.lit b/maldoca/js/ir/conversion/tests/binary_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/binary_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/binary_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/block_statement/BUILD b/maldoca/js/ir/conversion/tests/block_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/block_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/block_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/block_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/block_statement/jshir.mlir deleted file mode 100644 index bfb12580..00000000 --- a/maldoca/js/ir/conversion/tests/block_statement/jshir.mlir +++ /dev/null @@ -1,14 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/block_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/block_statement/jsir.mlir new file mode 100644 index 00000000..cc751493 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/block_statement/jsir.mlir @@ -0,0 +1,14 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/block_statement/run.lit b/maldoca/js/ir/conversion/tests/block_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/block_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/block_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/break/BUILD b/maldoca/js/ir/conversion/tests/break/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/break/BUILD +++ b/maldoca/js/ir/conversion/tests/break/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/break/jshir.mlir b/maldoca/js/ir/conversion/tests/break/jshir.mlir deleted file mode 100644 index ffb61390..00000000 --- a/maldoca/js/ir/conversion/tests/break/jshir.mlir +++ /dev/null @@ -1,50 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 80, " =============================================================================">, #jsir, , 81, 112, " Breaking out of a while loop">, #jsir, , 113, 193, " =============================================================================">, #jsir, , 235, 315, " =============================================================================">, #jsir, , 316, 352, " Breaking out of second while loop">, #jsir, , 353, 433, " =============================================================================">, #jsir, , 514, 594, " =============================================================================">, #jsir, , 595, 630, " Breaking immediately after label">, #jsir, , 631, 711, " =============================================================================">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%1) ({ -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label0", 435, 441, 0, "label0">}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label1", 462, 468, 4, "label1">}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%1) ({ -// JSHIR-NEXT: "jshir.break_statement"() <{label = #jsir, , "label0", 503, 509, 5, "label0">}> : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label", 713, 718, 0, "label">}> ({ -// JSHIR-NEXT: "jshir.break_statement"() <{label = #jsir, , "label", 726, 731, 0, "label">}> : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/break/jsir.mlir b/maldoca/js/ir/conversion/tests/break/jsir.mlir new file mode 100644 index 00000000..abe3e9b0 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/break/jsir.mlir @@ -0,0 +1,50 @@ +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 80, " =============================================================================">, #jsir, , 81, 112, " Breaking out of a while loop">, #jsir, , 113, 193, " =============================================================================">, #jsir, , 235, 315, " =============================================================================">, #jsir, , 316, 352, " Breaking out of second while loop">, #jsir, , 353, 433, " =============================================================================">, #jsir, , 514, 594, " =============================================================================">, #jsir, , 595, 630, " Breaking immediately after label">, #jsir, , 631, 711, " =============================================================================">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%1) ({ +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label0", 435, 441, 0, "label0">}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label1", 462, 468, 4, "label1">}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%1) ({ +// JSIR-NEXT: "jsir.break_statement"() <{label = #jsir, , "label0", 503, 509, 5, "label0">}> : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label", 713, 718, 0, "label">}> ({ +// JSIR-NEXT: "jsir.break_statement"() <{label = #jsir, , "label", 726, 731, 0, "label">}> : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/break/run.lit b/maldoca/js/ir/conversion/tests/break/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/break/run.lit +++ b/maldoca/js/ir/conversion/tests/break/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/call_expression/BUILD b/maldoca/js/ir/conversion/tests/call_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/call_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/call_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/call_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/call_expression/jshir.mlir deleted file mode 100644 index 4fc0b2ea..00000000 --- a/maldoca/js/ir/conversion/tests/call_expression/jshir.mlir +++ /dev/null @@ -1,16 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "foo"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.call_expression"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "bar"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.spread_element"(%5) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.call_expression"(%2, %3, %4, %6) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/call_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/call_expression/jsir.mlir new file mode 100644 index 00000000..d63193ad --- /dev/null +++ b/maldoca/js/ir/conversion/tests/call_expression/jsir.mlir @@ -0,0 +1,16 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "foo"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.call_expression"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "bar"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.spread_element"(%5) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %7 = "jsir.call_expression"(%2, %3, %4, %6) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/call_expression/run.lit b/maldoca/js/ir/conversion/tests/call_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/call_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/call_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/class_declaration/BUILD b/maldoca/js/ir/conversion/tests/class_declaration/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/class_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/class_declaration/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/class_declaration/jshir.mlir b/maldoca/js/ir/conversion/tests/class_declaration/jshir.mlir deleted file mode 100644 index cb3c622d..00000000 --- a/maldoca/js/ir/conversion/tests/class_declaration/jshir.mlir +++ /dev/null @@ -1,67 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.class_declaration"() <{id = #jsir, , "Foo", 6, 9, 1, "Foo">}> ({ -// JSHIR-NEXT: "jsir.class_body"() ({ -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , "property_identifier", 14, 33, 1, "property_identifier">, static_ = false}> ({ -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_private_property"() <{key = #jsir, , 41, 63, 1, , , "property_private_name", 42, 63, 1, "property_private_name">, static_ = false}> ({ -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 71, 96, 1, "property_literal_string", "\22property_literal_string\22", "property_literal_string">, static_ = false}> ({ -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 104, 107, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, static_ = false}> ({ -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %0 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.class_property"(%0) <{static_ = false}> ({ -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 144, 161, 1, "method_identifier">, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_private_method"() <{async = false, generator = false, key = #jsir, , 169, 189, 1, , , "method_private_name", 170, 189, 1, "method_private_name">, kind = "method", static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 197, 220, 1, "method_literal_string", "\22method_literal_string\22", "method_literal_string">, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 228, 231, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %1 = "jsir.string_literal"() <{extra = #jsir, value = "method_computed"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.class_method"(%1) <{async = false, generator = false, kind = "method", operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/class_declaration/jsir.mlir b/maldoca/js/ir/conversion/tests/class_declaration/jsir.mlir new file mode 100644 index 00000000..9b72fa4b --- /dev/null +++ b/maldoca/js/ir/conversion/tests/class_declaration/jsir.mlir @@ -0,0 +1,67 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.class_declaration"() <{id = #jsir, , "Foo", 6, 9, 1, "Foo">}> ({ +// JSIR-NEXT: "jsir.class_body"() ({ +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , "property_identifier", 14, 33, 1, "property_identifier">, static_ = false}> ({ +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_private_property"() <{key = #jsir, , 41, 63, 1, , , "property_private_name", 42, 63, 1, "property_private_name">, static_ = false}> ({ +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 71, 96, 1, "property_literal_string", "\22property_literal_string\22", "property_literal_string">, static_ = false}> ({ +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 104, 107, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, static_ = false}> ({ +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %0 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.class_property"(%0) <{static_ = false}> ({ +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 144, 161, 1, "method_identifier">, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_private_method"() <{async = false, generator = false, key = #jsir, , 169, 189, 1, , , "method_private_name", 170, 189, 1, "method_private_name">, kind = "method", static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 197, 220, 1, "method_literal_string", "\22method_literal_string\22", "method_literal_string">, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 228, 231, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %1 = "jsir.string_literal"() <{extra = #jsir, value = "method_computed"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.class_method"(%1) <{async = false, generator = false, kind = "method", operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/class_declaration/run.lit b/maldoca/js/ir/conversion/tests/class_declaration/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/class_declaration/run.lit +++ b/maldoca/js/ir/conversion/tests/class_declaration/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/class_expression/BUILD b/maldoca/js/ir/conversion/tests/class_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/class_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/class_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/class_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/class_expression/jshir.mlir deleted file mode 100644 index d64ce5dd..00000000 --- a/maldoca/js/ir/conversion/tests/class_expression/jshir.mlir +++ /dev/null @@ -1,69 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.class_expression"() ({ -// JSHIR-NEXT: "jsir.class_body"() ({ -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , "property_identifier", 11, 30, 1, "property_identifier">, static_ = false}> ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_private_property"() <{key = #jsir, , 38, 60, 1, , , "property_private_name", 39, 60, 1, "property_private_name">, static_ = false}> ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 68, 93, 1, "property_literal_string", "\22property_literal_string\22", "property_literal_string">, static_ = false}> ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 101, 104, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, static_ = false}> ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.class_property"(%2) <{static_ = false}> ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 141, 158, 1, "method_identifier">, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_private_method"() <{async = false, generator = false, key = #jsir, , 166, 186, 1, , , "method_private_name", 167, 186, 1, "method_private_name">, kind = "method", static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 194, 217, 1, "method_literal_string", "\22method_literal_string\22", "method_literal_string">, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 225, 228, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: %3 = "jsir.string_literal"() <{extra = #jsir, value = "method_computed"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.class_method"(%3) <{async = false, generator = false, kind = "method", operandSegmentSizes = array, static_ = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.parenthesized_expression"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/class_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/class_expression/jsir.mlir new file mode 100644 index 00000000..40f07d96 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/class_expression/jsir.mlir @@ -0,0 +1,69 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.class_expression"() ({ +// JSIR-NEXT: "jsir.class_body"() ({ +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , "property_identifier", 11, 30, 1, "property_identifier">, static_ = false}> ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_private_property"() <{key = #jsir, , 38, 60, 1, , , "property_private_name", 39, 60, 1, "property_private_name">, static_ = false}> ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 68, 93, 1, "property_literal_string", "\22property_literal_string\22", "property_literal_string">, static_ = false}> ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_property"() <{literal_key = #jsir, , 101, 104, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, static_ = false}> ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.class_property"(%2) <{static_ = false}> ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 5.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 141, 158, 1, "method_identifier">, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_private_method"() <{async = false, generator = false, key = #jsir, , 166, 186, 1, , , "method_private_name", 167, 186, 1, "method_private_name">, kind = "method", static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 194, 217, 1, "method_literal_string", "\22method_literal_string\22", "method_literal_string">, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.class_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 225, 228, 1, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: %3 = "jsir.string_literal"() <{extra = #jsir, value = "method_computed"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.class_method"(%3) <{async = false, generator = false, kind = "method", operandSegmentSizes = array, static_ = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.parenthesized_expression"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/class_expression/run.lit b/maldoca/js/ir/conversion/tests/class_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/class_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/class_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/comment/BUILD b/maldoca/js/ir/conversion/tests/comment/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/comment/BUILD +++ b/maldoca/js/ir/conversion/tests/comment/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/comment/jshir.mlir b/maldoca/js/ir/conversion/tests/comment/jshir.mlir deleted file mode 100644 index 5cf9a7ca..00000000 --- a/maldoca/js/ir/conversion/tests/comment/jshir.mlir +++ /dev/null @@ -1,10 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 4, " 1">, #jsir, , 8, 12, " 2">, #jsir, , 15, 22, " 3 ">, #jsir, , 24, 28, " 4">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/comment/jsir.mlir b/maldoca/js/ir/conversion/tests/comment/jsir.mlir new file mode 100644 index 00000000..0df66e38 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/comment/jsir.mlir @@ -0,0 +1,10 @@ +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 4, " 1">, #jsir, , 8, 12, " 2">, #jsir, , 15, 22, " 3 ">, #jsir, , 24, 28, " 4">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/comment/run.lit b/maldoca/js/ir/conversion/tests/comment/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/comment/run.lit +++ b/maldoca/js/ir/conversion/tests/comment/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/conditional_expression/BUILD b/maldoca/js/ir/conversion/tests/conditional_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/conditional_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/conditional_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/conditional_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/conditional_expression/jshir.mlir deleted file mode 100644 index 25572e41..00000000 --- a/maldoca/js/ir/conversion/tests/conditional_expression/jshir.mlir +++ /dev/null @@ -1,15 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jshir.conditional_expression"(%0) ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/conditional_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/conditional_expression/jsir.mlir new file mode 100644 index 00000000..143a26e4 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/conditional_expression/jsir.mlir @@ -0,0 +1,15 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.conditional_expression"(%0) ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/conditional_expression/run.lit b/maldoca/js/ir/conversion/tests/conditional_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/conditional_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/conditional_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/continue_statement/BUILD b/maldoca/js/ir/conversion/tests/continue_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/continue_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/continue_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/continue_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/continue_statement/jshir.mlir deleted file mode 100644 index 05226061..00000000 --- a/maldoca/js/ir/conversion/tests/continue_statement/jshir.mlir +++ /dev/null @@ -1,47 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%0) ({ -// JSHIR-NEXT: "jshir.continue_statement"() : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label0", 43, 49, 0, "label0">}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label1", 70, 76, 4, "label1">}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%1) ({ -// JSHIR-NEXT: "jshir.continue_statement"() <{label = #jsir, , "label0", 114, 120, 5, "label0">}> : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/continue_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/continue_statement/jsir.mlir new file mode 100644 index 00000000..a95175c3 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/continue_statement/jsir.mlir @@ -0,0 +1,47 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%0) ({ +// JSIR-NEXT: "jsir.continue_statement"() : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label0", 43, 49, 0, "label0">}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label1", 70, 76, 4, "label1">}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%1) ({ +// JSIR-NEXT: "jsir.continue_statement"() <{label = #jsir, , "label0", 114, 120, 5, "label0">}> : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/continue_statement/run.lit b/maldoca/js/ir/conversion/tests/continue_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/continue_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/continue_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/debugger_statement/BUILD b/maldoca/js/ir/conversion/tests/debugger_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/debugger_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/debugger_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/debugger_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/debugger_statement/jshir.mlir deleted file mode 100644 index 38150377..00000000 --- a/maldoca/js/ir/conversion/tests/debugger_statement/jshir.mlir +++ /dev/null @@ -1,7 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.debugger_statement"() : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/debugger_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/debugger_statement/jsir.mlir new file mode 100644 index 00000000..8920c40a --- /dev/null +++ b/maldoca/js/ir/conversion/tests/debugger_statement/jsir.mlir @@ -0,0 +1,7 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.debugger_statement"() : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/debugger_statement/run.lit b/maldoca/js/ir/conversion/tests/debugger_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/debugger_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/debugger_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/directive_literal/BUILD b/maldoca/js/ir/conversion/tests/directive_literal/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/directive_literal/BUILD +++ b/maldoca/js/ir/conversion/tests/directive_literal/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/directive_literal/jshir.mlir b/maldoca/js/ir/conversion/tests/directive_literal/jshir.mlir deleted file mode 100644 index 5fc99488..00000000 --- a/maldoca/js/ir/conversion/tests/directive_literal/jshir.mlir +++ /dev/null @@ -1,8 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.directive_literal"() <{extra = #jsir, value = "use strict"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.directive"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/directive_literal/jsir.mlir b/maldoca/js/ir/conversion/tests/directive_literal/jsir.mlir new file mode 100644 index 00000000..8ef1849f --- /dev/null +++ b/maldoca/js/ir/conversion/tests/directive_literal/jsir.mlir @@ -0,0 +1,8 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.directive_literal"() <{extra = #jsir, value = "use strict"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.directive"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/directive_literal/run.lit b/maldoca/js/ir/conversion/tests/directive_literal/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/directive_literal/run.lit +++ b/maldoca/js/ir/conversion/tests/directive_literal/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/do_while_statement/BUILD b/maldoca/js/ir/conversion/tests/do_while_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/do_while_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/do_while_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/do_while_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/do_while_statement/jshir.mlir deleted file mode 100644 index d879b297..00000000 --- a/maldoca/js/ir/conversion/tests/do_while_statement/jshir.mlir +++ /dev/null @@ -1,24 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.do_while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.do_while_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/do_while_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/do_while_statement/jsir.mlir new file mode 100644 index 00000000..9c8a4df8 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/do_while_statement/jsir.mlir @@ -0,0 +1,24 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.do_while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.do_while_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/do_while_statement/run.lit b/maldoca/js/ir/conversion/tests/do_while_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/do_while_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/do_while_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/empty_statement/BUILD b/maldoca/js/ir/conversion/tests/empty_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/empty_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/empty_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/empty_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/empty_statement/jshir.mlir deleted file mode 100644 index 3c13eb44..00000000 --- a/maldoca/js/ir/conversion/tests/empty_statement/jshir.mlir +++ /dev/null @@ -1,7 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.empty_statement"() : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/empty_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/empty_statement/jsir.mlir new file mode 100644 index 00000000..8d814227 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/empty_statement/jsir.mlir @@ -0,0 +1,7 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.empty_statement"() : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/empty_statement/run.lit b/maldoca/js/ir/conversion/tests/empty_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/empty_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/empty_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/export_declaration/BUILD b/maldoca/js/ir/conversion/tests/export_declaration/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/export_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/export_declaration/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/export_declaration/jshir.mlir b/maldoca/js/ir/conversion/tests/export_declaration/jshir.mlir deleted file mode 100644 index 6d6fb80b..00000000 --- a/maldoca/js/ir/conversion/tests/export_declaration/jshir.mlir +++ /dev/null @@ -1,20 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 139, 175, " TODO(b/182441574): Fix AST error.">, #jsir, , 176, 215, " export * as identifier_3 from \22foo\22;">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ -// JSHIR-NEXT: "jsir.export_default_declaration"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "arbitrary_expression"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.export_named_declaration"() <{source = #jsir, , 83, 88, 0, "foo", "\22foo\22", "foo">, specifiers = [#jsir, , 46, 58, 0, #jsir, , "identifier_1", 46, 58, 0, "identifier_1">, #jsir, , "identifier_1", 46, 58, 0, "identifier_1">>, #jsir, , 60, 76, 0, #jsir, , 60, 76, 0, "string_literal", "\22string_literal\22", "string_literal">, #jsir, , 60, 76, 0, "string_literal", "\22string_literal\22", "string_literal">>]}> ({ -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.export_named_declaration"() <{specifiers = []}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "identifier_2"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.variable_declarator"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.export_all_declaration"() <{source = #jsir, , 131, 136, 0, "foo", "\22foo\22", "foo">}> : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/export_declaration/jsir.mlir b/maldoca/js/ir/conversion/tests/export_declaration/jsir.mlir new file mode 100644 index 00000000..960a91d2 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/export_declaration/jsir.mlir @@ -0,0 +1,20 @@ +// JSIR: "jsir.file"() <{comments = [#jsir, , 139, 175, " TODO(b/182441574): Fix AST error.">, #jsir, , 176, 215, " export * as identifier_3 from \22foo\22;">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ +// JSIR-NEXT: "jsir.export_default_declaration"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "arbitrary_expression"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.export_named_declaration"() <{source = #jsir, , 83, 88, 0, "foo", "\22foo\22", "foo">, specifiers = [#jsir, , 46, 58, 0, #jsir, , "identifier_1", 46, 58, 0, "identifier_1">, #jsir, , "identifier_1", 46, 58, 0, "identifier_1">>, #jsir, , 60, 76, 0, #jsir, , 60, 76, 0, "string_literal", "\22string_literal\22", "string_literal">, #jsir, , 60, 76, 0, "string_literal", "\22string_literal\22", "string_literal">>]}> ({ +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.export_named_declaration"() <{specifiers = []}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "identifier_2"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.variable_declarator"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.export_all_declaration"() <{source = #jsir, , 131, 136, 0, "foo", "\22foo\22", "foo">}> : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/export_declaration/run.lit b/maldoca/js/ir/conversion/tests/export_declaration/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/export_declaration/run.lit +++ b/maldoca/js/ir/conversion/tests/export_declaration/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/for_in_statement/BUILD b/maldoca/js/ir/conversion/tests/for_in_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/for_in_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_in_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/for_in_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/for_in_statement/jshir.mlir deleted file mode 100644 index 41e59611..00000000 --- a/maldoca/js/ir/conversion/tests/for_in_statement/jshir.mlir +++ /dev/null @@ -1,18 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_in_statement"(%0, %1) ({ -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_in_statement"(%2, %3) <{left_declaration = #jsir, , 24, 29, 2, , , 28, 29, 2, "a", 2, "let">}> ({ -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_in_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/for_in_statement/jsir.mlir new file mode 100644 index 00000000..802fd390 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/for_in_statement/jsir.mlir @@ -0,0 +1,18 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_in_statement"(%0, %1) ({ +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_in_statement"(%2, %3) <{left_declaration = #jsir, , 24, 29, 2, , , 28, 29, 2, "a", 2, "let">}> ({ +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_in_statement/run.lit b/maldoca/js/ir/conversion/tests/for_in_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/for_in_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/for_in_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/for_of_statement/BUILD b/maldoca/js/ir/conversion/tests/for_of_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/for_of_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_of_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/for_of_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/for_of_statement/jshir.mlir deleted file mode 100644 index 2cbfdc0a..00000000 --- a/maldoca/js/ir/conversion/tests/for_of_statement/jshir.mlir +++ /dev/null @@ -1,28 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_of_statement"(%0, %1) <{await = false}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_of_statement"(%2, %3) <{await = false, left_declaration = #jsir, , 24, 29, 2, , , 28, 29, 2, "a", 2, "let">}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.for_of_statement"(%4, %5) <{await = false}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_of_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/for_of_statement/jsir.mlir new file mode 100644 index 00000000..d3d5d45e --- /dev/null +++ b/maldoca/js/ir/conversion/tests/for_of_statement/jsir.mlir @@ -0,0 +1,28 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_of_statement"(%0, %1) <{await = false}> ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_of_statement"(%2, %3) <{await = false, left_declaration = #jsir, , 24, 29, 2, , , 28, 29, 2, "a", 2, "let">}> ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.for_of_statement"(%4, %5) <{await = false}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_of_statement/run.lit b/maldoca/js/ir/conversion/tests/for_of_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/for_of_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/for_of_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/for_statement/BUILD b/maldoca/js/ir/conversion/tests/for_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/for_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/for_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/for_statement/jshir.mlir deleted file mode 100644 index cd8d399b..00000000 --- a/maldoca/js/ir/conversion/tests/for_statement/jshir.mlir +++ /dev/null @@ -1,47 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.variable_declarator"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.for_statement"() ({ -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/for_statement/jsir.mlir new file mode 100644 index 00000000..b6f0286e --- /dev/null +++ b/maldoca/js/ir/conversion/tests/for_statement/jsir.mlir @@ -0,0 +1,47 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.variable_declarator"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.for_statement"() ({ +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/for_statement/run.lit b/maldoca/js/ir/conversion/tests/for_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/for_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/for_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/function_declaration/BUILD b/maldoca/js/ir/conversion/tests/function_declaration/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/function_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/function_declaration/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/function_declaration/jshir.mlir b/maldoca/js/ir/conversion/tests/function_declaration/jshir.mlir deleted file mode 100644 index 3ff6c5d8..00000000 --- a/maldoca/js/ir/conversion/tests/function_declaration/jshir.mlir +++ /dev/null @@ -1,31 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "foo", 9, 12, 1, "foo">}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "bar", 42, 45, 2, "bar">}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "some_computation"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.call_expression"(%1) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.assignment_pattern_ref"(%0, %2) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/function_declaration/jsir.mlir b/maldoca/js/ir/conversion/tests/function_declaration/jsir.mlir new file mode 100644 index 00000000..32917cf2 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/function_declaration/jsir.mlir @@ -0,0 +1,31 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "foo", 9, 12, 1, "foo">}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.function_declaration"() <{async = false, generator = false, id = #jsir, , "bar", 42, 45, 2, "bar">}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "some_computation"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.call_expression"(%1) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.assignment_pattern_ref"(%0, %2) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.return_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/function_declaration/run.lit b/maldoca/js/ir/conversion/tests/function_declaration/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/function_declaration/run.lit +++ b/maldoca/js/ir/conversion/tests/function_declaration/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/generate_tests.py b/maldoca/js/ir/conversion/tests/generate_tests.py deleted file mode 100644 index 788bd92a..00000000 --- a/maldoca/js/ir/conversion/tests/generate_tests.py +++ /dev/null @@ -1,92 +0,0 @@ -"""Generates test files for the conversion tests. - -In each directory, only `input.js` is manually written. The other files are -generated by running this tool. - -Usage: python3 generate_tests.py -""" - -import os -import shutil -import subprocess -import sys - - -def run_command(cmd: str) -> bytes: - """Run a shell command and return its output.""" - - print("Running:") - print(" ", cmd) - - try: - return subprocess.check_output(cmd, shell=True, stderr=subprocess.PIPE) - except subprocess.CalledProcessError as e: - print("Error running command, output:", e.output) - sys.exit(1) - - -def generate_test_file(name: str, output_name: str, passes: str, prefix: str): - """Generates a test file. - - Args: - name: Test case name. - output_name: The output file will be /. - passes: Comma-separated list of JSIR passes. - prefix: FileCheck prefix. - """ - output = run_command( - "bazel run //maldoca/js/ir:jsir_gen --" - f" --input_file {'$(pwd)/' + name + '/input.js'}" - f" --passes='{passes}'" - ) - - output = output.strip() - - # Prepend prefix - lines = output.split(b"\n") - out_lines = [] - for i, line in enumerate(lines): - if not line: - line = f"// {prefix}-EMPTY:".encode() - elif i == 0: - line = f"// {prefix}: ".encode() + line - else: - line = f"// {prefix}-NEXT: ".encode() + line - out_lines.append(line) - - output = b"\n".join(out_lines) + b"\n" - - with open(name + "/" + output_name, "wb") as f: - f.write(output) - - -if __name__ == "__main__": - for entry in os.listdir(os.path.dirname(__file__)): - if not os.path.isdir(entry): - continue - - print("Generating test:", entry) - - generate_test_file( - entry, - output_name="ast.json", - passes="source2ast", - prefix="AST", - ) - - generate_test_file( - entry, - output_name="jshir.mlir", - passes="source2ast,ast2hir", - prefix="JSHIR", - ) - - generate_test_file( - entry, - output_name="output.js", - passes="source2ast,ast2source", - prefix="SOURCE", - ) - - shutil.copyfile("run.lit.template", os.path.join(entry, "run.lit")) - shutil.copyfile("BUILD.template.bzl", os.path.join(entry, "BUILD")) diff --git a/maldoca/js/ir/conversion/tests/if_statement/BUILD b/maldoca/js/ir/conversion/tests/if_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/if_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/if_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/if_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/if_statement/jshir.mlir deleted file mode 100644 index 3a07c790..00000000 --- a/maldoca/js/ir/conversion/tests/if_statement/jshir.mlir +++ /dev/null @@ -1,24 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%0) ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%1) ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/if_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/if_statement/jsir.mlir new file mode 100644 index 00000000..4f972834 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/if_statement/jsir.mlir @@ -0,0 +1,24 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%0) ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%1) ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/if_statement/run.lit b/maldoca/js/ir/conversion/tests/if_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/if_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/if_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/import_declaration/BUILD b/maldoca/js/ir/conversion/tests/import_declaration/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/import_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/import_declaration/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/import_declaration/jshir.mlir b/maldoca/js/ir/conversion/tests/import_declaration/jshir.mlir deleted file mode 100644 index 455b43c8..00000000 --- a/maldoca/js/ir/conversion/tests/import_declaration/jshir.mlir +++ /dev/null @@ -1,10 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ -// JSHIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 30, 35, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 7, 24, 0, "default_specifier", 0, , , "default_specifier", 7, 24, 0, "default_specifier">]}> : () -> () -// JSHIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 62, 67, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 46, 55, 0, "specifier", 0, #jsir, , "specifier", 46, 55, 0, "specifier">, , , "specifier", 46, 55, 0, "specifier">]}> : () -> () -// JSHIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 107, 112, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 78, 88, 0, "specifier1", 0, #jsir, , "specifier1", 78, 88, 0, "specifier1">, , , "specifier1", 78, 88, 0, "specifier1">, #jsir, , 90, 100, 0, "specifier2", 0, #jsir, , "specifier2", 90, 100, 0, "specifier2">, , , "specifier2", 90, 100, 0, "specifier2">]}> : () -> () -// JSHIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 152, 157, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 122, 146, 0, "namespace_specifier", 0, , , "namespace_specifier", 127, 146, 0, "namespace_specifier">]}> : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/import_declaration/jsir.mlir b/maldoca/js/ir/conversion/tests/import_declaration/jsir.mlir new file mode 100644 index 00000000..65657c8f --- /dev/null +++ b/maldoca/js/ir/conversion/tests/import_declaration/jsir.mlir @@ -0,0 +1,10 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ +// JSIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 30, 35, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 7, 24, 0, "default_specifier", 0, , , "default_specifier", 7, 24, 0, "default_specifier">]}> : () -> () +// JSIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 62, 67, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 46, 55, 0, "specifier", 0, #jsir, , "specifier", 46, 55, 0, "specifier">, , , "specifier", 46, 55, 0, "specifier">]}> : () -> () +// JSIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 107, 112, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 78, 88, 0, "specifier1", 0, #jsir, , "specifier1", 78, 88, 0, "specifier1">, , , "specifier1", 78, 88, 0, "specifier1">, #jsir, , 90, 100, 0, "specifier2", 0, #jsir, , "specifier2", 90, 100, 0, "specifier2">, , , "specifier2", 90, 100, 0, "specifier2">]}> : () -> () +// JSIR-NEXT: "jsir.import_declaration"() <{source = #jsir, , 152, 157, 0, "src", "\22src\22", "src">, specifiers = [#jsir, , 122, 146, 0, "namespace_specifier", 0, , , "namespace_specifier", 127, 146, 0, "namespace_specifier">]}> : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/import_declaration/run.lit b/maldoca/js/ir/conversion/tests/import_declaration/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/import_declaration/run.lit +++ b/maldoca/js/ir/conversion/tests/import_declaration/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD b/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD +++ b/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/interpreter_directive/jshir.mlir b/maldoca/js/ir/conversion/tests/interpreter_directive/jshir.mlir deleted file mode 100644 index a0571ba2..00000000 --- a/maldoca/js/ir/conversion/tests/interpreter_directive/jshir.mlir +++ /dev/null @@ -1,7 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{interpreter = #jsir, , 0, 25, "/usr/bin/env babel-node">, source_type = "script"}> ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/interpreter_directive/jsir.mlir b/maldoca/js/ir/conversion/tests/interpreter_directive/jsir.mlir new file mode 100644 index 00000000..e472b2dc --- /dev/null +++ b/maldoca/js/ir/conversion/tests/interpreter_directive/jsir.mlir @@ -0,0 +1,7 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{interpreter = #jsir, , 0, 25, "/usr/bin/env babel-node">, source_type = "script"}> ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/interpreter_directive/run.lit b/maldoca/js/ir/conversion/tests/interpreter_directive/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/interpreter_directive/run.lit +++ b/maldoca/js/ir/conversion/tests/interpreter_directive/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/labeled_statement/BUILD b/maldoca/js/ir/conversion/tests/labeled_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/labeled_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/labeled_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/labeled_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/labeled_statement/jshir.mlir deleted file mode 100644 index 27ddccf2..00000000 --- a/maldoca/js/ir/conversion/tests/labeled_statement/jshir.mlir +++ /dev/null @@ -1,14 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.labeled_statement"() <{label = #jsir, , "label", 0, 5, 0, "label">}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.if_statement"(%0) ({ -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/labeled_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/labeled_statement/jsir.mlir new file mode 100644 index 00000000..6c77edd7 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/labeled_statement/jsir.mlir @@ -0,0 +1,14 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.labeled_statement"() <{label = #jsir, , "label", 0, 5, 0, "label">}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.if_statement"(%0) ({ +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/labeled_statement/run.lit b/maldoca/js/ir/conversion/tests/labeled_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/labeled_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/labeled_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/literal/BUILD b/maldoca/js/ir/conversion/tests/literal/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/literal/BUILD +++ b/maldoca/js/ir/conversion/tests/literal/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/literal/jshir.mlir b/maldoca/js/ir/conversion/tests/literal/jshir.mlir deleted file mode 100644 index f5f14e7c..00000000 --- a/maldoca/js/ir/conversion/tests/literal/jshir.mlir +++ /dev/null @@ -1,18 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.reg_exp_literal"() <{extra = #jsir, flags = "", pattern = "1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.null_literal"() : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: %5 = "jsir.big_int_literal"() <{extra = #jsir, value = "1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/literal/jsir.mlir b/maldoca/js/ir/conversion/tests/literal/jsir.mlir new file mode 100644 index 00000000..06933100 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/literal/jsir.mlir @@ -0,0 +1,18 @@ +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 21, " regular expression">, #jsir, , 28, 35, " null">, #jsir, , 42, 51, " string">, #jsir, , 58, 68, " boolean">, #jsir, , 76, 85, " number">, #jsir, , 90, 100, " big int">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.reg_exp_literal"() <{extra = #jsir, flags = "", pattern = "1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.null_literal"() : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.string_literal"() <{extra = #jsir, value = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.boolean_literal"() <{value = true}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: %5 = "jsir.big_int_literal"() <{extra = #jsir, value = "1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/literal/run.lit b/maldoca/js/ir/conversion/tests/literal/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/literal/run.lit +++ b/maldoca/js/ir/conversion/tests/literal/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD b/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD +++ b/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/load_store_identifier/jshir.mlir b/maldoca/js/ir/conversion/tests/load_store_identifier/jshir.mlir deleted file mode 100644 index 0213c324..00000000 --- a/maldoca/js/ir/conversion/tests/load_store_identifier/jshir.mlir +++ /dev/null @@ -1,12 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/load_store_identifier/jsir.mlir b/maldoca/js/ir/conversion/tests/load_store_identifier/jsir.mlir new file mode 100644 index 00000000..7173af23 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/load_store_identifier/jsir.mlir @@ -0,0 +1,12 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/load_store_identifier/run.lit b/maldoca/js/ir/conversion/tests/load_store_identifier/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/load_store_identifier/run.lit +++ b/maldoca/js/ir/conversion/tests/load_store_identifier/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/logical_expression/BUILD b/maldoca/js/ir/conversion/tests/logical_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/logical_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/logical_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/logical_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/logical_expression/jshir.mlir deleted file mode 100644 index d4a10880..00000000 --- a/maldoca/js/ir/conversion/tests/logical_expression/jshir.mlir +++ /dev/null @@ -1,24 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jshir.logical_expression"(%0) <{operator_ = "&&"}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jshir.logical_expression"(%2) <{operator_ = "||"}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jshir.logical_expression"(%4) <{operator_ = "??"}> ({ -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/logical_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/logical_expression/jsir.mlir new file mode 100644 index 00000000..5b77b21d --- /dev/null +++ b/maldoca/js/ir/conversion/tests/logical_expression/jsir.mlir @@ -0,0 +1,24 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.logical_expression"(%0) <{operator_ = "&&"}> ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.logical_expression"(%2) <{operator_ = "||"}> ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.logical_expression"(%4) <{operator_ = "??"}> ({ +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/logical_expression/run.lit b/maldoca/js/ir/conversion/tests/logical_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/logical_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/logical_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/member_expression/BUILD b/maldoca/js/ir/conversion/tests/member_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/member_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/member_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/member_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/member_expression/jshir.mlir deleted file mode 100644 index 416c0f7e..00000000 --- a/maldoca/js/ir/conversion/tests/member_expression/jshir.mlir +++ /dev/null @@ -1,24 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "b", 2, 3, 0, "b">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.member_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.member_expression_ref"(%5) <{literal_property = #jsir, , "b", 15, 16, 0, "b">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.assignment_expression"(%6, %7) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: %9 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.member_expression_ref"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.assignment_expression"(%11, %12) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%13) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/member_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/member_expression/jsir.mlir new file mode 100644 index 00000000..ba0ace0a --- /dev/null +++ b/maldoca/js/ir/conversion/tests/member_expression/jsir.mlir @@ -0,0 +1,24 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.member_expression"(%0) <{literal_property = #jsir, , "b", 2, 3, 0, "b">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.member_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.member_expression_ref"(%5) <{literal_property = #jsir, , "b", 15, 16, 0, "b">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %7 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.assignment_expression"(%6, %7) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%8) : (!jsir.any) -> () +// JSIR-NEXT: %9 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.member_expression_ref"(%9, %10) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.assignment_expression"(%11, %12) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%13) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/member_expression/run.lit b/maldoca/js/ir/conversion/tests/member_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/member_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/member_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/meta_property/BUILD b/maldoca/js/ir/conversion/tests/meta_property/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/meta_property/BUILD +++ b/maldoca/js/ir/conversion/tests/meta_property/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/meta_property/jshir.mlir b/maldoca/js/ir/conversion/tests/meta_property/jshir.mlir deleted file mode 100644 index af9df4f6..00000000 --- a/maldoca/js/ir/conversion/tests/meta_property/jshir.mlir +++ /dev/null @@ -1,8 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ -// JSHIR-NEXT: %0 = "jsir.meta_property"() <{meta = #jsir, , "import", 0, 6, 0, "import">, property = #jsir, , "meta", 7, 11, 0, "meta">}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/meta_property/jsir.mlir b/maldoca/js/ir/conversion/tests/meta_property/jsir.mlir new file mode 100644 index 00000000..8959e935 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/meta_property/jsir.mlir @@ -0,0 +1,8 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "module"}> ({ +// JSIR-NEXT: %0 = "jsir.meta_property"() <{meta = #jsir, , "import", 0, 6, 0, "import">, property = #jsir, , "meta", 7, 11, 0, "meta">}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/meta_property/run.lit b/maldoca/js/ir/conversion/tests/meta_property/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/meta_property/run.lit +++ b/maldoca/js/ir/conversion/tests/meta_property/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/new_expression/BUILD b/maldoca/js/ir/conversion/tests/new_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/new_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/new_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/new_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/new_expression/jshir.mlir deleted file mode 100644 index 46367465..00000000 --- a/maldoca/js/ir/conversion/tests/new_expression/jshir.mlir +++ /dev/null @@ -1,13 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "foo"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.spread_element"(%3) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.new_expression"(%0, %1, %2, %4) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/new_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/new_expression/jsir.mlir new file mode 100644 index 00000000..f42f7af2 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/new_expression/jsir.mlir @@ -0,0 +1,13 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "foo"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.spread_element"(%3) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %5 = "jsir.new_expression"(%0, %1, %2, %4) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/new_expression/run.lit b/maldoca/js/ir/conversion/tests/new_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/new_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/new_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/object_expression/BUILD b/maldoca/js/ir/conversion/tests/object_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/object_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/object_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/object_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/object_expression/jshir.mlir deleted file mode 100644 index 10137720..00000000 --- a/maldoca/js/ir/conversion/tests/object_expression/jshir.mlir +++ /dev/null @@ -1,53 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.object_expression"() ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "short_hand"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.object_property"(%2) <{literal_key = #jsir, , "short_hand", 5, 15, 0, "short_hand">, shorthand = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.object_property"(%4) <{literal_key = #jsir, , "property_identifier", 19, 38, 0, "property_identifier">, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.object_property"(%6) <{literal_key = #jsir, , 45, 70, 0, "property_string_literal", "\22property_string_literal\22", "property_string_literal">, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.object_property"(%8) <{literal_key = #jsir, , 77, 80, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.object_property"(%10, %11) <{shorthand = false}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 115, 132, 0, "method_identifier">, operandSegmentSizes = array}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 141, 166, 0, "property_string_literal", "\22property_string_literal\22", "property_string_literal">, operandSegmentSizes = array}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 175, 178, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %16 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any -// JSHIR-NEXT: %17 = "jsir.object_method"(%16) <{async = false, generator = false, kind = "method", operandSegmentSizes = array}> ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %18 = "jsir.identifier"() <{name = "spread_element"}> : () -> !jsir.any -// JSHIR-NEXT: %19 = "jsir.spread_element"(%18) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%3, %5, %7, %9, %12, %13, %14, %15, %17, %19) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.parenthesized_expression"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/object_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/object_expression/jsir.mlir new file mode 100644 index 00000000..866cb0ce --- /dev/null +++ b/maldoca/js/ir/conversion/tests/object_expression/jsir.mlir @@ -0,0 +1,53 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.object_expression"() ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "short_hand"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.object_property"(%2) <{literal_key = #jsir, , "short_hand", 5, 15, 0, "short_hand">, shorthand = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.object_property"(%4) <{literal_key = #jsir, , "property_identifier", 19, 38, 0, "property_identifier">, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.object_property"(%6) <{literal_key = #jsir, , 45, 70, 0, "property_string_literal", "\22property_string_literal\22", "property_string_literal">, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %8 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.object_property"(%8) <{literal_key = #jsir, , 77, 80, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.numeric_literal"() <{extra = #jsir, value = 4.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %12 = "jsir.object_property"(%10, %11) <{shorthand = false}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %13 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , "method_identifier", 115, 132, 0, "method_identifier">, operandSegmentSizes = array}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 141, 166, 0, "property_string_literal", "\22property_string_literal\22", "property_string_literal">, operandSegmentSizes = array}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %15 = "jsir.object_method"() <{async = false, generator = false, kind = "method", literal_key = #jsir, , 175, 178, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, operandSegmentSizes = array}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %16 = "jsir.string_literal"() <{extra = #jsir, value = "property_computed"}> : () -> !jsir.any +// JSIR-NEXT: %17 = "jsir.object_method"(%16) <{async = false, generator = false, kind = "method", operandSegmentSizes = array}> ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %18 = "jsir.identifier"() <{name = "spread_element"}> : () -> !jsir.any +// JSIR-NEXT: %19 = "jsir.spread_element"(%18) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%3, %5, %7, %9, %12, %13, %14, %15, %17, %19) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.parenthesized_expression"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/object_expression/run.lit b/maldoca/js/ir/conversion/tests/object_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/object_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/object_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/object_pattern/BUILD b/maldoca/js/ir/conversion/tests/object_pattern/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/object_pattern/BUILD +++ b/maldoca/js/ir/conversion/tests/object_pattern/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/object_pattern/jshir.mlir b/maldoca/js/ir/conversion/tests/object_pattern/jshir.mlir deleted file mode 100644 index e18f1779..00000000 --- a/maldoca/js/ir/conversion/tests/object_pattern/jshir.mlir +++ /dev/null @@ -1,26 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = [#jsir, , 0, 48, " Must wrap with \22()\22, otherwise doesn't parse.">]}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.object_pattern_ref"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "lvalue_shorthand"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.object_property_ref"(%4) <{literal_key = #jsir, , "lvalue_shorthand", 59, 75, 0, "lvalue_shorthand">, shorthand = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "lvalue_1"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.object_property_ref"(%6) <{literal_key = #jsir, , "identifier", 81, 91, 0, "identifier">, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "lvalue_2"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.object_property_ref"(%8) <{literal_key = #jsir, , 107, 123, 0, "string_literal", "'string_literal'", "string_literal">, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "lvalue_3"}> : () -> !jsir.any -// JSHIR-NEXT: %11 = "jsir.object_property_ref"(%10) <{literal_key = #jsir, , 139, 142, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, shorthand = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %12 = "jsir.string_literal"() <{extra = #jsir, value = "computed"}> : () -> !jsir.any -// JSHIR-NEXT: %13 = "jsir.identifier_ref"() <{name = "lvalue_4"}> : () -> !jsir.any -// JSHIR-NEXT: %14 = "jsir.object_property_ref"(%12, %13) <{shorthand = false}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %15 = "jsir.identifier_ref"() <{name = "lvalue_rest"}> : () -> !jsir.any -// JSHIR-NEXT: %16 = "jsir.rest_element_ref"(%15) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%5, %7, %9, %11, %14, %16) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> () -// JSHIR-NEXT: }) : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "obj"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.parenthesized_expression"(%2) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/object_pattern/jsir.mlir b/maldoca/js/ir/conversion/tests/object_pattern/jsir.mlir new file mode 100644 index 00000000..8c5d26c0 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/object_pattern/jsir.mlir @@ -0,0 +1,26 @@ +// JSIR: "jsir.file"() <{comments = [#jsir, , 0, 48, " Must wrap with \22()\22, otherwise doesn't parse.">]}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.object_pattern_ref"() ({ +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "lvalue_shorthand"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.object_property_ref"(%4) <{literal_key = #jsir, , "lvalue_shorthand", 59, 75, 0, "lvalue_shorthand">, shorthand = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier_ref"() <{name = "lvalue_1"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.object_property_ref"(%6) <{literal_key = #jsir, , "identifier", 81, 91, 0, "identifier">, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %8 = "jsir.identifier_ref"() <{name = "lvalue_2"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.object_property_ref"(%8) <{literal_key = #jsir, , 107, 123, 0, "string_literal", "'string_literal'", "string_literal">, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.identifier_ref"() <{name = "lvalue_3"}> : () -> !jsir.any +// JSIR-NEXT: %11 = "jsir.object_property_ref"(%10) <{literal_key = #jsir, , 139, 142, 0, 1.000000e+00 : f64, "1.0", 1.000000e+00 : f64>, shorthand = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %12 = "jsir.string_literal"() <{extra = #jsir, value = "computed"}> : () -> !jsir.any +// JSIR-NEXT: %13 = "jsir.identifier_ref"() <{name = "lvalue_4"}> : () -> !jsir.any +// JSIR-NEXT: %14 = "jsir.object_property_ref"(%12, %13) <{shorthand = false}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %15 = "jsir.identifier_ref"() <{name = "lvalue_rest"}> : () -> !jsir.any +// JSIR-NEXT: %16 = "jsir.rest_element_ref"(%15) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%5, %7, %9, %11, %14, %16) : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> () +// JSIR-NEXT: }) : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "obj"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.assignment_expression"(%0, %1) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.parenthesized_expression"(%2) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/object_pattern/run.lit b/maldoca/js/ir/conversion/tests/object_pattern/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/object_pattern/run.lit +++ b/maldoca/js/ir/conversion/tests/object_pattern/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD b/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/optional_member_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/optional_member_expression/jshir.mlir deleted file mode 100644 index a95242e9..00000000 --- a/maldoca/js/ir/conversion/tests/optional_member_expression/jshir.mlir +++ /dev/null @@ -1,21 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.optional_member_expression"(%0) <{literal_property = #jsir, , "b", 3, 4, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "b", 9, 10, 0, "b">}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.optional_member_expression"(%3) <{literal_property = #jsir, , "c", 12, 13, 0, "c">, optional = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.optional_member_expression"(%5) <{literal_property = #jsir, , "b", 19, 20, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.optional_member_expression"(%6) <{literal_property = #jsir, , "c", 21, 22, 0, "c">, optional = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: %8 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %9 = "jsir.optional_member_expression"(%8) <{literal_property = #jsir, , "b", 28, 29, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %10 = "jsir.optional_member_expression"(%9) <{literal_property = #jsir, , "c", 31, 32, 0, "c">, optional = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%10) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/optional_member_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/optional_member_expression/jsir.mlir new file mode 100644 index 00000000..b69a1a7b --- /dev/null +++ b/maldoca/js/ir/conversion/tests/optional_member_expression/jsir.mlir @@ -0,0 +1,21 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.optional_member_expression"(%0) <{literal_property = #jsir, , "b", 3, 4, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.member_expression"(%2) <{literal_property = #jsir, , "b", 9, 10, 0, "b">}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.optional_member_expression"(%3) <{literal_property = #jsir, , "c", 12, 13, 0, "c">, optional = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: %5 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.optional_member_expression"(%5) <{literal_property = #jsir, , "b", 19, 20, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %7 = "jsir.optional_member_expression"(%6) <{literal_property = #jsir, , "c", 21, 22, 0, "c">, optional = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: %8 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %9 = "jsir.optional_member_expression"(%8) <{literal_property = #jsir, , "b", 28, 29, 0, "b">, optional = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %10 = "jsir.optional_member_expression"(%9) <{literal_property = #jsir, , "c", 31, 32, 0, "c">, optional = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%10) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/optional_member_expression/run.lit b/maldoca/js/ir/conversion/tests/optional_member_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/optional_member_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/optional_member_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD b/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/parenthesized_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/parenthesized_expression/jshir.mlir deleted file mode 100644 index 9f279bcc..00000000 --- a/maldoca/js/ir/conversion/tests/parenthesized_expression/jshir.mlir +++ /dev/null @@ -1,16 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.parenthesized_expression_ref"(%0) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.assignment_expression"(%1, %2) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.parenthesized_expression"(%5) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.assignment_expression"(%4, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/parenthesized_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/parenthesized_expression/jsir.mlir new file mode 100644 index 00000000..16cea57c --- /dev/null +++ b/maldoca/js/ir/conversion/tests/parenthesized_expression/jsir.mlir @@ -0,0 +1,16 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.parenthesized_expression_ref"(%0) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.assignment_expression"(%1, %2) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: %4 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.parenthesized_expression"(%5) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %7 = "jsir.assignment_expression"(%4, %6) <{operator_ = "="}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%7) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/parenthesized_expression/run.lit b/maldoca/js/ir/conversion/tests/parenthesized_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/parenthesized_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/parenthesized_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/run.lit.template b/maldoca/js/ir/conversion/tests/run.lit.template index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/run.lit.template +++ b/maldoca/js/ir/conversion/tests/run.lit.template @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/switch_statement/BUILD b/maldoca/js/ir/conversion/tests/switch_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/switch_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/switch_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/switch_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/switch_statement/jshir.mlir deleted file mode 100644 index 0371ccba..00000000 --- a/maldoca/js/ir/conversion/tests/switch_statement/jshir.mlir +++ /dev/null @@ -1,66 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.switch_statement"(%0) ({ -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "body0"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "body1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.switch_statement"(%1) ({ -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "f"}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.call_expression"(%4) : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "body0"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %4 = "jsir.identifier"() <{name = "body1"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: "jshir.break_statement"() : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.switch_statement"(%2) ({ -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.switch_statement"(%3) ({ -// JSHIR-NEXT: "jshir.switch_case"() ({ -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/switch_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/switch_statement/jsir.mlir new file mode 100644 index 00000000..9cb0c3b6 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/switch_statement/jsir.mlir @@ -0,0 +1,66 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.switch_statement"(%0) ({ +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "body0"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "body1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.switch_statement"(%1) ({ +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "f"}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.call_expression"(%4) : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "body0"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %6 = "jsir.binary_expression"(%4, %5) <{operator_ = "+"}> : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%6) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %4 = "jsir.identifier"() <{name = "body1"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: "jsir.break_statement"() : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.switch_statement"(%2) ({ +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.switch_statement"(%3) ({ +// JSIR-NEXT: "jsir.switch_case"() ({ +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/switch_statement/run.lit b/maldoca/js/ir/conversion/tests/switch_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/switch_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/switch_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/tagged_template/BUILD b/maldoca/js/ir/conversion/tests/tagged_template/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/tagged_template/BUILD +++ b/maldoca/js/ir/conversion/tests/tagged_template/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/tagged_template/jshir.mlir b/maldoca/js/ir/conversion/tests/tagged_template/jshir.mlir deleted file mode 100644 index 8424e47f..00000000 --- a/maldoca/js/ir/conversion/tests/tagged_template/jshir.mlir +++ /dev/null @@ -1,12 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "raw"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.template_element_value"() <{cooked = "42", raw = "42"}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.template_element"(%1) <{tail = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.template_literal"(%2) <{operandSegmentSizes = array}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.tagged_template_expression"(%0, %3) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/tagged_template/jsir.mlir b/maldoca/js/ir/conversion/tests/tagged_template/jsir.mlir new file mode 100644 index 00000000..aff44a24 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/tagged_template/jsir.mlir @@ -0,0 +1,12 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "raw"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.template_element_value"() <{cooked = "42", raw = "42"}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.template_element"(%1) <{tail = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.template_literal"(%2) <{operandSegmentSizes = array}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.tagged_template_expression"(%0, %3) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%4) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/tagged_template/run.lit b/maldoca/js/ir/conversion/tests/tagged_template/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/tagged_template/run.lit +++ b/maldoca/js/ir/conversion/tests/tagged_template/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/template/BUILD b/maldoca/js/ir/conversion/tests/template/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/template/BUILD +++ b/maldoca/js/ir/conversion/tests/template/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/template/jshir.mlir b/maldoca/js/ir/conversion/tests/template/jshir.mlir deleted file mode 100644 index 06d5199f..00000000 --- a/maldoca/js/ir/conversion/tests/template/jshir.mlir +++ /dev/null @@ -1,16 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.template_element_value"() <{cooked = "a", raw = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.template_element"(%0) <{tail = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.template_element_value"() <{cooked = "c", raw = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.template_element"(%2) <{tail = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.template_element_value"() <{cooked = "", raw = ""}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.template_element"(%4) <{tail = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %7 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %8 = "jsir.template_literal"(%1, %3, %5, %6, %7) <{operandSegmentSizes = array}> : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%8) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/template/jsir.mlir b/maldoca/js/ir/conversion/tests/template/jsir.mlir new file mode 100644 index 00000000..04287625 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/template/jsir.mlir @@ -0,0 +1,16 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.template_element_value"() <{cooked = "a", raw = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.template_element"(%0) <{tail = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %2 = "jsir.template_element_value"() <{cooked = "c", raw = "c"}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.template_element"(%2) <{tail = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %4 = "jsir.template_element_value"() <{cooked = "", raw = ""}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.template_element"(%4) <{tail = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: %6 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %7 = "jsir.identifier"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %8 = "jsir.template_literal"(%1, %3, %5, %6, %7) <{operandSegmentSizes = array}> : (!jsir.any, !jsir.any, !jsir.any, !jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%8) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/template/run.lit b/maldoca/js/ir/conversion/tests/template/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/template/run.lit +++ b/maldoca/js/ir/conversion/tests/template/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/test_config.json b/maldoca/js/ir/conversion/tests/test_config.json new file mode 100644 index 00000000..40683696 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/test_config.json @@ -0,0 +1,22 @@ +{ + "tests": [ + { + "output_file": "ast.json", + "passes": "source2ast", + "prefix": "AST" + }, + { + "output_file": "jsir.mlir", + "passes": "source2ast,ast2jsir", + "prefix": "JSIR" + }, + { + "output_file": "output.js", + "passes": "source2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template.bzl", + "lit_template": "run.lit.template", + "generate_readme": false +} diff --git a/maldoca/js/ir/conversion/tests/throw_statement/BUILD b/maldoca/js/ir/conversion/tests/throw_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/throw_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/throw_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/throw_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/throw_statement/jshir.mlir deleted file mode 100644 index f58cbc24..00000000 --- a/maldoca/js/ir/conversion/tests/throw_statement/jshir.mlir +++ /dev/null @@ -1,8 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.throw_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/throw_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/throw_statement/jsir.mlir new file mode 100644 index 00000000..f4aa1c10 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/throw_statement/jsir.mlir @@ -0,0 +1,8 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: "jsir.throw_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/throw_statement/run.lit b/maldoca/js/ir/conversion/tests/throw_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/throw_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/throw_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/try_statement/BUILD b/maldoca/js/ir/conversion/tests/try_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/try_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/try_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/try_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/try_statement/jshir.mlir deleted file mode 100644 index 72908f99..00000000 --- a/maldoca/js/ir/conversion/tests/try_statement/jshir.mlir +++ /dev/null @@ -1,66 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.try_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "error"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.catch_clause"(%0) ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.try_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jshir.try_statement"() ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "error"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.catch_clause"(%0) ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/try_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/try_statement/jsir.mlir new file mode 100644 index 00000000..38972745 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/try_statement/jsir.mlir @@ -0,0 +1,66 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.try_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "error"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.catch_clause"(%0) ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.try_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.try_statement"() ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "error"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.catch_clause"(%0) ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/try_statement/run.lit b/maldoca/js/ir/conversion/tests/try_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/try_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/try_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/unary_expression/BUILD b/maldoca/js/ir/conversion/tests/unary_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/unary_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/unary_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/unary_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/unary_expression/jshir.mlir deleted file mode 100644 index 030c02c6..00000000 --- a/maldoca/js/ir/conversion/tests/unary_expression/jshir.mlir +++ /dev/null @@ -1,9 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.unary_expression"(%0) <{operator_ = "-", prefix = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/unary_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/unary_expression/jsir.mlir new file mode 100644 index 00000000..4ebb406d --- /dev/null +++ b/maldoca/js/ir/conversion/tests/unary_expression/jsir.mlir @@ -0,0 +1,9 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.unary_expression"(%0) <{operator_ = "-", prefix = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/unary_expression/run.lit b/maldoca/js/ir/conversion/tests/unary_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/unary_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/unary_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/update_expression/BUILD b/maldoca/js/ir/conversion/tests/update_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/update_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/update_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/update_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/update_expression/jshir.mlir deleted file mode 100644 index 2df033f8..00000000 --- a/maldoca/js/ir/conversion/tests/update_expression/jshir.mlir +++ /dev/null @@ -1,9 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.update_expression"(%0) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/update_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/update_expression/jsir.mlir new file mode 100644 index 00000000..ae5d24a8 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/update_expression/jsir.mlir @@ -0,0 +1,9 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.update_expression"(%0) <{operator_ = "++", prefix = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/update_expression/run.lit b/maldoca/js/ir/conversion/tests/update_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/update_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/update_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/variable_declaration/BUILD b/maldoca/js/ir/conversion/tests/variable_declaration/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/variable_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/variable_declaration/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/variable_declaration/jshir.mlir b/maldoca/js/ir/conversion/tests/variable_declaration/jshir.mlir deleted file mode 100644 index f523533f..00000000 --- a/maldoca/js/ir/conversion/tests/variable_declaration/jshir.mlir +++ /dev/null @@ -1,27 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: "jsir.variable_declaration"() <{kind = "const"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.exprs_region_end"(%2, %5) : (!jsir.any, !jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/variable_declaration/jsir.mlir b/maldoca/js/ir/conversion/tests/variable_declaration/jsir.mlir new file mode 100644 index 00000000..205492fa --- /dev/null +++ b/maldoca/js/ir/conversion/tests/variable_declaration/jsir.mlir @@ -0,0 +1,27 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "let"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 0.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "var"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: "jsir.variable_declaration"() <{kind = "const"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier_ref"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %2 = "jsir.variable_declarator"(%0, %1) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %3 = "jsir.identifier_ref"() <{name = "d"}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %5 = "jsir.variable_declarator"(%3, %4) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.exprs_region_end"(%2, %5) : (!jsir.any, !jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/variable_declaration/run.lit b/maldoca/js/ir/conversion/tests/variable_declaration/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/variable_declaration/run.lit +++ b/maldoca/js/ir/conversion/tests/variable_declaration/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/while_statement/BUILD b/maldoca/js/ir/conversion/tests/while_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/while_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/while_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/while_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/while_statement/jshir.mlir deleted file mode 100644 index bb246e47..00000000 --- a/maldoca/js/ir/conversion/tests/while_statement/jshir.mlir +++ /dev/null @@ -1,13 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jshir.while_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/while_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/while_statement/jsir.mlir new file mode 100644 index 00000000..43eabb4c --- /dev/null +++ b/maldoca/js/ir/conversion/tests/while_statement/jsir.mlir @@ -0,0 +1,13 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.while_statement"() ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expr_region_end"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%0) : (!jsir.any) -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/while_statement/run.lit b/maldoca/js/ir/conversion/tests/while_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/while_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/while_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/with_statement/BUILD b/maldoca/js/ir/conversion/tests/with_statement/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/with_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/with_statement/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/with_statement/jshir.mlir b/maldoca/js/ir/conversion/tests/with_statement/jshir.mlir deleted file mode 100644 index 161d8660..00000000 --- a/maldoca/js/ir/conversion/tests/with_statement/jshir.mlir +++ /dev/null @@ -1,22 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.with_statement"(%0) ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any -// JSHIR-NEXT: "jshir.with_statement"(%1) ({ -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () -// JSHIR-NEXT: %3 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/with_statement/jsir.mlir b/maldoca/js/ir/conversion/tests/with_statement/jsir.mlir new file mode 100644 index 00000000..628f6f76 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/with_statement/jsir.mlir @@ -0,0 +1,22 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: %0 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.with_statement"(%0) ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: %1 = "jsir.identifier"() <{name = "a"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.with_statement"(%1) ({ +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %2 = "jsir.identifier"() <{name = "b"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%2) : (!jsir.any) -> () +// JSIR-NEXT: %3 = "jsir.identifier"() <{name = "c"}> : () -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%3) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/with_statement/run.lit b/maldoca/js/ir/conversion/tests/with_statement/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/with_statement/run.lit +++ b/maldoca/js/ir/conversion/tests/with_statement/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/tests/yield_expression/BUILD b/maldoca/js/ir/conversion/tests/yield_expression/BUILD index 51e32be8..c08caad1 100644 --- a/maldoca/js/ir/conversion/tests/yield_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/yield_expression/BUILD @@ -23,7 +23,7 @@ filegroup( srcs = [ "ast.json", "input.js", - "jshir.mlir", + "jsir.mlir", "output.js", ], tags = ["ignore_srcs"], diff --git a/maldoca/js/ir/conversion/tests/yield_expression/jshir.mlir b/maldoca/js/ir/conversion/tests/yield_expression/jshir.mlir deleted file mode 100644 index 60c580b6..00000000 --- a/maldoca/js/ir/conversion/tests/yield_expression/jshir.mlir +++ /dev/null @@ -1,22 +0,0 @@ -// JSHIR: "jsir.file"() <{comments = []}> ({ -// JSHIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ -// JSHIR-NEXT: "jsir.function_declaration"() <{async = false, generator = true, id = #jsir, , "gen", 10, 13, 1, "gen">}> ({ -// JSHIR-NEXT: "jsir.exprs_region_end"() : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: "jshir.block_statement"() ({ -// JSHIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %1 = "jsir.yield_expression"(%0) <{delegate = false}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () -// JSHIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any -// JSHIR-NEXT: %4 = "jsir.array_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any -// JSHIR-NEXT: %5 = "jsir.yield_expression"(%4) <{delegate = true}> : (!jsir.any) -> !jsir.any -// JSHIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }, { -// JSHIR-NEXT: ^bb0: -// JSHIR-NEXT: }) : () -> () -// JSHIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/yield_expression/jsir.mlir b/maldoca/js/ir/conversion/tests/yield_expression/jsir.mlir new file mode 100644 index 00000000..d25e3765 --- /dev/null +++ b/maldoca/js/ir/conversion/tests/yield_expression/jsir.mlir @@ -0,0 +1,22 @@ +// JSIR: "jsir.file"() <{comments = []}> ({ +// JSIR-NEXT: "jsir.program"() <{source_type = "script"}> ({ +// JSIR-NEXT: "jsir.function_declaration"() <{async = false, generator = true, id = #jsir, , "gen", 10, 13, 1, "gen">}> ({ +// JSIR-NEXT: "jsir.exprs_region_end"() : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: "jsir.block_statement"() ({ +// JSIR-NEXT: %0 = "jsir.numeric_literal"() <{extra = #jsir, value = 1.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %1 = "jsir.yield_expression"(%0) <{delegate = false}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%1) : (!jsir.any) -> () +// JSIR-NEXT: %2 = "jsir.numeric_literal"() <{extra = #jsir, value = 2.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %3 = "jsir.numeric_literal"() <{extra = #jsir, value = 3.000000e+00 : f64}> : () -> !jsir.any +// JSIR-NEXT: %4 = "jsir.array_expression"(%2, %3) : (!jsir.any, !jsir.any) -> !jsir.any +// JSIR-NEXT: %5 = "jsir.yield_expression"(%4) <{delegate = true}> : (!jsir.any) -> !jsir.any +// JSIR-NEXT: "jsir.expression_statement"(%5) : (!jsir.any) -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }, { +// JSIR-NEXT: ^bb0: +// JSIR-NEXT: }) : () -> () +// JSIR-NEXT: }) : () -> () diff --git a/maldoca/js/ir/conversion/tests/yield_expression/run.lit b/maldoca/js/ir/conversion/tests/yield_expression/run.lit index c7362e4f..d3c12f93 100644 --- a/maldoca/js/ir/conversion/tests/yield_expression/run.lit +++ b/maldoca/js/ir/conversion/tests/yield_expression/run.lit @@ -1,11 +1,11 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir" \ -// RUN: | FileCheck --check-prefix JSHIR "$(dirname "${INPUT}")"/jshir.mlir +// RUN: --passes "source2ast,ast2jsir" \ +// RUN: | FileCheck --check-prefix JSIR "$(dirname "${INPUT}")"/jsir.mlir // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes "source2ast,ast2hir,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js // RUN: INPUT=%s && \ @@ -15,5 +15,6 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,hir2ast \ +// RUN: --passes source2ast,ast2jsir,jsir2ast \ // RUN: | FileCheck --check-prefix AST "$(dirname "${INPUT}")"/ast.json + diff --git a/maldoca/js/ir/conversion/utils.cc b/maldoca/js/ir/conversion/utils.cc index 31f7ca69..552d0f28 100644 --- a/maldoca/js/ir/conversion/utils.cc +++ b/maldoca/js/ir/conversion/utils.cc @@ -32,11 +32,10 @@ namespace maldoca { -absl::StatusOr> AstToJshirFile( - const JsFile &ast, mlir::MLIRContext &context) { +absl::StatusOr> AstToJsirFile( + const JsFile& ast, mlir::MLIRContext& context) { // Check for all the dialects MALDOCA_RET_CHECK_NE(context.getLoadedDialect(), nullptr); - MALDOCA_RET_CHECK_NE(context.getLoadedDialect(), nullptr); MALDOCA_RET_CHECK_NE(context.getLoadedDialect(), nullptr); @@ -48,13 +47,12 @@ absl::StatusOr> AstToJshirFile( return std::move(hir_file); } -absl::StatusOr> JshirFileToAst(JsirFileOp hir_file) { - return JsirToAst::VisitFile(hir_file); +absl::StatusOr> JsirFileToAst(JsirFileOp ir_file) { + return JsirToAst::VisitFile(ir_file); } void LoadNecessaryDialects(mlir::MLIRContext &context) { context.getOrLoadDialect(); - context.getOrLoadDialect(); context.getOrLoadDialect(); context.getOrLoadDialect(); } diff --git a/maldoca/js/ir/conversion/utils.h b/maldoca/js/ir/conversion/utils.h index d61ab71c..51af6d7d 100644 --- a/maldoca/js/ir/conversion/utils.h +++ b/maldoca/js/ir/conversion/utils.h @@ -27,12 +27,11 @@ namespace maldoca { // context must contain the dialects // - JsirDialect -// - JshirDialect // - mlir::func::FuncDialect -absl::StatusOr> AstToJshirFile( - const JsFile &ast, mlir::MLIRContext &context); +absl::StatusOr> AstToJsirFile( + const JsFile& ast, mlir::MLIRContext& context); -absl::StatusOr> JshirFileToAst(JsirFileOp hir_file); +absl::StatusOr> JsirFileToAst(JsirFileOp ir_file); void LoadNecessaryDialects(mlir::MLIRContext &context); diff --git a/maldoca/js/ir/generate_tests.py b/maldoca/js/ir/generate_tests.py new file mode 100644 index 00000000..b56ff17f --- /dev/null +++ b/maldoca/js/ir/generate_tests.py @@ -0,0 +1,362 @@ +r"""Consolidated test generator for JSIR tests. + +Scans a directory for test cases (directories containing `input.js`) +and generates test outputs, READMEs, LIT files, and BUILD files based on +`test_config.json` found in the scanned directory. + +Usage: + python3 maldoca/js/ir/generate_tests.py + +Example: + python3 maldoca/js/ir/generate_tests.py maldoca/js/ir +""" + +import argparse +from concurrent import futures +import dataclasses +import json +import os +import shutil +import subprocess +import sys +from typing import Any, Dict, List, Optional +from tqdm import tqdm + + +def run_command(cmd: str) -> bytes: + """Run a shell command and return its output.""" + try: + return subprocess.check_output(cmd, shell=True, stderr=subprocess.PIPE) + except subprocess.CalledProcessError as e: + tqdm.write( + "Error running command, output:" + f" {e.output.decode('utf-8', errors='replace')}" + ) + sys.exit(1) + + +@dataclasses.dataclass +class TestConfig: + passes: str + output_file: str + prefix: Optional[str] = None + jsir_analysis: Optional[str] = None + output_type: Optional[str] = None + requires_taint_rules: bool = False + lit_file: str = "run.generated.lit" + readme_file: str = "README.generated.md" + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "TestConfig": + return cls( + passes=data["passes"], + output_file=data["output_file"], + prefix=data.get("prefix"), + jsir_analysis=data.get("jsir_analysis"), + output_type=data.get("output_type"), + requires_taint_rules=data.get("requires_taint_rules", False), + lit_file=data.get("lit_file", "run.generated.lit"), + readme_file=data.get("readme_file", "README.generated.md"), + ) + + +@dataclasses.dataclass +class SuiteConfig: + tests: List[TestConfig] + build_template: Optional[str] = None + lit_template: Optional[str] = None + lit_dest: str = "run.lit" + generate_readme: bool = True + overrides: Dict[str, "SuiteConfig"] = dataclasses.field(default_factory=dict) + + @classmethod + def from_dict(cls, data: Dict[str, Any]) -> "SuiteConfig": + tests = [TestConfig.from_dict(t) for t in data.get("tests", [])] + overrides = {} + if "overrides" in data: + for k, v in data["overrides"].items(): + overrides[k] = SuiteConfig.from_dict(v) + + return cls( + tests=tests, + build_template=data.get("build_template"), + lit_template=data.get("lit_template"), + lit_dest=data.get("lit_dest", "run.lit"), + generate_readme=data.get("generate_readme", True), + overrides=overrides, + ) + + +def get_extra_args( + test_config: TestConfig, test_path: str, for_template: bool +) -> str: + args = [] + if test_config.jsir_analysis: + args.append(f"--jsir_analysis={test_config.jsir_analysis}") + if test_config.output_type: + args.append(f"--output_type={test_config.output_type}") + + if test_config.requires_taint_rules: + rules_path = os.path.join(test_path, "input_rules.txtpb") + if for_template: + args.append(f"--taint_rules_path=$(pwd)/{rules_path}") + else: + args.append(f"--taint_rules_path={os.path.abspath(rules_path)}") + + return " " + " ".join(args) if args else "" + + +def get_check_command(test_config: TestConfig) -> str: + output_file = test_config.output_file + prefix = test_config.prefix or "JSIR" + if test_config.output_type == "analysis": + return f'diff "$(dirname %s)"/{output_file} -' + else: + return f'FileCheck --check-prefix {prefix} "$(dirname %s)"/{output_file}' + + +def validate_test_config(test_config: TestConfig, test_path: str): + if test_config.requires_taint_rules: + rules_path = os.path.join(test_path, "input_rules.txtpb") + if not os.path.exists(rules_path): + tqdm.write( + "Warning: Taint rules file (input_rules.txtpb) not found in" + f" {test_path}." + ) + + +def generate_test_file( + jsir_gen_bin: str, + input_path: str, + output_path: str, + test_config: TestConfig, +): + passes = test_config.passes + output_file = test_config.output_file + prefix = test_config.prefix + + extra_args = get_extra_args( + test_config, os.path.dirname(input_path), for_template=False + ) + + command = ( + f"{jsir_gen_bin}" + f" --input_file={os.path.abspath(input_path)}" + f" --passes='{passes}'" + f"{extra_args}" + ) + + output = run_command(command).decode("utf-8") + output = output.strip() + + if prefix: + lines = output.split("\n") + out_lines = [] + for i, line in enumerate(lines): + if not line: + line = f"// {prefix}-EMPTY:" + elif i == 0: + line = f"// {prefix}: " + line + else: + line = f"// {prefix}-NEXT: " + line + out_lines.append(line) + output = "\n".join(out_lines) + "\n" + else: + output = output + "\n" + if test_config.output_type == "analysis": + output += "\n" + + with open(os.path.join(output_path, output_file), "w") as f: + f.write(output) + + +def generate_readme_files(test_path: str, tests: List[TestConfig]): + readme_groups = {} + for test in tests: + readme_file = test.readme_file + if readme_file not in readme_groups: + readme_groups[readme_file] = [] + readme_groups[readme_file].append(test) + + for readme_file, group_tests in readme_groups.items(): + content = "" + for test in group_tests: + lines = [ + "To run manually:", + "", + "```shell", + "bazel run //maldoca/js/ir:jsir_gen -- \\", + f" --input_file $(pwd)/{test_path}/input.js \\", + ] + + extra_args_list = [] + if test.jsir_analysis: + extra_args_list.append(f"--jsir_analysis {test.jsir_analysis}") + if test.output_type: + extra_args_list.append(f"--output_type {test.output_type}") + if test.requires_taint_rules: + extra_args_list.append( + f"--taint_rules_path $(pwd)/{test_path}/input_rules.txtpb" + ) + + if extra_args_list: + lines.append(f' --passes "{test.passes}" \\') + for i, arg in enumerate(extra_args_list): + if i < len(extra_args_list) - 1: + lines.append(f" {arg} \\") + else: + lines.append(f" {arg}") + else: + lines.append(f' --passes "{test.passes}"') + + lines.extend(["```", ""]) + content += "\n".join(lines) + "\n" + + with open(os.path.join(test_path, readme_file), "w") as f: + f.write(content.strip() + "\n") + + +def generate_lit_files(test_path: str, tests: List[TestConfig]): + lit_groups = {} + for test in tests: + lit_file = test.lit_file + if lit_file not in lit_groups: + lit_groups[lit_file] = [] + lit_groups[lit_file].append(test) + + for lit_file, group_tests in lit_groups.items(): + content = "" + for test in group_tests: + lines = [ + "// RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \\", + '// RUN: jsir_gen --input_file "$(dirname %s)"/input.js \\', + f'// RUN: --passes "{test.passes}" \\', + ] + + extra_args_list = [] + if test.jsir_analysis: + extra_args_list.append(f"--jsir_analysis {test.jsir_analysis}") + if test.output_type: + extra_args_list.append(f"--output_type {test.output_type}") + if test.requires_taint_rules: + extra_args_list.append( + f"--taint_rules_path $(pwd)/{test_path}/input_rules.txtpb" + ) + + if extra_args_list: + for arg in extra_args_list: + lines.append(f"// RUN: {arg} \\") + + check_command = get_check_command(test) + lines.append(f"// RUN: | {check_command}") + + content += "\n".join(lines) + "\n\n" + + with open(os.path.join(test_path, lit_file), "w") as f: + f.write(content.strip() + "\n") + + +def process_test_directory( + jsir_gen_bin: str, + test_path: str, + config: SuiteConfig, + config_dir: str, +): + test_name = os.path.basename(test_path) + tqdm.write(f"Generating test: {test_name}") + + rel_path = os.path.relpath(test_path, config_dir) + tests = config.tests + if rel_path in config.overrides: + tests = config.overrides[rel_path].tests + + for test_config in tests: + validate_test_config(test_config, test_path) + generate_test_file( + jsir_gen_bin=jsir_gen_bin, + input_path=os.path.join(test_path, "input.js"), + output_path=test_path, + test_config=test_config, + ) + + # Handle LIT template/generation + if config.lit_template: + lit_template_path = os.path.join(config_dir, config.lit_template) + shutil.copyfile(lit_template_path, os.path.join(test_path, config.lit_dest)) + else: + generate_lit_files(test_path, tests) + + # Handle README generation + if config.generate_readme: + generate_readme_files(test_path, tests) + + # Handle BUILD template + if config.build_template: + build_template_path = os.path.join(config_dir, config.build_template) + shutil.copyfile(build_template_path, os.path.join(test_path, "BUILD")) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("path", help="Directory to scan for tests") + args = parser.parse_args() + + root_path = args.path + + # Find all config files + config_paths = [] + if os.path.exists(os.path.join(root_path, "test_config.json")): + config_paths.append(os.path.join(root_path, "test_config.json")) + else: + # Recursive scan + for dirpath, _, filenames in os.walk(root_path): + if "test_config.json" in filenames: + config_paths.append(os.path.join(dirpath, "test_config.json")) + + if not config_paths: + print( + f"Error: No test_config.json found in {root_path} or its" + " subdirectories", + file=sys.stderr, + ) + sys.exit(1) + + tqdm.write("Building jsir_gen...") + run_command("bazel build //maldoca/js/ir:jsir_gen") + jsir_gen_bin = os.path.abspath("bazel-bin/maldoca/js/ir/jsir_gen") + + # Flatten tasks + all_tasks = [] + for config_path in config_paths: + config_dir = os.path.dirname(config_path) + with open(config_path, "r") as f: + config = SuiteConfig.from_dict(json.load(f)) + + for test_path, dirnames, file_names_in_dir in os.walk(config_dir): + # Prune subdirectories that have their own config + if test_path != config_dir and "test_config.json" in file_names_in_dir: + dirnames[:] = [] + continue + + if "input.js" in file_names_in_dir: + all_tasks.append((test_path, config, config_dir)) + + with futures.ThreadPoolExecutor() as executor: + futures_list = [ + executor.submit( + process_test_directory, + jsir_gen_bin=jsir_gen_bin, + test_path=test_path, + config=config, + config_dir=config_dir, + ) + for test_path, config, config_dir in all_tasks + ] + for future in tqdm( + futures.as_completed(futures_list), total=len(futures_list) + ): + future.result() + + +if __name__ == "__main__": + main() diff --git a/maldoca/js/ir/ir.cc b/maldoca/js/ir/ir.cc index 66644ae7..aef36cc1 100644 --- a/maldoca/js/ir/ir.cc +++ b/maldoca/js/ir/ir.cc @@ -43,7 +43,6 @@ // Dialect Definition // ============================================================================= -#include "maldoca/js/ir/jshir_dialect.cc.inc" #include "maldoca/js/ir/jsir_dialect.cc.inc" // Dialect initialization, the instance will be owned by the context. This is @@ -67,13 +66,6 @@ void maldoca::JsirDialect::initialize() { JS_NewContext(qjs_runtime.get())); } -void maldoca::JshirDialect::initialize() { - addOperations< -#define GET_OP_LIST -#include "maldoca/js/ir/jshir_ops.cc.inc" - >(); -} - // Hook to materialize a single constant operation from a given attribute value // with the desired resultant type. This method should use the provided builder // to create the operation without changing the insertion position. The diff --git a/maldoca/js/ir/ir.h b/maldoca/js/ir/ir.h index 4f725834..c61f2f1e 100644 --- a/maldoca/js/ir/ir.h +++ b/maldoca/js/ir/ir.h @@ -37,155 +37,155 @@ // A useful macro to pass to FOR_EACH_JSIR_CLASS to ignore a kind of JSIR class. #define JSIR_CLASS_IGNORE(...) -// A list of all JSIR and JSHIR ops and attributes: +// A list of all JSIR ops and attributes: // // - CIR_OP: JsirOp -// - HIR_OP: JshirOp +// - HIR_OP: Unused (formerly JshirOp) // - REF_OP: JsirRefOp // - ATTRIB: JsirAttr #define FOR_EACH_JSIR_CLASS(CIR_OP, HIR_OP, REF_OP, ATTRIB) \ - /* File */ \ - CIR_OP(File) \ - \ - /* Identifiers */ \ - CIR_OP(Identifier) \ - REF_OP(Identifier) \ - ATTRIB(Identifier) \ - CIR_OP(PrivateName) \ - ATTRIB(PrivateName) \ - \ - /* Literals */ \ - ATTRIB(RegExpLiteralExtra) \ - CIR_OP(RegExpLiteral) \ - CIR_OP(NullLiteral) \ - ATTRIB(StringLiteralExtra) \ - CIR_OP(StringLiteral) \ - ATTRIB(StringLiteral) \ - CIR_OP(BooleanLiteral) \ - ATTRIB(NumericLiteralExtra) \ - CIR_OP(NumericLiteral) \ - ATTRIB(NumericLiteral) \ - ATTRIB(BigIntLiteralExtra) \ - CIR_OP(BigIntLiteral) \ - ATTRIB(BigIntLiteral) \ - \ - /* Program */ \ - CIR_OP(Program) \ - \ - /* Statements */ \ - CIR_OP(ExpressionStatement) \ - HIR_OP(BlockStatement) \ - CIR_OP(EmptyStatement) \ - CIR_OP(DebuggerStatement) \ - HIR_OP(WithStatement) \ - CIR_OP(ReturnStatement) \ - HIR_OP(LabeledStatement) \ - HIR_OP(BreakStatement) \ - HIR_OP(ContinueStatement) \ - HIR_OP(IfStatement) \ - HIR_OP(SwitchStatement) \ - HIR_OP(SwitchCase) \ - CIR_OP(ThrowStatement) \ - HIR_OP(TryStatement) \ - HIR_OP(CatchClause) \ - HIR_OP(WhileStatement) \ - HIR_OP(DoWhileStatement) \ - HIR_OP(ForStatement) \ - HIR_OP(ForInStatement) \ - HIR_OP(ForOfStatement) \ - \ - /* Declarations */ \ - CIR_OP(FunctionDeclaration) \ - CIR_OP(VariableDeclaration) \ - CIR_OP(VariableDeclarator) \ - \ - /* Directives */ \ - CIR_OP(Directive) \ - ATTRIB(DirectiveLiteralExtra) \ - CIR_OP(DirectiveLiteral) \ - ATTRIB(InterpreterDirective) \ - \ - /* Expressions */ \ - CIR_OP(Super) \ - CIR_OP(Import) \ - CIR_OP(ThisExpression) \ - CIR_OP(ArrowFunctionExpression) \ - CIR_OP(YieldExpression) \ - CIR_OP(AwaitExpression) \ - CIR_OP(ArrayExpression) \ - CIR_OP(ObjectExpression) \ - CIR_OP(ObjectProperty) \ - REF_OP(ObjectProperty) \ - CIR_OP(ObjectMethod) \ - CIR_OP(FunctionExpression) \ - CIR_OP(UnaryExpression) \ - CIR_OP(UpdateExpression) \ - CIR_OP(BinaryExpression) \ - CIR_OP(AssignmentExpression) \ - HIR_OP(LogicalExpression) \ - CIR_OP(SpreadElement) \ - CIR_OP(MemberExpression) \ - REF_OP(MemberExpression) \ - CIR_OP(OptionalMemberExpression) \ - HIR_OP(ConditionalExpression) \ - CIR_OP(CallExpression) \ - CIR_OP(OptionalCallExpression) \ - CIR_OP(NewExpression) \ - CIR_OP(SequenceExpression) \ - CIR_OP(ParenthesizedExpression) \ - REF_OP(ParenthesizedExpression) \ - CIR_OP(TemplateLiteral) \ - CIR_OP(TaggedTemplateExpression) \ - CIR_OP(TemplateElementValue) \ - CIR_OP(TemplateElement) \ - \ - /* Patterns */ \ - REF_OP(ObjectPattern) \ - REF_OP(ArrayPattern) \ - REF_OP(RestElement) \ - REF_OP(AssignmentPattern) \ - \ - /* Classes */ \ - CIR_OP(ClassBody) \ - CIR_OP(ClassMethod) \ - CIR_OP(ClassPrivateMethod) \ - CIR_OP(ClassProperty) \ - CIR_OP(ClassPrivateProperty) \ - CIR_OP(ClassDeclaration) \ - CIR_OP(ClassExpression) \ - \ - /* Modules */ \ - CIR_OP(MetaProperty) \ - CIR_OP(ImportDeclaration) \ - ATTRIB(ImportSpecifier) \ - ATTRIB(ImportDefaultSpecifier) \ - ATTRIB(ImportNamespaceSpecifier) \ - ATTRIB(ImportAttribute) \ - CIR_OP(ExportNamedDeclaration) \ - ATTRIB(ExportSpecifier) \ - CIR_OP(ExportDefaultDeclaration) \ + /* File */ \ + CIR_OP(File) \ + \ + /* Identifiers */ \ + CIR_OP(Identifier) \ + REF_OP(Identifier) \ + ATTRIB(Identifier) \ + CIR_OP(PrivateName) \ + ATTRIB(PrivateName) \ + \ + /* Literals */ \ + ATTRIB(RegExpLiteralExtra) \ + CIR_OP(RegExpLiteral) \ + CIR_OP(NullLiteral) \ + ATTRIB(StringLiteralExtra) \ + CIR_OP(StringLiteral) \ + ATTRIB(StringLiteral) \ + CIR_OP(BooleanLiteral) \ + ATTRIB(NumericLiteralExtra) \ + CIR_OP(NumericLiteral) \ + ATTRIB(NumericLiteral) \ + ATTRIB(BigIntLiteralExtra) \ + CIR_OP(BigIntLiteral) \ + ATTRIB(BigIntLiteral) \ + \ + /* Program */ \ + CIR_OP(Program) \ + \ + /* Statements */ \ + CIR_OP(ExpressionStatement) \ + CIR_OP(BlockStatement) \ + CIR_OP(EmptyStatement) \ + CIR_OP(DebuggerStatement) \ + CIR_OP(WithStatement) \ + CIR_OP(ReturnStatement) \ + CIR_OP(LabeledStatement) \ + CIR_OP(BreakStatement) \ + CIR_OP(ContinueStatement) \ + CIR_OP(IfStatement) \ + CIR_OP(SwitchStatement) \ + CIR_OP(SwitchCase) \ + CIR_OP(ThrowStatement) \ + CIR_OP(TryStatement) \ + CIR_OP(CatchClause) \ + CIR_OP(WhileStatement) \ + CIR_OP(DoWhileStatement) \ + CIR_OP(ForStatement) \ + CIR_OP(ForInStatement) \ + CIR_OP(ForOfStatement) \ + \ + /* Declarations */ \ + CIR_OP(FunctionDeclaration) \ + CIR_OP(VariableDeclaration) \ + CIR_OP(VariableDeclarator) \ + \ + /* Directives */ \ + CIR_OP(Directive) \ + ATTRIB(DirectiveLiteralExtra) \ + CIR_OP(DirectiveLiteral) \ + ATTRIB(InterpreterDirective) \ + \ + /* Expressions */ \ + CIR_OP(Super) \ + CIR_OP(Import) \ + CIR_OP(ThisExpression) \ + CIR_OP(ArrowFunctionExpression) \ + CIR_OP(YieldExpression) \ + CIR_OP(AwaitExpression) \ + CIR_OP(ArrayExpression) \ + CIR_OP(ObjectExpression) \ + CIR_OP(ObjectProperty) \ + REF_OP(ObjectProperty) \ + CIR_OP(ObjectMethod) \ + CIR_OP(FunctionExpression) \ + CIR_OP(UnaryExpression) \ + CIR_OP(UpdateExpression) \ + CIR_OP(BinaryExpression) \ + CIR_OP(AssignmentExpression) \ + CIR_OP(LogicalExpression) \ + CIR_OP(SpreadElement) \ + CIR_OP(MemberExpression) \ + REF_OP(MemberExpression) \ + CIR_OP(OptionalMemberExpression) \ + CIR_OP(ConditionalExpression) \ + CIR_OP(CallExpression) \ + CIR_OP(OptionalCallExpression) \ + CIR_OP(NewExpression) \ + CIR_OP(SequenceExpression) \ + CIR_OP(ParenthesizedExpression) \ + REF_OP(ParenthesizedExpression) \ + CIR_OP(TemplateLiteral) \ + CIR_OP(TaggedTemplateExpression) \ + CIR_OP(TemplateElementValue) \ + CIR_OP(TemplateElement) \ + \ + /* Patterns */ \ + REF_OP(ObjectPattern) \ + REF_OP(ArrayPattern) \ + REF_OP(RestElement) \ + REF_OP(AssignmentPattern) \ + \ + /* Classes */ \ + CIR_OP(ClassBody) \ + CIR_OP(ClassMethod) \ + CIR_OP(ClassPrivateMethod) \ + CIR_OP(ClassProperty) \ + CIR_OP(ClassPrivateProperty) \ + CIR_OP(ClassDeclaration) \ + CIR_OP(ClassExpression) \ + \ + /* Modules */ \ + CIR_OP(MetaProperty) \ + CIR_OP(ImportDeclaration) \ + ATTRIB(ImportSpecifier) \ + ATTRIB(ImportDefaultSpecifier) \ + ATTRIB(ImportNamespaceSpecifier) \ + ATTRIB(ImportAttribute) \ + CIR_OP(ExportNamedDeclaration) \ + ATTRIB(ExportSpecifier) \ + CIR_OP(ExportDefaultDeclaration) \ CIR_OP(ExportAllDeclaration) // JsirStatementOpInterface #define FOR_EACH_JSIR_STATEMENT_OP(CIR, HIR) \ CIR(ExpressionStatement) \ - HIR(BlockStatement) \ + CIR(BlockStatement) \ CIR(EmptyStatement) \ CIR(DebuggerStatement) \ - HIR(WithStatement) \ + CIR(WithStatement) \ CIR(ReturnStatement) \ - HIR(LabeledStatement) \ - HIR(BreakStatement) \ - HIR(ContinueStatement) \ - HIR(IfStatement) \ - HIR(SwitchStatement) \ + CIR(LabeledStatement) \ + CIR(BreakStatement) \ + CIR(ContinueStatement) \ + CIR(IfStatement) \ + CIR(SwitchStatement) \ CIR(ThrowStatement) \ - HIR(TryStatement) \ - HIR(WhileStatement) \ - HIR(DoWhileStatement) \ - HIR(ForStatement) \ - HIR(ForInStatement) \ - HIR(ForOfStatement) \ + CIR(TryStatement) \ + CIR(WhileStatement) \ + CIR(DoWhileStatement) \ + CIR(ForStatement) \ + CIR(ForInStatement) \ + CIR(ForOfStatement) \ CIR(FunctionDeclaration) \ CIR(VariableDeclaration) \ CIR(ClassDeclaration) @@ -210,10 +210,10 @@ CIR(UpdateExpression) \ CIR(BinaryExpression) \ CIR(AssignmentExpression) \ - HIR(LogicalExpression) \ + CIR(LogicalExpression) \ CIR(MemberExpression) \ CIR(OptionalMemberExpression) \ - HIR(ConditionalExpression) \ + CIR(ConditionalExpression) \ CIR(CallExpression) \ CIR(OptionalCallExpression) \ CIR(NewExpression) \ @@ -317,7 +317,6 @@ QjsValue EmulateUnaryOp(JSContext *qjs_context, std::string op, // Include the auto-generated header file containing the declaration of the JSIR // dialect. -#include "maldoca/js/ir/jshir_dialect.h.inc" #include "maldoca/js/ir/jsir_dialect.h.inc" // Include the auto-generated header file containing the declarations of the @@ -343,7 +342,5 @@ QjsValue EmulateUnaryOp(JSContext *qjs_context, std::string op, // JSIR operations. #define GET_OP_CLASSES #include "maldoca/js/ir/jsir_ops.h.inc" -#define GET_OP_CLASSES -#include "maldoca/js/ir/jshir_ops.h.inc" #endif // MALDOCA_JS_IR_IR_H_ diff --git a/maldoca/js/ir/jshir_ops.cc b/maldoca/js/ir/jshir_ops.cc deleted file mode 100644 index 27a34d26..00000000 --- a/maldoca/js/ir/jshir_ops.cc +++ /dev/null @@ -1,29 +0,0 @@ -// Copyright 2024 Google LLC -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// https://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -// IWYU pragma: begin_keep - -#include "llvm/ADT/ArrayRef.h" -#include "mlir/IR/Attributes.h" -#include "mlir/IR/Builders.h" -#include "mlir/IR/BuiltinAttributes.h" -#include "mlir/IR/BuiltinTypes.h" -#include "mlir/IR/OpDefinition.h" -#include "mlir/IR/OpImplementation.h" -#include "maldoca/js/ir/ir.h" - -// IWYU pragma: end_keep - -#define GET_OP_CLASSES -#include "maldoca/js/ir/jshir_ops.cc.inc" diff --git a/maldoca/js/ir/jsir_dialect.td b/maldoca/js/ir/jsir_dialect.td index b14d0f2e..828daf36 100644 --- a/maldoca/js/ir/jsir_dialect.td +++ b/maldoca/js/ir/jsir_dialect.td @@ -63,17 +63,6 @@ class OptionalRegion : Region< region.summary >; -def Jshir_Dialect : Dialect { - let name = "jshir"; - let cppNamespace = "::maldoca"; -} -// Base class for JSHIR dialect operations. -// This operation inherits from the base `Op` class in OpBase.td, and provides: -// - The parent dialect of the operation. -// - The mnemonic for the operation, or the name without the dialect prefix. -// - A list of traits for the operation. -class Jshir_Op traits = []> : - Op; #endif // MALDOCA_JS_IR_JSIR_DIALECT_TD_ diff --git a/maldoca/js/ir/jsir_gen.cc b/maldoca/js/ir/jsir_gen.cc index 24f6cf80..b8f62446 100644 --- a/maldoca/js/ir/jsir_gen.cc +++ b/maldoca/js/ir/jsir_gen.cc @@ -18,7 +18,7 @@ // // bazel run //maldoca/js/ir:jsir_gen -- \ // --input_file=test.js \ -// --output_dialect=jshir +// --passes=source2ast,ast2jsir #include #include @@ -48,8 +48,10 @@ static auto* kStringToPassKind = new absl::flat_hash_map{ {"source2ast", maldoca::JsirPassKind::kSourceToAst}, - {"ast2hir", maldoca::JsirPassKind::kAstToJshir}, - {"hir2ast", maldoca::JsirPassKind::kJshirToAst}, + {"ast2jsir", maldoca::JsirPassKind::kAstToJsir}, + {"ast2hir", maldoca::JsirPassKind::kAstToJsir}, + {"jsir2ast", maldoca::JsirPassKind::kJsirToAst}, + {"hir2ast", maldoca::JsirPassKind::kJsirToAst}, {"ast2source", maldoca::JsirPassKind::kAstToSource}, {"erase_comments", maldoca::JsirPassKind::kEraseComments}, diff --git a/maldoca/js/ir/jsir_gen_lib.cc b/maldoca/js/ir/jsir_gen_lib.cc index 19262a27..fb453929 100644 --- a/maldoca/js/ir/jsir_gen_lib.cc +++ b/maldoca/js/ir/jsir_gen_lib.cc @@ -183,9 +183,9 @@ absl::StatusOr JsirGen( break; } - case JsirPassKind::kAstToJshir: { + case JsirPassKind::kAstToJsir: { JsConversionConfig conversion; - *conversion.mutable_js_ast_to_hir() = {}; + *conversion.mutable_js_ast_to_jsir() = {}; *pass_configs.add_passes()->mutable_conversion() = std::move(conversion); @@ -193,9 +193,9 @@ absl::StatusOr JsirGen( break; } - case JsirPassKind::kJshirToAst: { + case JsirPassKind::kJsirToAst: { JsConversionConfig conversion; - *conversion.mutable_js_hir_to_ast() = {}; + *conversion.mutable_jsir_to_ast() = {}; *pass_configs.add_passes()->mutable_conversion() = std::move(conversion); diff --git a/maldoca/js/ir/jsir_gen_lib.h b/maldoca/js/ir/jsir_gen_lib.h index 2160c475..e88c0145 100644 --- a/maldoca/js/ir/jsir_gen_lib.h +++ b/maldoca/js/ir/jsir_gen_lib.h @@ -31,8 +31,8 @@ namespace maldoca { enum class JsirPassKind { // Conversion kSourceToAst, - kAstToJshir, - kJshirToAst, + kAstToJsir, + kJsirToAst, kAstToSource, // Transform diff --git a/maldoca/js/ir/jsir_ops.generated.td b/maldoca/js/ir/jsir_ops.generated.td index 2814e052..86b457f6 100644 --- a/maldoca/js/ir/jsir_ops.generated.td +++ b/maldoca/js/ir/jsir_ops.generated.td @@ -296,7 +296,7 @@ def JsirBigIntLiteralOp : Jsir_Op< ); } -def JshirBlockStatementOp : Jshir_Op< +def JsirBlockStatementOp : Jsir_Op< "block_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -328,7 +328,7 @@ def JsirDebuggerStatementOp : Jsir_Op< ]> { } -def JshirWithStatementOp : Jshir_Op< +def JsirWithStatementOp : Jsir_Op< "with_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -351,7 +351,7 @@ def JsirReturnStatementOp : Jsir_Op< ); } -def JshirLabeledStatementOp : Jshir_Op< +def JsirLabeledStatementOp : Jsir_Op< "labeled_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -365,7 +365,7 @@ def JshirLabeledStatementOp : Jshir_Op< ); } -def JshirIfStatementOp : Jshir_Op< +def JsirIfStatementOp : Jsir_Op< "if_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -380,7 +380,7 @@ def JshirIfStatementOp : Jshir_Op< ); } -def JshirSwitchCaseOp : Jshir_Op< +def JsirSwitchCaseOp : Jsir_Op< "switch_case", [ NoTerminator ]> { @@ -390,7 +390,7 @@ def JshirSwitchCaseOp : Jshir_Op< ); } -def JshirSwitchStatementOp : Jshir_Op< +def JsirSwitchStatementOp : Jsir_Op< "switch_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -413,7 +413,7 @@ def JsirThrowStatementOp : Jsir_Op< ); } -def JshirCatchClauseOp : Jshir_Op< +def JsirCatchClauseOp : Jsir_Op< "catch_clause", [ NoTerminator ]> { @@ -426,7 +426,7 @@ def JshirCatchClauseOp : Jshir_Op< ); } -def JshirTryStatementOp : Jshir_Op< +def JsirTryStatementOp : Jsir_Op< "try_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -438,7 +438,7 @@ def JshirTryStatementOp : Jshir_Op< ); } -def JshirWhileStatementOp : Jshir_Op< +def JsirWhileStatementOp : Jsir_Op< "while_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -449,7 +449,7 @@ def JshirWhileStatementOp : Jshir_Op< ); } -def JshirDoWhileStatementOp : Jshir_Op< +def JsirDoWhileStatementOp : Jsir_Op< "do_while_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -667,7 +667,7 @@ def JsirAssignmentExpressionOp : Jsir_Op< ); } -def JshirLogicalExpressionOp : Jshir_Op< +def JsirLogicalExpressionOp : Jsir_Op< "logical_expression", [ JsirExpressionOpInterfaceTraits, NoTerminator, @@ -687,7 +687,7 @@ def JshirLogicalExpressionOp : Jshir_Op< ); } -def JshirConditionalExpressionOp : Jshir_Op< +def JsirConditionalExpressionOp : Jsir_Op< "conditional_expression", [ JsirExpressionOpInterfaceTraits, NoTerminator diff --git a/maldoca/js/ir/jsir_ops.td b/maldoca/js/ir/jsir_ops.td index 513c50cb..84a30e94 100644 --- a/maldoca/js/ir/jsir_ops.td +++ b/maldoca/js/ir/jsir_ops.td @@ -35,9 +35,9 @@ def JsirNoneOp : Jsir_Op<"none", [Pure]> { // BreakStatement-Related Ops // -// jshir.break_statement (%label optional argument) +// jsir.break_statement (%label optional argument) -def JshirBreakStatementOp : Jshir_Op< +def JsirBreakStatementOp : Jsir_Op< "break_statement", [ JsirStatementOpInterfaceTraits ]> { @@ -48,9 +48,9 @@ def JshirBreakStatementOp : Jshir_Op< // ContinueStatement-Related Ops // -// jshir.continue_statement (%label optional argument) +// jsir.continue_statement (%label optional argument) -def JshirContinueStatementOp : Jshir_Op< +def JsirContinueStatementOp : Jsir_Op< "continue_statement", [ JsirStatementOpInterfaceTraits ]> { @@ -61,7 +61,7 @@ def JshirContinueStatementOp : Jshir_Op< // ForStatement-Related Ops // -// jshir.for_statement ( { +// jsir.for_statement ( { // %init = ... // jsir.expr_region_end (%init) // }, { @@ -74,7 +74,7 @@ def JshirContinueStatementOp : Jshir_Op< // ... // body // }) -def JshirForStatementOp : Jshir_Op< +def JsirForStatementOp : Jsir_Op< "for_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -91,15 +91,15 @@ def JshirForStatementOp : Jshir_Op< // // %left = ... // %right = ... -// jshir.for_in_statement (%left, %right) { +// jsir.for_in_statement (%left, %right) { // ... // body // }) // - OR - -// jshir.for_of_statement (%left, %right) { +// jsir.for_of_statement (%left, %right) { // ... // body // }) {await = true} -def JshirForInStatementOp : Jshir_Op< +def JsirForInStatementOp : Jsir_Op< "for_in_statement", [ JsirStatementOpInterfaceTraits, NoTerminator @@ -115,7 +115,7 @@ def JshirForInStatementOp : Jshir_Op< ); } -def JshirForOfStatementOp : Jshir_Op< +def JsirForOfStatementOp : Jsir_Op< "for_of_statement", [ JsirStatementOpInterfaceTraits, NoTerminator diff --git a/maldoca/js/ir/jsir_utils.cc b/maldoca/js/ir/jsir_utils.cc index 9b0d8d9b..6532996f 100644 --- a/maldoca/js/ir/jsir_utils.cc +++ b/maldoca/js/ir/jsir_utils.cc @@ -99,22 +99,22 @@ bool IsStatementBlock(mlir::Block &block) { return false; } - return llvm::TypeSwitch(region->getParentOp()) - .Case([&](JshirWithStatementOp parent_op) { + return llvm::TypeSwitch(region->getParentOp()) + .Case([&](JsirWithStatementOp parent_op) { // interface WithStatement <: Statement { // object: Expression; // body: Statement; // } return region == &parent_op.getBody(); }) - .Case([&](JshirLabeledStatementOp parent_op) { + .Case([&](JsirLabeledStatementOp parent_op) { // interface LabeledStatement <: Statement { // label: Identifier; // body: Statement; // } return region == &parent_op.getBody(); }) - .Case([&](JshirIfStatementOp parent_op) { + .Case([&](JsirIfStatementOp parent_op) { // interface IfStatement <: Statement { // test: Expression; // consequent: Statement; @@ -123,21 +123,21 @@ bool IsStatementBlock(mlir::Block &block) { return region == &parent_op.getConsequent() || region == &parent_op.getAlternate(); }) - .Case([&](JshirWhileStatementOp parent_op) { + .Case([&](JsirWhileStatementOp parent_op) { // interface WhileStatement <: Statement { // test: Expression; // body: Statement; // } return region == &parent_op.getBody(); }) - .Case([&](JshirDoWhileStatementOp parent_op) { + .Case([&](JsirDoWhileStatementOp parent_op) { // interface DoWhileStatement <: Statement { // body: Statement; // test: Expression; // } return region == &parent_op.getBody(); }) - .Case([&](JshirForStatementOp parent_op) { + .Case([&](JsirForStatementOp parent_op) { // interface ForStatement <: Statement { // init: VariableDeclaration | Expression | null; // test: Expression | null; @@ -146,7 +146,7 @@ bool IsStatementBlock(mlir::Block &block) { // } return region == &parent_op.getBody(); }) - .Case([&](JshirForInStatementOp parent_op) { + .Case([&](JsirForInStatementOp parent_op) { // interface ForInStatement <: Statement { // left: VariableDeclaration | LVal; // right: Expression; @@ -154,7 +154,7 @@ bool IsStatementBlock(mlir::Block &block) { // } return region == &parent_op.getBody(); }) - .Case([&](JshirForOfStatementOp parent_op) { + .Case([&](JsirForOfStatementOp parent_op) { // interface ForOfStatement <: Statement { // left: VariableDeclaration | LVal; // right: Expression; @@ -186,7 +186,7 @@ void WrapBlockContentWithBlockStatement(mlir::Block &block) { // After: // // ^block: - // JshirBlockStatement(/*directives=*/{}, /*body=*/{}) + // JsirBlockStatement(/*directives=*/{}, /*body=*/{}) // // ^new_block: // op1 @@ -194,7 +194,7 @@ void WrapBlockContentWithBlockStatement(mlir::Block &block) { // ... mlir::OpBuilder builder{context}; builder.setInsertionPointToStart(&block); - auto block_stmt_op = JshirBlockStatementOp::create(builder, region->getLoc()); + auto block_stmt_op = JsirBlockStatementOp::create(builder, region->getLoc()); // `directives` is empty, but we need to keep an empty block in the region. block_stmt_op.getDirectives().emplaceBlock(); @@ -202,7 +202,7 @@ void WrapBlockContentWithBlockStatement(mlir::Block &block) { // After: // // ^block: - // JshirBlockStatement( + // JsirBlockStatement( // /*directives=*/{ // ^empty_block: // }, diff --git a/maldoca/js/ir/jsir_utils.h b/maldoca/js/ir/jsir_utils.h index 7d5fdeb5..1936752b 100644 --- a/maldoca/js/ir/jsir_utils.h +++ b/maldoca/js/ir/jsir_utils.h @@ -89,12 +89,12 @@ auto FilterBlockOps(mlir::Block &block) { // Infers if this block should contain a single statement. bool IsStatementBlock(mlir::Block &block); -// TODO(tzx) Implement a standalone pass to add `jshir.block_statement`. +// TODO(tzx) Implement a standalone pass to add `jsir.block_statement`. // // We shouldn't require each individual pass to maintain the invariant that // certain `mlir::Block`s should only contain a single statement - a // `mlir::Block` should always allow multiple statements, and we should -// automatically add `jshir.block_statement`s when lifting JSHIR to AST. +// automatically add `jsir.block_statement`s when lifting JSIR to AST. void WrapBlockContentWithBlockStatement(mlir::Block &block); } // namespace maldoca diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/if/README.generated.md index 5cbfcab4..b9dd1ff2 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/if/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/if/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/README.generated.md index 2a0c28b4..1894f268 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/if_join/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/simple/README.generated.md index a4f651bf..91d890d0 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/simple/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/simple/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/README.generated.md index e6391fff..443deee2 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/README.generated.md index 442aac43..896f6cd5 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/test_config.json b/maldoca/js/ir/transforms/constant_propagation/tests/test_config.json new file mode 100644 index 00000000..4389500c --- /dev/null +++ b/maldoca/js/ir/transforms/constant_propagation/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir,constprop,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/README.generated.md index 98505055..ed0892c9 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/void_0/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/while/README.generated.md b/maldoca/js/ir/transforms/constant_propagation/tests/while/README.generated.md index d1d65e43..f19878e0 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/while/README.generated.md +++ b/maldoca/js/ir/transforms/constant_propagation/tests/while/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/constant_propagation/tests/while/input.js \ - --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" + --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/while/run.generated.lit b/maldoca/js/ir/transforms/constant_propagation/tests/while/run.generated.lit index 1fee49c9..fbbeec68 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/while/run.generated.lit +++ b/maldoca/js/ir/transforms/constant_propagation/tests/while/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,constprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,constprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dead_code_elimination/pass.cc b/maldoca/js/ir/transforms/dead_code_elimination/pass.cc index 7981ccbf..23cd86bc 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/pass.cc +++ b/maldoca/js/ir/transforms/dead_code_elimination/pass.cc @@ -37,7 +37,7 @@ namespace maldoca { void IfStatementElimination(mlir::Operation* root_op) { - root_op->walk([&](JshirIfStatementOp op) { + root_op->walk([&](JsirIfStatementOp op) { auto condition = op.getTest().getDefiningOp(); if (condition == nullptr) { return; @@ -72,7 +72,7 @@ void IfStatementElimination(mlir::Operation* root_op) { } void WhileStatementElimination(mlir::Operation* root_op) { - root_op->walk([&](JshirWhileStatementOp op) { + root_op->walk([&](JsirWhileStatementOp op) { auto condition_op = GetExprRegionOp(op.getTest()); if (!condition_op.ok()) { return; diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/README.generated.md b/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/README.generated.md index c44673f8..c647d6ce 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/README.generated.md +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/input.js \ - --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" + --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/run.generated.lit b/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/run.generated.lit index 408844b6..82faf7dc 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/run.generated.lit +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/after_dynconstprop/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/README.generated.md b/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/README.generated.md index 1f9745ba..6337865d 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/README.generated.md +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/input.js \ - --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" + --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/run.generated.lit b/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/run.generated.lit index 408844b6..82faf7dc 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/if_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/test_config.json b/maldoca/js/ir/transforms/dead_code_elimination/tests/test_config.json new file mode 100644 index 00000000..49aaaa56 --- /dev/null +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/README.generated.md b/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/README.generated.md index ff3e1e29..45970e81 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/README.generated.md +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/input.js \ - --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" + --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/run.generated.lit b/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/run.generated.lit index 408844b6..82faf7dc 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/run.generated.lit +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/unused_function/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/README.generated.md b/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/README.generated.md index a796c467..59767983 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/README.generated.md +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/input.js \ - --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" + --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/run.generated.lit b/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/run.generated.lit index 408844b6..82faf7dc 100644 --- a/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/dead_code_elimination/tests/while_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,dead_code_elimination,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/README.generated.md index 80a48025..07d41f88 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/atob/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/README.generated.md index ebb08d62..050b2436 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/output.generated.txt index ffda4bd5..d5594860 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/output.generated.txt @@ -338,7 +338,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -390,7 +390,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -416,7 +416,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -496,7 +496,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -614,7 +614,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -640,7 +640,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -744,7 +744,7 @@ // SOURCE-NEXT: %133 = jsir.call_expression (%119, %120, %132) // SOURCE-NEXT: // %133 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%133) ({ +// SOURCE-NEXT: jsir.if_statement (%133) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -763,7 +763,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -777,7 +777,7 @@ // SOURCE-NEXT: %141 = jsir.identifier {"_0x555f00"} // SOURCE-NEXT: // %141 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %142 = jshir.conditional_expression (%141) ({ +// SOURCE-NEXT: %142 = jsir.conditional_expression (%141) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -791,7 +791,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -820,7 +820,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -846,7 +846,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -899,11 +899,11 @@ // SOURCE-NEXT: %145 = jsir.identifier {"_0x4e326e"} // SOURCE-NEXT: // %145 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%145) ({ +// SOURCE-NEXT: jsir.if_statement (%145) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1077,7 +1077,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1108,7 +1108,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1151,7 +1151,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1221,7 +1221,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1264,7 +1264,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1388,7 +1388,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1455,7 +1455,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1519,7 +1519,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1643,7 +1643,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1686,7 +1686,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1740,7 +1740,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1766,7 +1766,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1841,7 +1841,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1966,7 +1966,7 @@ // SOURCE-NEXT: %142 = jsir.call_expression (%125, %133, %141) // SOURCE-NEXT: // %142 = false // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%142) ({ +// SOURCE-NEXT: jsir.if_statement (%142) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2180,7 +2180,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2198,11 +2198,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2350,11 +2350,11 @@ // SOURCE-NEXT: %144 = jsir.identifier_ref {"_0x306e21"} // SOURCE-NEXT: // %144 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%144) ({ +// SOURCE-NEXT: jsir.catch_clause (%144) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2403,22 +2403,22 @@ // SOURCE-NEXT: %159 = jsir.call_expression (%147, %155, %158) // SOURCE-NEXT: // %159 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%159) ({ +// SOURCE-NEXT: jsir.if_statement (%159) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %160 = jsir.identifier {"_0x28fe3a"} // SOURCE-NEXT: // %160 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%160) ({ +// SOURCE-NEXT: jsir.if_statement (%160) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2616,7 +2616,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2703,7 +2703,7 @@ // SOURCE-NEXT: %116 = jsir.member_expression (%109, %115) // SOURCE-NEXT: // %116 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %117 = jshir.logical_expression (%116) {"||"} ({ +// SOURCE-NEXT: %117 = jsir.logical_expression (%116) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2753,7 +2753,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2907,7 +2907,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.for_statement ({ +// SOURCE-NEXT: jsir.for_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3025,7 +3025,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3068,11 +3068,11 @@ // SOURCE-NEXT: %112 = jsir.call_expression (%102, %108, %111) // SOURCE-NEXT: // %112 = true // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%112) ({ +// SOURCE-NEXT: jsir.if_statement (%112) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3191,7 +3191,7 @@ // SOURCE-NEXT: %195 = jsir.member_expression (%193, %194) // SOURCE-NEXT: // %195 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %196 = jshir.logical_expression (%195) {"||"} ({ +// SOURCE-NEXT: %196 = jsir.logical_expression (%195) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3360,7 +3360,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3370,7 +3370,7 @@ // SOURCE-NEXT: %114 = jsir.unary_expression (%113) {"!", true} // SOURCE-NEXT: // %114 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%114) ({ +// SOURCE-NEXT: jsir.if_statement (%114) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3612,7 +3612,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3721,7 +3721,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4250,11 +4250,11 @@ // SOURCE-NEXT: %86 = jsir.identifier {"functionNames"} // SOURCE-NEXT: // %86 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.for_of_statement (%85, %86) {false, #jsir, , 12590, 12600, 49, , , 12596, 12600, 49, "name", 49, "const">} ({ +// SOURCE-NEXT: jsir.for_of_statement (%85, %86) {false, #jsir, , 12590, 12600, 49, , , 12596, 12600, 49, "name", 49, "const">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4283,7 +4283,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4309,7 +4309,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4390,7 +4390,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4486,7 +4486,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4512,7 +4512,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4584,7 +4584,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4775,7 +4775,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4873,7 +4873,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4929,7 +4929,7 @@ // SOURCE-NEXT: %130 = jsir.unary_expression (%129) {"!", true} // SOURCE-NEXT: // %130 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%130) ({ +// SOURCE-NEXT: jsir.if_statement (%130) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5014,7 +5014,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5139,11 +5139,11 @@ // SOURCE-NEXT: %88 = jsir.identifier {"propertyNames"} // SOURCE-NEXT: // %88 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.for_of_statement (%87, %88) {false, #jsir, , 14330, 14340, 61, , , 14336, 14340, 61, "name", 61, "const">} ({ +// SOURCE-NEXT: jsir.for_of_statement (%87, %88) {false, #jsir, , 14330, 14340, 61, , , 14336, 14340, 61, "name", 61, "const">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5191,7 +5191,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5217,7 +5217,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5300,7 +5300,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5381,7 +5381,7 @@ // SOURCE-NEXT: %105 = jsir.unary_expression (%104) {"!", true} // SOURCE-NEXT: // %105 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%105) ({ +// SOURCE-NEXT: jsir.if_statement (%105) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5471,7 +5471,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5497,7 +5497,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5572,7 +5572,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/babel/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/README.generated.md index 9396bf51..1e09b7c4 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/output.generated.txt index 5b730a0f..a32e424a 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/output.generated.txt @@ -39,7 +39,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%5) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/btoa/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/README.generated.md index c6ec25b8..7e88d6fd 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/output.generated.txt index 90363b81..74b21ac6 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/output.generated.txt @@ -39,7 +39,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -75,7 +75,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -129,7 +129,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/complex_wrapper/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/README.generated.md index a21a3f77..40bdbf3c 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/output.generated.txt index a25e65e5..61748963 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/output.generated.txt @@ -340,7 +340,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -371,7 +371,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -435,7 +435,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -541,7 +541,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -584,7 +584,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -723,7 +723,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -901,7 +901,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -986,7 +986,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1038,7 +1038,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1081,7 +1081,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1107,7 +1107,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1161,7 +1161,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1247,11 +1247,11 @@ // SOURCE-NEXT: %53 = jsir.call_expression (%38, %46, %52) // SOURCE-NEXT: // %53 = false // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%53) ({ +// SOURCE-NEXT: jsir.if_statement (%53) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1265,7 +1265,7 @@ // SOURCE-NEXT: %61 = jsir.identifier {"_0x3f313a"} // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %62 = jshir.conditional_expression (%61) ({ +// SOURCE-NEXT: %62 = jsir.conditional_expression (%61) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1279,7 +1279,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1308,7 +1308,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1334,7 +1334,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1390,11 +1390,11 @@ // SOURCE-NEXT: %65 = jsir.identifier {"_0x330f38"} // SOURCE-NEXT: // %65 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%65) ({ +// SOURCE-NEXT: jsir.if_statement (%65) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1534,7 +1534,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1548,7 +1548,7 @@ // SOURCE-NEXT: %61 = jsir.identifier {"_0x10bab4"} // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %62 = jshir.conditional_expression (%61) ({ +// SOURCE-NEXT: %62 = jsir.conditional_expression (%61) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1562,7 +1562,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1591,18 +1591,18 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %65 = jsir.identifier {"_0x4f3fc0"} // SOURCE-NEXT: // %65 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%65) ({ +// SOURCE-NEXT: jsir.if_statement (%65) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1768,7 +1768,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1826,7 +1826,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1852,7 +1852,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1924,7 +1924,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2019,11 +2019,11 @@ // SOURCE-NEXT: %50 = jsir.call_expression (%38, %41, %49) // SOURCE-NEXT: // %50 = false // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%50) ({ +// SOURCE-NEXT: jsir.if_statement (%50) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2110,7 +2110,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2129,7 +2129,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2145,11 +2145,11 @@ // SOURCE-NEXT: %54 = jsir.member_expression (%51, %53) // SOURCE-NEXT: // %54 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%54) ({ +// SOURCE-NEXT: jsir.switch_statement (%54) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2179,11 +2179,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%59) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2212,7 +2212,7 @@ // SOURCE-NEXT: %58 = jsir.member_expression (%56, %57) // SOURCE-NEXT: // %58 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %59 = jshir.logical_expression (%58) {"||"} ({ +// SOURCE-NEXT: %59 = jsir.logical_expression (%58) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2231,11 +2231,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2271,11 +2271,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2368,11 +2368,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%80) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2429,11 +2429,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%68) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2523,13 +2523,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: @@ -2549,7 +2549,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2651,7 +2651,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x50c043#40 : 0.000000e+00 : f64> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x50c043#40 : 0.000000e+00 : f64> } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2670,7 +2670,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2686,11 +2686,11 @@ // SOURCE-NEXT: %54 = jsir.member_expression (%51, %53) // SOURCE-NEXT: // %54 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%54) ({ +// SOURCE-NEXT: jsir.switch_statement (%54) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2703,11 +2703,11 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2872,11 +2872,11 @@ // SOURCE-NEXT: %55 = jsir.identifier_ref {"_0x455513"} // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%55) ({ +// SOURCE-NEXT: jsir.catch_clause (%55) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2902,11 +2902,11 @@ // SOURCE-NEXT: }, { // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2919,7 +2919,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.for_statement ({ +// SOURCE-NEXT: jsir.for_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3052,7 +3052,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3142,7 +3142,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x92b385#40 : 0.000000e+00 : f64> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x92b385#40 : 0.000000e+00 : f64> } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3161,7 +3161,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3177,11 +3177,11 @@ // SOURCE-NEXT: %58 = jsir.member_expression (%55, %57) // SOURCE-NEXT: // %58 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%58) ({ +// SOURCE-NEXT: jsir.switch_statement (%58) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3217,11 +3217,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3251,11 +3251,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%63) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3284,7 +3284,7 @@ // SOURCE-NEXT: %62 = jsir.member_expression (%60, %61) // SOURCE-NEXT: // %62 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %63 = jshir.logical_expression (%62) {"||"} ({ +// SOURCE-NEXT: %63 = jsir.logical_expression (%62) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3303,11 +3303,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3412,11 +3412,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3488,11 +3488,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%77) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3585,13 +3585,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%84) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: @@ -3609,11 +3609,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3640,11 +3640,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3821,11 +3821,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3878,7 +3878,7 @@ // SOURCE-NEXT: %66 = jsir.member_expression (%64, %65) // SOURCE-NEXT: // %66 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %67 = jshir.logical_expression (%66) {"||"} ({ +// SOURCE-NEXT: %67 = jsir.logical_expression (%66) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3906,13 +3906,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/README.generated.md index e25129ba..1116a50a 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/output.generated.txt index bd37d35d..c1062e22 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/output.generated.txt @@ -340,7 +340,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -371,7 +371,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -420,7 +420,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -481,7 +481,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -524,7 +524,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -579,7 +579,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -661,7 +661,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -725,7 +725,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -777,7 +777,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -820,7 +820,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -846,7 +846,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -900,7 +900,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -956,11 +956,11 @@ // SOURCE-NEXT: %28 = jsir.call_expression (%23, %26, %27) // SOURCE-NEXT: // %28 = false // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%28) ({ +// SOURCE-NEXT: jsir.if_statement (%28) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -974,7 +974,7 @@ // SOURCE-NEXT: %36 = jsir.identifier {"_0x3f313a"} // SOURCE-NEXT: // %36 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %37 = jshir.conditional_expression (%36) ({ +// SOURCE-NEXT: %37 = jsir.conditional_expression (%36) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -988,7 +988,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1017,7 +1017,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1043,7 +1043,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1099,11 +1099,11 @@ // SOURCE-NEXT: %40 = jsir.identifier {"_0x330f38"} // SOURCE-NEXT: // %40 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%40) ({ +// SOURCE-NEXT: jsir.if_statement (%40) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1216,7 +1216,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1230,7 +1230,7 @@ // SOURCE-NEXT: %36 = jsir.identifier {"_0x10bab4"} // SOURCE-NEXT: // %36 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %37 = jshir.conditional_expression (%36) ({ +// SOURCE-NEXT: %37 = jsir.conditional_expression (%36) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1244,7 +1244,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1273,18 +1273,18 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.identifier {"_0x4f3fc0"} // SOURCE-NEXT: // %40 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%40) ({ +// SOURCE-NEXT: jsir.if_statement (%40) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1450,7 +1450,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1508,7 +1508,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1534,7 +1534,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1606,7 +1606,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1686,11 +1686,11 @@ // SOURCE-NEXT: %30 = jsir.call_expression (%23, %26, %29) // SOURCE-NEXT: // %30 = false // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.if_statement (%30) ({ +// SOURCE-NEXT: jsir.if_statement (%30) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1732,7 +1732,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1751,7 +1751,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1767,11 +1767,11 @@ // SOURCE-NEXT: %34 = jsir.member_expression (%31, %33) // SOURCE-NEXT: // %34 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%34) ({ +// SOURCE-NEXT: jsir.switch_statement (%34) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1801,11 +1801,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%39) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1834,7 +1834,7 @@ // SOURCE-NEXT: %38 = jsir.member_expression (%36, %37) // SOURCE-NEXT: // %38 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %39 = jshir.logical_expression (%38) {"||"} ({ +// SOURCE-NEXT: %39 = jsir.logical_expression (%38) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1853,11 +1853,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1893,11 +1893,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1945,11 +1945,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%45) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1991,11 +1991,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%43) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2049,13 +2049,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: @@ -2075,7 +2075,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2123,7 +2123,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x50c043#40 : 0.000000e+00 : f64> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x50c043#40 : 0.000000e+00 : f64> } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2142,7 +2142,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2158,11 +2158,11 @@ // SOURCE-NEXT: %34 = jsir.member_expression (%31, %33) // SOURCE-NEXT: // %34 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%34) ({ +// SOURCE-NEXT: jsir.switch_statement (%34) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2175,11 +2175,11 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2284,11 +2284,11 @@ // SOURCE-NEXT: %35 = jsir.identifier_ref {"_0x455513"} // SOURCE-NEXT: // %35 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%35) ({ +// SOURCE-NEXT: jsir.catch_clause (%35) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2314,11 +2314,11 @@ // SOURCE-NEXT: }, { // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2331,7 +2331,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.for_statement ({ +// SOURCE-NEXT: jsir.for_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2398,7 +2398,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2446,7 +2446,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x92b385#40 : 0.000000e+00 : f64> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x92b385#40 : 0.000000e+00 : f64> } -// SOURCE-NEXT: jshir.while_statement ({ +// SOURCE-NEXT: jsir.while_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2465,7 +2465,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2481,11 +2481,11 @@ // SOURCE-NEXT: %38 = jsir.member_expression (%35, %37) // SOURCE-NEXT: // %38 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_statement (%38) ({ +// SOURCE-NEXT: jsir.switch_statement (%38) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2521,11 +2521,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2555,11 +2555,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%43) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2588,7 +2588,7 @@ // SOURCE-NEXT: %42 = jsir.member_expression (%40, %41) // SOURCE-NEXT: // %42 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %43 = jshir.logical_expression (%42) {"||"} ({ +// SOURCE-NEXT: %43 = jsir.logical_expression (%42) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2607,11 +2607,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2665,11 +2665,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2711,11 +2711,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%47) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2763,13 +2763,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%49) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: @@ -2787,11 +2787,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2818,11 +2818,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2909,11 +2909,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.switch_case ({ +// SOURCE-NEXT: jsir.switch_case ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2951,7 +2951,7 @@ // SOURCE-NEXT: %41 = jsir.member_expression (%39, %40) // SOURCE-NEXT: // %41 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %42 = jshir.logical_expression (%41) {"||"} ({ +// SOURCE-NEXT: %42 = jsir.logical_expression (%41) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2979,13 +2979,13 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.continue_statement +// SOURCE-NEXT: jsir.continue_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.break_statement +// SOURCE-NEXT: jsir.break_statement // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/function_inline_second/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/README.generated.md index be803d3d..53178772 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/output.generated.txt index b129f864..e4226534 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/output.generated.txt @@ -19,7 +19,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"a"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jshir.logical_expression (%0) {"||"} ({ +// SOURCE-NEXT: %1 = jsir.logical_expression (%0) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -48,7 +48,7 @@ // SOURCE-NEXT: %6 = jsir.identifier {"a"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %7 = jshir.logical_expression (%6) {"||"} ({ +// SOURCE-NEXT: %7 = jsir.logical_expression (%6) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/logical_expression/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/README.generated.md index 88e694ba..d92bf9f7 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/output.generated.txt index 230d27cd..7b418df2 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/output.generated.txt @@ -88,7 +88,7 @@ // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: jsir.expression_statement (%9) // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { > } @@ -126,7 +126,7 @@ // SOURCE-NEXT: // State [default = ] { > > } // SOURCE-NEXT: jsir.expression_statement (%14) // SOURCE-NEXT: // State [default = ] { > > } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { > > } @@ -169,7 +169,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/scoped_alias/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/README.generated.md index 03ec36a4..dbe6ed25 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/self_defending/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/README.generated.md index 63d3f901..a214565c 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/README.generated.md index 6835ec73..45d3d94c 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/output.generated.txt index d178f07f..36318627 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/output.generated.txt @@ -100,7 +100,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -193,7 +193,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias_and_wrapper/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/README.generated.md index 24f15290..df71d81e 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/output.generated.txt index b9820292..01b2ba13 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/output.generated.txt @@ -43,7 +43,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -82,7 +82,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -138,7 +138,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_function_inline/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/README.generated.md index 6c355ede..cf4d1a86 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/README.generated.md index 0b41ebf1..4b4b6136 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/output.generated.txt index 6caac733..e4d4e022 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/output.generated.txt @@ -63,7 +63,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -119,7 +119,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -175,7 +175,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_wrapper/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/test_config.json b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/test_config.json new file mode 100644 index 00000000..9066b9ff --- /dev/null +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/README.generated.md index c7a7aae7..6ed7079b 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/output.generated.txt index 1743fa7b..f1b05bcb 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/output.generated.txt @@ -250,7 +250,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -299,7 +299,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -390,7 +390,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -469,7 +469,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -512,7 +512,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -552,7 +552,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -646,7 +646,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -686,7 +686,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -743,7 +743,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -792,7 +792,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -903,7 +903,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -985,7 +985,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1034,7 +1034,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1077,7 +1077,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1204,7 +1204,7 @@ // SOURCE-NEXT: %56 = jsir.identifier {"_0xcc36bd"} // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %57 = jshir.conditional_expression (%56) ({ +// SOURCE-NEXT: %57 = jsir.conditional_expression (%56) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } @@ -1218,7 +1218,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1247,7 +1247,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1280,11 +1280,11 @@ // SOURCE-NEXT: %60 = jsir.identifier {"_0x17e846"} // SOURCE-NEXT: // %60 = // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%60) ({ +// SOURCE-NEXT: jsir.if_statement (%60) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } @@ -1336,11 +1336,11 @@ // SOURCE-NEXT: %76 = jsir.call_expression (%65, %70, %75) // SOURCE-NEXT: // %76 = true // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%76) ({ +// SOURCE-NEXT: jsir.if_statement (%76) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } @@ -1577,7 +1577,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1616,7 +1616,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1665,7 +1665,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1770,11 +1770,11 @@ // SOURCE-NEXT: %107 = jsir.binary_expression (%101, %106) {"!=="} // SOURCE-NEXT: // %107 = true // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%107) ({ +// SOURCE-NEXT: jsir.if_statement (%107) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1792,11 +1792,11 @@ // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1827,7 +1827,7 @@ // SOURCE-NEXT: %117 = jsir.binary_expression (%111, %116) {"==="} // SOURCE-NEXT: // %117 = true // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%117) ({ +// SOURCE-NEXT: jsir.if_statement (%117) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1960,7 +1960,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1978,11 +1978,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2094,11 +2094,11 @@ // SOURCE-NEXT: %119 = jsir.identifier_ref {"_0x475726"} // SOURCE-NEXT: // %119 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%119) ({ +// SOURCE-NEXT: jsir.catch_clause (%119) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2150,11 +2150,11 @@ // SOURCE-NEXT: %109 = jsir.identifier_ref {"_0x1ee9d2"} // SOURCE-NEXT: // %109 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%109) ({ +// SOURCE-NEXT: jsir.catch_clause (%109) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2280,7 +2280,7 @@ // SOURCE-NEXT: %67 = jsir.member_expression (%63, %66) // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: %68 = jshir.logical_expression (%67) {"||"} ({ +// SOURCE-NEXT: %68 = jsir.logical_expression (%67) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2386,7 +2386,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: jshir.for_statement ({ +// SOURCE-NEXT: jsir.for_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2498,7 +2498,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2590,7 +2590,7 @@ // SOURCE-NEXT: %100 = jsir.member_expression (%98, %99) // SOURCE-NEXT: // %100 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: %101 = jshir.logical_expression (%100) {"||"} ({ +// SOURCE-NEXT: %101 = jsir.logical_expression (%100) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/README.generated.md b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/README.generated.md index 079c77b2..fe44863a 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/README.generated.md +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/input.js \ - --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" + --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/output.generated.txt index a5804976..948b7a70 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/output.generated.txt @@ -250,7 +250,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -299,7 +299,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -360,7 +360,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -421,7 +421,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -464,7 +464,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -504,7 +504,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -574,7 +574,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -614,7 +614,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -665,7 +665,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -714,7 +714,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -807,7 +807,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -889,7 +889,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -938,7 +938,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -981,7 +981,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1066,7 +1066,7 @@ // SOURCE-NEXT: %52 = jsir.identifier {"_0xcc36bd"} // SOURCE-NEXT: // %52 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %53 = jshir.conditional_expression (%52) ({ +// SOURCE-NEXT: %53 = jsir.conditional_expression (%52) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } @@ -1080,7 +1080,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1109,7 +1109,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1142,11 +1142,11 @@ // SOURCE-NEXT: %56 = jsir.identifier {"_0x17e846"} // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%56) ({ +// SOURCE-NEXT: jsir.if_statement (%56) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } @@ -1180,11 +1180,11 @@ // SOURCE-NEXT: %66 = jsir.call_expression (%59, %62, %65) // SOURCE-NEXT: // %66 = true // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%66) ({ +// SOURCE-NEXT: jsir.if_statement (%66) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } @@ -1409,7 +1409,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1448,7 +1448,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1497,7 +1497,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1572,11 +1572,11 @@ // SOURCE-NEXT: %87 = jsir.binary_expression (%83, %86) {"!=="} // SOURCE-NEXT: // %87 = true // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%87) ({ +// SOURCE-NEXT: jsir.if_statement (%87) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1594,11 +1594,11 @@ // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1623,7 +1623,7 @@ // SOURCE-NEXT: %95 = jsir.binary_expression (%91, %94) {"==="} // SOURCE-NEXT: // %95 = true // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: jshir.if_statement (%95) ({ +// SOURCE-NEXT: jsir.if_statement (%95) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } @@ -1696,7 +1696,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1714,11 +1714,11 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.try_statement ({ +// SOURCE-NEXT: jsir.try_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1782,11 +1782,11 @@ // SOURCE-NEXT: %97 = jsir.identifier_ref {"_0x475726"} // SOURCE-NEXT: // %97 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%97) ({ +// SOURCE-NEXT: jsir.catch_clause (%97) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1838,11 +1838,11 @@ // SOURCE-NEXT: %89 = jsir.identifier_ref {"_0x1ee9d2"} // SOURCE-NEXT: // %89 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.catch_clause (%89) ({ +// SOURCE-NEXT: jsir.catch_clause (%89) ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1950,7 +1950,7 @@ // SOURCE-NEXT: %57 = jsir.member_expression (%55, %56) // SOURCE-NEXT: // %57 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: %58 = jshir.logical_expression (%57) {"||"} ({ +// SOURCE-NEXT: %58 = jsir.logical_expression (%57) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2038,7 +2038,7 @@ // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: jshir.for_statement ({ +// SOURCE-NEXT: jsir.for_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2105,7 +2105,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: jshir.block_statement ({ +// SOURCE-NEXT: jsir.block_statement ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } @@ -2173,7 +2173,7 @@ // SOURCE-NEXT: %80 = jsir.member_expression (%78, %79) // SOURCE-NEXT: // %80 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } -// SOURCE-NEXT: %81 = jshir.logical_expression (%80) {"||"} ({ +// SOURCE-NEXT: %81 = jsir.logical_expression (%80) {"||"} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/run.generated.lit b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/run.generated.lit index dbfc7005..ab94d878 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/run.generated.lit +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/variable_inline_second/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source" \ +// RUN: --passes "source2ast,extract_prelude,erase_comments,ast2jsir,dynconstprop,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/generate_tests.py b/maldoca/js/ir/transforms/generate_tests.py deleted file mode 100644 index 19d8fd14..00000000 --- a/maldoca/js/ir/transforms/generate_tests.py +++ /dev/null @@ -1,191 +0,0 @@ -r"""Generates test files for the conversion tests. - -In each directory, only `input.js` is manually written. The other files are -generated by running this tool. - -Usage: - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,constprop,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/constant_propagation/tests - -# TODO(b/452034945): Release these tests. -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,constprop,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/constant_propagation/jscomp_peephole_tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,extract_prelude,erase_comments,ast2hir,dynconstprop,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/dynamic_constant_propagation/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/move_named_functions/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,erase_comments,ast2hir,normalize_member_expressions,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/normalize_member_expressions/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,erase_comments,ast2hir,constprop,normalize_member_expressions,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/normalize_member_expressions/tests/with_constant_propagation - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,normalizeobjprops,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/normalize_object_properties/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,erase_comments,ast2hir,peelparens,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/peel_parentheses/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/split_declaration_statements/tests - -# TODO(b/452034945): Release these tests. -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,dead_code_elimination,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/dead_code_elimination/tests - -python3 maldoca/js/ir/transforms/generate_tests.py \ - --passes source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source \ - --path maldoca/js/ir/transforms/split_sequence_expressions/tests -""" - -import argparse -import os -import shutil -import subprocess -import sys - - -def run_command(cmd: str) -> bytes: - """Run a shell command and return its output.""" - - print("Running:") - print(" ", cmd) - - try: - return subprocess.check_output(cmd, shell=True, stderr=subprocess.PIPE) - except subprocess.CalledProcessError as e: - print("Error running command, output:", e.output) - sys.exit(1) - - -def generate_test_file( - input_path: str, - output_path: str, - passes: str, - prefix: str, -): - """Generates a test file. - - Args: - input_path: Test case name. - output_path: The output file will be /. - passes: Comma-separated list of JSIR passes. - prefix: FileCheck prefix. - """ - input_abs_path: str = os.path.abspath(input_path) - - command: str = ( - "bazel run //maldoca/js/ir:jsir_gen --" - f" --input_file={input_abs_path}" - f" --passes='{passes}'" - ) - - try: - output = run_command(command).decode("utf-8") - except UnicodeDecodeError: - output = run_command(command).decode("latin-1") - - output = output.strip() - - # Prepend prefix - lines = output.split("\n") - out_lines = [] - for i, line in enumerate(lines): - if not line: - line = f"// {prefix}-EMPTY:" - elif i == 0: - line = f"// {prefix}: " + line - else: - line = f"// {prefix}-NEXT: " + line - out_lines.append(line) - - output = "\n".join(out_lines) + "\n" - - with open(output_path, "w") as f: - f.write(output) - - -README_TEMPLATE = r"""To run manually: - -```shell -bazel run //maldoca/js/ir:jsir_gen -- \ - --input_file $(pwd)/{test_path}/input.js \ - --passes "{passes}" -``` -""" - -LIT_TEMPLATE = r"""// RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ -// RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "{passes}" \ -// RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt -""" - - -def generate_readme_file(test_path: str, passes: str): - with open(os.path.join(test_path, "README.generated.md"), "w") as f: - f.write(README_TEMPLATE.format(test_path=test_path, passes=passes)) - - -def generate_lit_file(test_path: str, passes: str): - with open(os.path.join(test_path, "run.generated.lit"), "w") as f: - f.write(LIT_TEMPLATE.format(test_path=test_path, passes=passes)) - - -def main(): - parser = argparse.ArgumentParser() - parser.add_argument("--passes", required=True) - parser.add_argument("--path", required=True) - - args = parser.parse_args() - passes: str = args.passes - root_path: str = args.path - print("Passes:", passes) - print("Path:", root_path) - - for test_path, _, file_names_in_dir in os.walk(root_path): - - if "input.js" not in file_names_in_dir: - continue - - test_name = os.path.basename(test_path) - print("Generating test:", test_name) - - generate_test_file( - input_path=os.path.join(test_path, "input.js"), - output_path=os.path.join(test_path, "output.generated.txt"), - passes=passes, - prefix="SOURCE", - ) - - generate_readme_file( - test_path=test_path, - passes=passes, - ) - - generate_lit_file( - test_path, - passes=passes, - ) - - shutil.copyfile( - os.path.join(root_path, "BUILD.template"), - os.path.join(test_path, "BUILD"), - ) - - -if __name__ == "__main__": - main() diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/README.generated.md b/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/README.generated.md index e2ad41bd..fb559472 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/README.generated.md +++ b/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/input.js \ - --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" + --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/run.generated.lit b/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/run.generated.lit index b833dc7c..115485c2 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/run.generated.lit +++ b/maldoca/js/ir/transforms/move_named_functions/tests/control_flow/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" \ +// RUN: --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/nested/README.generated.md b/maldoca/js/ir/transforms/move_named_functions/tests/nested/README.generated.md index 195524a6..aa5ba8bd 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/nested/README.generated.md +++ b/maldoca/js/ir/transforms/move_named_functions/tests/nested/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/move_named_functions/tests/nested/input.js \ - --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" + --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/nested/run.generated.lit b/maldoca/js/ir/transforms/move_named_functions/tests/nested/run.generated.lit index b833dc7c..115485c2 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/nested/run.generated.lit +++ b/maldoca/js/ir/transforms/move_named_functions/tests/nested/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" \ +// RUN: --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/simple/README.generated.md b/maldoca/js/ir/transforms/move_named_functions/tests/simple/README.generated.md index 09a34892..b96e834e 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/simple/README.generated.md +++ b/maldoca/js/ir/transforms/move_named_functions/tests/simple/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/move_named_functions/tests/simple/input.js \ - --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" + --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/simple/run.generated.lit b/maldoca/js/ir/transforms/move_named_functions/tests/simple/run.generated.lit index b833dc7c..115485c2 100644 --- a/maldoca/js/ir/transforms/move_named_functions/tests/simple/run.generated.lit +++ b/maldoca/js/ir/transforms/move_named_functions/tests/simple/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,erase_comments,ast2hir,movenamedfuncs,hir2ast,ast2source" \ +// RUN: --passes "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/move_named_functions/tests/test_config.json b/maldoca/js/ir/transforms/move_named_functions/tests/test_config.json new file mode 100644 index 00000000..cb4ac49f --- /dev/null +++ b/maldoca/js/ir/transforms/move_named_functions/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,erase_comments,ast2jsir,movenamedfuncs,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/README.generated.md b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/README.generated.md index b3d933d2..d83d6cdb 100644 --- a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/README.generated.md +++ b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/input.js \ - --passes "source2ast,ast2hir,normalizeobjprops,hir2ast,ast2source" + --passes "source2ast,ast2jsir,normalizeobjprops,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/run.generated.lit b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/run.generated.lit index d0c313c5..52fd5371 100644 --- a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/run.generated.lit +++ b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,normalizeobjprops,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,normalizeobjprops,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/README.generated.md b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/README.generated.md index 0a991ed8..3f2b7ca5 100644 --- a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/README.generated.md +++ b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/input.js \ - --passes "source2ast,ast2hir,normalizeobjprops,hir2ast,ast2source" + --passes "source2ast,ast2jsir,normalizeobjprops,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/run.generated.lit b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/run.generated.lit index d0c313c5..52fd5371 100644 --- a/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/run.generated.lit +++ b/maldoca/js/ir/transforms/normalize_object_properties/tests/object_property_ref/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,normalizeobjprops,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,normalizeobjprops,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/normalize_object_properties/tests/test_config.json b/maldoca/js/ir/transforms/normalize_object_properties/tests/test_config.json new file mode 100644 index 00000000..b2ef56b2 --- /dev/null +++ b/maldoca/js/ir/transforms/normalize_object_properties/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir,normalizeobjprops,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/README.generated.md b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/README.generated.md index f86bf58c..7f391e62 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/README.generated.md +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/input.js \ - --passes "source2ast,erase_comments,ast2hir,peelparens,hir2ast,ast2source" + --passes "source2ast,erase_comments,ast2jsir,peelparens,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/run.generated.lit b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/run.generated.lit index d56ae84f..41660df0 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/run.generated.lit +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,erase_comments,ast2hir,peelparens,hir2ast,ast2source" \ +// RUN: --passes "source2ast,erase_comments,ast2jsir,peelparens,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/README.generated.md b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/README.generated.md index 802b310f..fda1cb5b 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/README.generated.md +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/input.js \ - --passes "source2ast,erase_comments,ast2hir,peelparens,hir2ast,ast2source" + --passes "source2ast,erase_comments,ast2jsir,peelparens,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/run.generated.lit b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/run.generated.lit index d56ae84f..41660df0 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/run.generated.lit +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,erase_comments,ast2hir,peelparens,hir2ast,ast2source" \ +// RUN: --passes "source2ast,erase_comments,ast2jsir,peelparens,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/test_config.json b/maldoca/js/ir/transforms/peel_parentheses/tests/test_config.json new file mode 100644 index 00000000..fc17de1f --- /dev/null +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,erase_comments,ast2jsir,peelparens,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/remove_directives/pass.cc b/maldoca/js/ir/transforms/remove_directives/pass.cc index 0e009b4f..879e1fab 100644 --- a/maldoca/js/ir/transforms/remove_directives/pass.cc +++ b/maldoca/js/ir/transforms/remove_directives/pass.cc @@ -34,8 +34,8 @@ namespace maldoca { void RemoveDirectives(mlir::Operation *root) { mlir::OpBuilder builder(root); - root->walk([&](mlir::Operation *op) { - llvm::TypeSwitch(op) + root->walk([&](mlir::Operation* op) { + llvm::TypeSwitch(op) .Case([&](JsirProgramOp op) { // Remove (1) op.removeInterpreterAttr(); @@ -46,14 +46,14 @@ void RemoveDirectives(mlir::Operation *root) { } }) - .Case([&](JshirBlockStatementOp op) { + .Case([&](JsirBlockStatementOp op) { // Remove (3) for (mlir::Block &block : op.getDirectives()) { block.clear(); } }) - .Default([&](mlir::Operation *op) {}); + .Default([&](mlir::Operation* op) {}); }); } diff --git a/maldoca/js/ir/transforms/remove_directives/tests/directives/run.lit b/maldoca/js/ir/transforms/remove_directives/tests/directives/run.lit index fa014269..5f83e2a4 100644 --- a/maldoca/js/ir/transforms/remove_directives/tests/directives/run.lit +++ b/maldoca/js/ir/transforms/remove_directives/tests/directives/run.lit @@ -1,4 +1,4 @@ // RUN: INPUT=%s && \ // RUN: jsir_gen --input_file "$(dirname "${INPUT}")"/input.js \ -// RUN: --passes source2ast,ast2hir,remove_directives,hir2ast,ast2source \ +// RUN: --passes source2ast,ast2jsir,remove_directives,jsir2ast,ast2source \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname "${INPUT}")"/output.js diff --git a/maldoca/js/ir/transforms/split_declaration_statements/pass.cc b/maldoca/js/ir/transforms/split_declaration_statements/pass.cc index c0f6e48c..a95d8385 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/pass.cc +++ b/maldoca/js/ir/transforms/split_declaration_statements/pass.cc @@ -48,7 +48,7 @@ std::vector GetDependencyOps(mlir::Operation *root) { bool BlockIsForHeader(mlir::Block &block) { auto for_op = - llvm::dyn_cast_if_present(block.getParentOp()); + llvm::dyn_cast_if_present(block.getParentOp()); if (for_op == nullptr) { return false; } diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/README.generated.md b/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/README.generated.md index 65781932..c742d24e 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/README.generated.md +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/input.js \ - --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/run.generated.lit b/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/run.generated.lit index 946017a2..04aececa 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/for_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/README.generated.md b/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/README.generated.md index cb44b7f2..496c2848 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/README.generated.md +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/input.js \ - --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/run.generated.lit b/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/run.generated.lit index 946017a2..04aececa 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/run.generated.lit +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/inner_scope/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/test_config.json b/maldoca/js/ir/transforms/split_declaration_statements/tests/test_config.json new file mode 100644 index 00000000..5cfae334 --- /dev/null +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/README.generated.md b/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/README.generated.md index 1cbcfd2a..85e2e443 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/README.generated.md +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/input.js \ - --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/run.generated.lit b/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/run.generated.lit index 946017a2..04aececa 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/run.generated.lit +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/variable_declaration/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/README.generated.md b/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/README.generated.md index 161af612..67e86e6e 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/README.generated.md +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/input.js \ - --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/run.generated.lit b/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/run.generated.lit index 946017a2..04aececa 100644 --- a/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/split_declaration_statements/tests/with_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_declaration_statements,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_declaration_statements,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/README.generated.md b/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/README.generated.md index 9fc03b89..210b4fcd 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/README.generated.md +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/input.js \ - --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/run.generated.lit b/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/run.generated.lit index 4152a1fb..904f2e3a 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/for_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/README.generated.md b/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/README.generated.md index bc4a1346..5c3070bf 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/README.generated.md +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/input.js \ - --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/run.generated.lit b/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/run.generated.lit index 4152a1fb..904f2e3a 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/run.generated.lit +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/return/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/test_config.json b/maldoca/js/ir/transforms/split_sequence_expressions/tests/test_config.json new file mode 100644 index 00000000..a1bfb6c8 --- /dev/null +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/test_config.json @@ -0,0 +1,10 @@ +{ + "tests": [ + { + "output_file": "output.generated.txt", + "passes": "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source", + "prefix": "SOURCE" + } + ], + "build_template": "BUILD.template" +} diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/README.generated.md b/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/README.generated.md index d1e8b1de..7ae427cf 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/README.generated.md +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/README.generated.md @@ -3,5 +3,5 @@ To run manually: ```shell bazel run //maldoca/js/ir:jsir_gen -- \ --input_file $(pwd)/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/input.js \ - --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" + --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" ``` diff --git a/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/run.generated.lit b/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/run.generated.lit index 4152a1fb..904f2e3a 100644 --- a/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/run.generated.lit +++ b/maldoca/js/ir/transforms/split_sequence_expressions/tests/with_statement/run.generated.lit @@ -1,4 +1,4 @@ // RUN: CURRENT_FILE_BASENAME=$(basename %s .lit) && \ // RUN: jsir_gen --input_file "$(dirname %s)"/input.js \ -// RUN: --passes "source2ast,ast2hir,split_sequence_expressions,hir2ast,ast2source" \ +// RUN: --passes "source2ast,ast2jsir,split_sequence_expressions,jsir2ast,ast2source" \ // RUN: | FileCheck --check-prefix SOURCE "$(dirname %s)"/output.generated.txt diff --git a/maldoca/js/ir/transforms/transform.cc b/maldoca/js/ir/transforms/transform.cc index 2f36aeb5..627defca 100644 --- a/maldoca/js/ir/transforms/transform.cc +++ b/maldoca/js/ir/transforms/transform.cc @@ -151,13 +151,13 @@ absl::StatusOr> TransformJsAst( mlir::MLIRContext mlir_context; LoadNecessaryDialects(mlir_context); - ABSL_ASSIGN_OR_RETURN(auto jshir_file, AstToJshirFile(ast, mlir_context)); + ABSL_ASSIGN_OR_RETURN(auto jsir_file, AstToJsirFile(ast, mlir_context)); JsAnalysisOutputs analysis_outputs; - ABSL_RETURN_IF_ERROR(TransformJsir(*jshir_file, scopes, std::move(configs), + ABSL_RETURN_IF_ERROR(TransformJsir(*jsir_file, scopes, std::move(configs), babel, &analysis_outputs)); - return JshirFileToAst(*jshir_file); + return JsirFileToAst(*jsir_file); } } // namespace maldoca