diff --git a/MODULE.bazel b/MODULE.bazel index b682568..e43a4cd 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -22,8 +22,11 @@ bazel_dep(name = "nlohmann_json", version = "3.11.3") bazel_dep(name = "googletest", version = "1.15.0") # https://registry.bazel.build/modules/protobuf -bazel_dep(name = "protobuf", version = "31.1", - repo_name = "com_google_protobuf") +bazel_dep( + name = "protobuf", + version = "31.1", + repo_name = "com_google_protobuf", +) # https://registry.bazel.build/modules/re2 bazel_dep(name = "re2", version = "2024-07-02") diff --git a/README.md b/README.md index 4f7089c..40bbb9b 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,8 @@ JSIR needs to achieve two seemingly conflicting goals: * It needs to be **low-level** enough to facilitate dataflow analysis, in order to support taint analysis, constant propagation, etc.. -To achieve these goals, JSIR defines a high level IR that uses MLIR regions to accurately model control flow structures. +To achieve these goals, JSIR defines a high level IR that uses MLIR regions to +accurately model control flow structures. See [intermediate_representation_design.md](docs/intermediate_representation_design.md) @@ -61,7 +62,6 @@ docker run --rm jsir:latest jsir_gen --help docker run --rm -v $(pwd):/workspace jsir:latest jsir_gen --input_file=/workspace/yourfile.js ``` - ### Install build tools We have only tested `clang` on Linux: diff --git a/maldoca/astgen/BUILD b/maldoca/astgen/BUILD index 7d85aba..ff3c273 100644 --- a/maldoca/astgen/BUILD +++ b/maldoca/astgen/BUILD @@ -70,35 +70,218 @@ cc_library( ) cc_library( - name = "ast_gen", - srcs = ["ast_gen.cc"], - hdrs = ["ast_gen.h"], + name = "printer_base", + hdrs = ["printer_base.h"], + deps = [ + "@com_google_protobuf//src/google/protobuf/io", + "@com_google_protobuf//src/google/protobuf/io:printer", + ], +) + +cc_library( + name = "ast_gen_utils", + hdrs = ["ast_gen_utils.h"], + deps = [ + ":ast_def", + "//maldoca/base:path", + "@abseil-cpp//absl/algorithm:container", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io:printer", + ], +) + +cc_library( + name = "cc_printer_base", + srcs = ["cc_printer_base.cc"], + hdrs = ["cc_printer_base.h"], + deps = [ + ":ast_def", + ":ast_gen_utils", + ":printer_base", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ast_header_printer", + srcs = ["ast_header_printer.cc"], + hdrs = ["ast_header_printer.h"], + deps = [ + ":ast_def", + ":ast_gen_utils", + ":cc_printer_base", + ":symbol", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ast_source_printer", + srcs = ["ast_source_printer.cc"], + hdrs = ["ast_source_printer.h"], deps = [ ":ast_def", ":ast_def_cc_proto", + ":ast_gen_utils", + ":cc_printer_base", + ":symbol", + "@abseil-cpp//absl/strings", + "@abseil-cpp//absl/strings:str_format", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ast_serialize_printer", + srcs = ["ast_serialize_printer.cc"], + hdrs = ["ast_serialize_printer.h"], + deps = [ + ":ast_def", + ":ast_gen_utils", + ":cc_printer_base", + ":symbol", + "@abseil-cpp//absl/log", + "@abseil-cpp//absl/log:check", + "@abseil-cpp//absl/strings", + "@abseil-cpp//absl/strings:str_format", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ast_from_json_printer", + srcs = ["ast_from_json_printer.cc"], + hdrs = ["ast_from_json_printer.h"], + deps = [ + ":ast_def", + ":ast_def_cc_proto", + ":ast_from_json_utils", + ":ast_gen_utils", + ":cc_printer_base", ":symbol", - "//maldoca/base:path", "@abseil-cpp//absl/algorithm:container", "@abseil-cpp//absl/base:core_headers", "@abseil-cpp//absl/cleanup", - "@abseil-cpp//absl/container:btree", "@abseil-cpp//absl/container:flat_hash_set", "@abseil-cpp//absl/log", "@abseil-cpp//absl/log:check", "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ts_interface_printer", + srcs = ["ts_interface_printer.cc"], + hdrs = ["ts_interface_printer.h"], + deps = [ + ":ast_def", + ":ast_def_cc_proto", + ":ast_gen_utils", + ":printer_base", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ir_table_gen_printer", + srcs = ["ir_table_gen_printer.cc"], + hdrs = ["ir_table_gen_printer.h"], + deps = [ + ":ast_def", + ":ast_gen_utils", + ":cc_printer_base", + ":symbol", + "@abseil-cpp//absl/algorithm:container", + "@abseil-cpp//absl/log", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ast_to_ir_source_printer", + srcs = ["ast_to_ir_source_printer.cc"], + hdrs = ["ast_to_ir_source_printer.h"], + deps = [ + ":ast_def", + ":ast_def_cc_proto", + ":ast_gen_utils", + ":cc_printer_base", + ":symbol", + "@abseil-cpp//absl/algorithm:container", + "@abseil-cpp//absl/base:core_headers", + "@abseil-cpp//absl/log", + "@abseil-cpp//absl/log:check", + "@abseil-cpp//absl/strings", "@abseil-cpp//absl/strings:str_format", "@com_google_protobuf//src/google/protobuf/io", + ], +) + +cc_library( + name = "ir_to_ast_source_printer", + srcs = ["ir_to_ast_source_printer.cc"], + hdrs = ["ir_to_ast_source_printer.h"], + deps = [ + ":ast_def", + ":ast_def_cc_proto", + ":ast_gen_utils", + ":cc_printer_base", + ":printer_base", + ":symbol", + "@abseil-cpp//absl/base:core_headers", + "@abseil-cpp//absl/container:btree", + "@abseil-cpp//absl/log", + "@abseil-cpp//absl/log:check", + "@abseil-cpp//absl/strings", + "@com_google_protobuf//src/google/protobuf/io", "@com_google_protobuf//src/google/protobuf/io:printer", ], ) +cc_library( + name = "ast_from_json_utils", + hdrs = ["ast_from_json_utils.h"], + deps = [ + "//maldoca/base:status", + "@abseil-cpp//absl/functional:any_invocable", + "@abseil-cpp//absl/status", + "@abseil-cpp//absl/status:statusor", + "@abseil-cpp//absl/strings", + "@nlohmann_json//:json", + ], +) + +cc_library( + name = "ir_to_ast_util", + hdrs = ["ir_to_ast_util.h"], + deps = [ + "//maldoca/base:status", + "@abseil-cpp//absl/status", + "@abseil-cpp//absl/status:statusor", + "@abseil-cpp//absl/strings:string_view", + "@llvm-project//llvm:Support", + "@llvm-project//mlir:IR", + ], +) + cc_binary( name = "ast_gen_main", srcs = ["ast_gen_main.cc"], deps = [ ":ast_def", ":ast_def_cc_proto", - ":ast_gen", + ":ast_from_json_printer", + ":ast_header_printer", + ":ast_serialize_printer", + ":ast_source_printer", + ":ast_to_ir_source_printer", + ":ir_table_gen_printer", + ":ir_to_ast_source_printer", "//maldoca/base:filesystem", "//maldoca/base:path", "//maldoca/base:status", @@ -113,8 +296,10 @@ cc_test( deps = [ ":ast_def", ":ast_def_cc_proto", - ":ast_gen", + ":ast_from_json_printer", + ":ast_header_printer", ":symbol", + ":ts_interface_printer", "//maldoca/base:filesystem", "//maldoca/base/testing:status_matchers", "@abseil-cpp//absl/memory", diff --git a/maldoca/astgen/ast_def.h b/maldoca/astgen/ast_def.h index eda8354..66cb0dd 100644 --- a/maldoca/astgen/ast_def.h +++ b/maldoca/astgen/ast_def.h @@ -43,10 +43,10 @@ class EnumMemberDef { : name_(std::move(name)), string_value_(std::move(string_value)) {} static absl::StatusOr FromEnumMemberDefPb( - const EnumMemberDefPb &member_pb); + const EnumMemberDefPb& member_pb); - const Symbol &name() const { return name_; } - const std::string &string_value() const { return string_value_; } + const Symbol& name() const { return name_; } + const std::string& string_value() const { return string_value_; } private: Symbol name_; @@ -58,9 +58,9 @@ class EnumDef { explicit EnumDef(Symbol name, std::vector members) : name_(std::move(name)), members_(std::move(members)) {} - static absl::StatusOr FromEnumDefPb(const EnumDefPb &enum_pb); + static absl::StatusOr FromEnumDefPb(const EnumDefPb& enum_pb); - const Symbol &name() const { return name_; } + const Symbol& name() const { return name_; } absl::Span members() const { return members_; } private: @@ -71,13 +71,13 @@ class EnumDef { // Definition of a field in a class. class FieldDef { public: - static absl::StatusOr FromFieldDefPb(const FieldDefPb &field_pb, + static absl::StatusOr FromFieldDefPb(const FieldDefPb& field_pb, absl::string_view lang_name); - const Symbol &name() const { return name_; } + const Symbol& name() const { return name_; } Optionalness optionalness() const { return optionalness_; } - const Type &type() const { return *type_; } - Type &type() { return *type_; } + const Type& type() const { return *type_; } + Type& type() { return *type_; } FieldKind kind() const { return kind_; } bool ignore_in_ir() const { return ignore_in_ir_; } bool enclose_in_region() const { return enclose_in_region_; } @@ -99,7 +99,7 @@ class FieldDef { class NodeDef { public: // Class name. - const std::string &name() const { return name_; } + const std::string& name() const { return name_; } // Type kind enum. // @@ -135,7 +135,7 @@ class NodeDef { // } // // parents = { Expression, Pattern } - absl::Span parents() const { return parents_; } + absl::Span parents() const { return parents_; } // Topologically sorted: base comes before derived. Use the original // definition order to break tie. @@ -147,23 +147,23 @@ class NodeDef { // interface Identifier <: Expression, Pattern // // ancestors: Node, Expression, Pattern - absl::Span ancestors() const { return ancestors_; } + absl::Span ancestors() const { return ancestors_; } // All fields, including those defined by ancestors. - absl::Span aggregated_fields() const { + absl::Span aggregated_fields() const { return aggregated_fields_; } // Direct children of this class. - absl::Span children() const { return children_; } + absl::Span children() const { return children_; } // All types that directly or indirectly inherit this class. - absl::Span descendants() const { return descendants_; } + absl::Span descendants() const { return descendants_; } // All descendants that are leaf classes. - absl::Span leafs() const { return leafs_; } + absl::Span leafs() const { return leafs_; } - std::optional node_type_enum() const { + std::optional node_type_enum() const { if (node_type_enum_.has_value()) { return &node_type_enum_.value(); } else { @@ -281,12 +281,12 @@ class NodeDef { std::string name_; std::optional type_; std::vector fields_; - std::vector parents_; - std::vector ancestors_; - std::vector aggregated_fields_; - std::vector children_; - std::vector descendants_; - std::vector leafs_; + std::vector parents_; + std::vector ancestors_; + std::vector aggregated_fields_; + std::vector children_; + std::vector descendants_; + std::vector leafs_; std::optional node_type_enum_; bool should_generate_ir_op_; std::vector kinds_; @@ -305,7 +305,7 @@ class AstDef { public: // Creates an AST definition from a proto. // Also checks the validity of the proto. - static absl::StatusOr FromProto(const AstDefPb &pb); + static absl::StatusOr FromProto(const AstDefPb& pb); absl::string_view lang_name() const { return lang_name_; } @@ -315,7 +315,7 @@ class AstDef { absl::Span node_names() const { return node_names_; } // Node name => node definition. - const absl::flat_hash_map> &nodes() + const absl::flat_hash_map>& nodes() const { return nodes_; } @@ -323,7 +323,7 @@ class AstDef { // Nodes listed in topological order. // This order ensures that dependencies (parent classes, field types) are // defined before each class. - absl::Span topological_sorted_nodes() const { + absl::Span topological_sorted_nodes() const { return topological_sorted_nodes_; } @@ -332,14 +332,14 @@ class AstDef { std::string lang_name, std::vector enum_defs, std::vector node_names, absl::flat_hash_map> nodes, - std::vector topological_sorted_nodes) + std::vector topological_sorted_nodes) : lang_name_(std::move(lang_name)), enum_defs_(std::move(enum_defs)), node_names_(std::move(node_names)), nodes_(std::move(nodes)), topological_sorted_nodes_(std::move(topological_sorted_nodes)) { LOG(INFO) << "Created AstDef. node_names:"; - for (const std::string &node_name : node_names_) { + for (const std::string& node_name : node_names_) { LOG(INFO) << " " << node_name; } } @@ -348,10 +348,10 @@ class AstDef { std::vector enum_defs_; std::vector node_names_; absl::flat_hash_map> nodes_; - std::vector topological_sorted_nodes_; + std::vector topological_sorted_nodes_; static void ResolveClassType( - Type &type, absl::Span topological_sorted_nodes); + Type& type, absl::Span topological_sorted_nodes); }; } // namespace maldoca diff --git a/maldoca/astgen/ast_from_json_printer.cc b/maldoca/astgen/ast_from_json_printer.cc new file mode 100644 index 0000000..67d7c0f --- /dev/null +++ b/maldoca/astgen/ast_from_json_printer.cc @@ -0,0 +1,558 @@ +// 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 "maldoca/astgen/ast_from_json_printer.h" + +#include +#include + +#include "absl/algorithm/container.h" +#include "absl/base/attributes.h" +#include "absl/cleanup/cleanup.h" +#include "absl/container/flat_hash_set.h" +#include "absl/log/check.h" +#include "absl/log/log.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { +namespace { + +static void GetCheckedClasses(const Type& type, bool is_part_of_variant, + absl::flat_hash_set* node_names) { + switch (type.kind()) { + case TypeKind::kBuiltin: + case TypeKind::kEnum: + break; + case TypeKind::kClass: { + if (is_part_of_variant) { + const auto& class_type = static_cast(type); + node_names->insert(class_type.name().ToPascalCase()); + } + break; + } + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + for (const auto& element_type : variant_type.types()) { + GetCheckedClasses(*element_type, /*is_part_of_variant=*/true, + node_names); + } + break; + } + case TypeKind::kList: { + const auto& list_type = static_cast(type); + GetCheckedClasses(list_type.element_type(), is_part_of_variant, + node_names); + break; + } + } +} + +static absl::flat_hash_set GetCheckedClasses(const AstDef& ast) { + absl::flat_hash_set checked_classes; + for (const NodeDef* node : ast.topological_sorted_nodes()) { + for (const FieldDef& field : node->fields()) { + GetCheckedClasses(field.type(), /*is_part_of_variant=*/false, + &checked_classes); + } + } + return checked_classes; +} + +} // namespace + +void AstFromJsonPrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path) { + auto vars = WithVars({ + {"json_variable", kJsonValueVariableName}, + }); + + auto header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println("// IWYU pragma: begin_keep"); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeaders({ + std::string(header_path), + "absl/container/flat_hash_set.h", + "absl/memory/memory.h", + "absl/status/status.h", + "absl/status/statusor.h", + "absl/strings/str_cat.h", + "absl/strings/string_view.h", + "maldoca/astgen/ast_from_json_utils.h", + "maldoca/base/status_macros.h", + "nlohmann/json.hpp", + }); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + absl::flat_hash_set checked_classes = GetCheckedClasses(ast); + + for (const NodeDef* node : ast.topological_sorted_nodes()) { + PrintTitle((Symbol(ast.lang_name()) + node->name()).ToPascalCase()); + Println(); + + if (checked_classes.contains(node->name())) { + PrintTypeChecker(*node); + Println(); + } + + for (const FieldDef& field : node->fields()) { + PrintGetFieldFunction(node->name(), field, ast.lang_name()); + Println(); + } + + PrintFromJsonFunction(*node, ast.lang_name()); + Println(); + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); +} + +void AstFromJsonPrinter::PrintTypeChecker(const NodeDef& node) { + auto vars = WithVars({ + {"NodeType", std::string(node.name())}, + {"json_variable", kJsonValueVariableName}, + }); + + Println("static bool Is$NodeType$(const nlohmann::json& $json_variable$) {"); + absl::Cleanup end_body = [&] { Println("}"); }; + { + auto indent = WithIndent(); + + Println("if (!$json_variable$.is_object()) {"); + Println(" return false;"); + Println("}"); + + if (node.children().empty() && node.parents().empty()) { + // This is not a virtual class. + Println("return true;"); + return; + } + + const std::string code = UnIndentedSource(R"cc( + auto type_it = $json_variable$.find("type"); + if (type_it == $json_variable$.end()) { + return false; + } + const nlohmann::json &type_json = type_it.value(); + if (!type_json.is_string()) { + return false; + } + const std::string &type = type_json.get(); + )cc"); + Println(code); + + if (!node.leafs().empty()) { + Println( + "static const auto *kTypes = new absl::flat_hash_set{"); + { + auto indent = WithIndent(4); + for (const NodeDef* leaf : node.leafs()) { + auto vars = WithVars({ + {"LeafType", leaf->name()}, + }); + Println("\"$LeafType$\","); + } + } + Println("};"); + Println(); + + Println("return kTypes->contains(type);"); + + } else { + CHECK_EQ(node.name(), node.type().value()); + Println("return type == \"$NodeType$\";"); + } + } +} + +void AstFromJsonPrinter::PrintGetFieldFunction(const std::string& node_name, + const FieldDef& field, + absl::string_view lang_name) { + std::string get_field_function_name = [&] { + switch (field.optionalness()) { + case OPTIONALNESS_REQUIRED: + return "GetRequiredField"; + case OPTIONALNESS_MAYBE_NULL: + return "GetNullableField"; + case OPTIONALNESS_MAYBE_UNDEFINED: + return "GetOptionalField"; + default: + LOG(FATAL) << "Unreachable code."; + } + }(); + + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node_name).ToPascalCase()}, + {"return_cc_type", CcType(field)}, + {"field_cc_type", field.type().CcType()}, + {"fieldName", field.name().ToCamelCase()}, + {"FieldName", field.name().ToPascalCase()}, + {"json_variable", kJsonValueVariableName}, + {"GetField", get_field_function_name}, + }); + + Println("absl::StatusOr<$return_cc_type$>"); + Println( + "$NodeType$::Get$FieldName$(const nlohmann::json& $json_variable$) {"); + { + auto indent = WithIndent(); + Println("return $GetField$<$field_cc_type$>("); + { + auto indent = WithIndent(4); + Println("$json_variable$,"); + Println("\"$fieldName$\","); + PrintConverter(field.type(), lang_name); + Println(); + } + Println(");"); + } + Println("}"); +} + +void AstFromJsonPrinter::PrintTypeCheckerName(const ScalarType& type) { + switch (type.kind()) { + case TypeKind::kList: + case TypeKind::kVariant: { + LOG(FATAL) << "Unreachable code."; + } + + case TypeKind::kClass: { + const auto& class_type = static_cast(type); + Print("Is" + class_type.name().ToPascalCase()); + break; + } + + case TypeKind::kEnum: { + const auto& enum_type = static_cast(type); + Print("Is" + enum_type.name().ToPascalCase()); + break; + } + + case TypeKind::kBuiltin: { + const auto& builtin_type = static_cast(type); + switch (builtin_type.builtin_kind()) { + case BuiltinTypeKind::kString: + Print("IsString"); + break; + case BuiltinTypeKind::kBool: + Print("IsBool"); + break; + case BuiltinTypeKind::kInt64: + Print("IsInt64"); + break; + case BuiltinTypeKind::kDouble: + Print("IsDouble"); + break; + default: + LOG(FATAL) << "Unreachable code."; + } + break; + } + } +} + +void AstFromJsonPrinter::PrintConverter(const Type& type, + absl::string_view lang_name) { + switch (type.kind()) { + case TypeKind::kList: { + const auto& list_type = static_cast(type); + PrintListConverter(list_type, lang_name); + break; + } + + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + PrintVariantConverter(variant_type, lang_name); + break; + } + + case TypeKind::kClass: { + const auto& class_type = static_cast(type); + PrintClassConverter(class_type, lang_name); + break; + } + + case TypeKind::kEnum: { + const auto& enum_type = static_cast(type); + PrintEnumConverter(enum_type, lang_name); + break; + } + + case TypeKind::kBuiltin: { + const auto& builtin_type = static_cast(type); + PrintBuiltinConverter(builtin_type, lang_name); + break; + } + } +} + +void AstFromJsonPrinter::PrintBuiltinConverter(const BuiltinType& builtin_type, + absl::string_view lang_name) { + switch (builtin_type.builtin_kind()) { + case BuiltinTypeKind::kString: + Print("JsonToString"); + break; + case BuiltinTypeKind::kBool: + Print("JsonToBool"); + break; + case BuiltinTypeKind::kInt64: + Print("JsonToInt64"); + break; + case BuiltinTypeKind::kDouble: + Print("JsonToDouble"); + break; + default: + LOG(FATAL) << "Unreachable code."; + } +} + +void AstFromJsonPrinter::PrintEnumConverter(const EnumType& enum_type, + absl::string_view lang_name) { + auto vars = WithVars({ + {"EnumName", (Symbol(lang_name) + enum_type.name()).ToPascalCase()}, + {"cc_type", enum_type.CcType()}, + }); + Print("Enum<$cc_type$>(StringTo$EnumName$)"); +} + +void AstFromJsonPrinter::PrintClassConverter(const ClassType& class_type, + absl::string_view lang_name) { + Print(absl::StrCat(class_type.CcClassName(), "::FromJson")); +} + +void AstFromJsonPrinter::PrintVariantConverter(const VariantType& variant_type, + absl::string_view lang_name) { + // Variant( + // VariantOption{ + // .predicate = IsDouble, + // .converter = JsonToDouble, + // }, + // VariantOption{ + // .predicate = IsString, + // .converter = JsonToString, + // } + // ) + + Println("Variant("); + { + auto indent = WithIndent(4); + TabPrinter tab_printer{{ + .print_separator = [this] { Print(",\n"); }, + }}; + + for (const auto& type : variant_type.types()) { + tab_printer.Print(); + + Println(absl::StrCat("VariantOption<", type->CcType(), ">{")); + { + auto indent = WithIndent(4); + + Print(".predicate = "); + PrintTypeCheckerName(*type); + Println(","); + + Print(".converter = "); + PrintConverter(*type, lang_name); + Println(","); + } + Print("}"); + } + } + Print(")"); +} + +void AstFromJsonPrinter::PrintListConverter(const ListType& list_type, + absl::string_view lang_name) { + // List>>( + // Nullable>(MyClass::FromJson) + // ) + + const NonListType& element_type = list_type.element_type(); + + auto vars = WithVars({ + {"nullable_element_cc_type", + element_type.CcType(list_type.element_maybe_null())}, + {"element_cc_type", element_type.CcType()}, + }); + + Println("List<$nullable_element_cc_type$>("); + { + auto indent = WithIndent(4); + if (list_type.element_maybe_null() == MaybeNull::kYes) { + Println("Nullable<$element_cc_type$>("); + { + auto indent = WithIndent(4); + PrintConverter(element_type, lang_name); + Println(); + } + Println(")"); + } else { + PrintConverter(element_type, lang_name); + Println(); + } + } + Print(")"); +} + +void AstFromJsonPrinter::PrintFromJsonFunction(const NodeDef& node, + absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + {"json_variable", kJsonValueVariableName}, + }); + + Println("absl::StatusOr>"); + Println("$NodeType$::FromJson(const nlohmann::json& $json_variable$) {"); + { + auto indent = WithIndent(); + + const auto check_is_object = UnIndentedSource(R"cc( + if (!$json_variable$.is_object()) { + return absl::InvalidArgumentError("JSON is not an object."); + } + )cc"); + Println(check_is_object); + Println(); + + if (!node.children().empty()) { + // This is a non-leaf type. + // We get the `type` field and dispatch the corresponding FromJson() + // function. + + Println( + "MALDOCA_ASSIGN_OR_RETURN" + "(std::string type, GetType($json_variable$));"); + Println(); + + IfStmtPrinter if_stmt_printer(this); + for (const NodeDef* descendent : node.descendants()) { + auto vars = WithVars({ + {"DescendentType", + (Symbol(lang_name) + descendent->name()).ToPascalCase()}, + {"DescendentTypeNoLangName", descendent->name()}, + }); + if_stmt_printer.PrintCase({ + [&] { Print("type == \"$DescendentTypeNoLangName$\""); }, + [&] { + Println("return $DescendentType$::FromJson($json_variable$);"); + }, + }); + } + Println(); + + Print("return absl::InvalidArgumentError"); + Println(R"((absl::StrCat("Invalid type: ", type));)"); + + } else { + // This is a leaf type. + // We get all the fields and call the constructor. + + struct NodeFieldPair { + std::string node_name; + Symbol field_name; + }; + std::vector node_field_pairs; + for (const NodeDef* ancestor : node.ancestors()) { + for (const FieldDef& field : ancestor->fields()) { + node_field_pairs.push_back({ancestor->name(), field.name()}); + } + } + for (const FieldDef& field : node.fields()) { + node_field_pairs.push_back({node.name(), field.name()}); + } + + for (const NodeFieldPair& node_field_pair : node_field_pairs) { + auto vars = WithVars({ + {"NodeType", + (Symbol(lang_name) + node_field_pair.node_name).ToPascalCase()}, + {"field_name", node_field_pair.field_name.ToCcVarName()}, + {"FieldName", node_field_pair.field_name.ToPascalCase()}, + }); + Println( + "MALDOCA_ASSIGN_OR_RETURN(auto $field_name$, " + "$NodeType$::Get$FieldName$($json_variable$));"); + } + + Println(); + + // Call the constructor. + Print("return absl::make_unique<$NodeType$>(\n"); + { + auto indent = WithIndent(4); + TabPrinter tab_printer{{ + .print_separator = [this] { Print(",\n"); }, + }}; + for (const FieldDef* field : node.aggregated_fields()) { + auto vars = WithVars({ + {"field_name", field->name().ToCcVarName()}, + }); + + tab_printer.Print(); + Print("std::move($field_name$)"); + } + } + + Println(");"); + } + } + Println("}"); +} + +std::string PrintAstFromJson(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + AstFromJsonPrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ast_from_json_printer.h b/maldoca/astgen/ast_from_json_printer.h new file mode 100644 index 0000000..02def92 --- /dev/null +++ b/maldoca/astgen/ast_from_json_printer.h @@ -0,0 +1,70 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_FROM_JSON_PRINTER_H_ +#define MALDOCA_ASTGEN_AST_FROM_JSON_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +class AstFromJsonPrinter : public CcPrinterBase { + public: + explicit AstFromJsonPrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + + private: + void PrintTypeChecker(const NodeDef& node); + + void PrintGetFieldFunction(const std::string& node_name, + const FieldDef& field, + absl::string_view lang_name); + + void PrintFromJsonFunction(const NodeDef& node, absl::string_view lang_name); + + void PrintTypeCheckerName(const ScalarType& type); + + void PrintConverter(const Type& type, absl::string_view lang_name); + + void PrintBuiltinConverter(const BuiltinType& builtin_type, + absl::string_view lang_name); + + void PrintEnumConverter(const EnumType& enum_type, + absl::string_view lang_name); + + void PrintClassConverter(const ClassType& class_type, + absl::string_view lang_name); + + void PrintVariantConverter(const VariantType& variant_type, + absl::string_view lang_name); + + void PrintListConverter(const ListType& list_type, + absl::string_view lang_name); +}; + +std::string PrintAstFromJson(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_FROM_JSON_PRINTER_H_ diff --git a/maldoca/astgen/ast_from_json_utils.h b/maldoca/astgen/ast_from_json_utils.h new file mode 100644 index 0000000..a17cf4f --- /dev/null +++ b/maldoca/astgen/ast_from_json_utils.h @@ -0,0 +1,238 @@ +// Copyright 2025 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. + +#ifndef MALDOCA_ASTGEN_AST_FROM_JSON_UTILS_H_ +#define MALDOCA_ASTGEN_AST_FROM_JSON_UTILS_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/string_view.h" +#include "nlohmann/json.hpp" +#include "maldoca/base/status_macros.h" + +namespace maldoca { + +template +using Converter = std::function(const nlohmann::json&)>; + +template +absl::StatusOr GetRequiredField(const nlohmann::json& json, + absl::string_view field_name, + Converter converter) { + auto field_it = json.find(field_name); + if (field_it == json.end()) { + return absl::InvalidArgumentError( + absl::StrCat("`", field_name, "` is undefined.")); + } + const nlohmann::json& json_field = field_it.value(); + if (json_field.is_null()) { + return absl::InvalidArgumentError( + absl::StrCat("`", field_name, "` is null.")); + } + return converter(json_field); +} + +template +absl::StatusOr> GetOptionalField(const nlohmann::json& json, + absl::string_view field_name, + Converter converter) { + auto field_it = json.find(field_name); + if (field_it == json.end()) { + return std::nullopt; + } + const nlohmann::json& json_field = field_it.value(); + if (json_field.is_null()) { + return absl::InvalidArgumentError( + absl::StrCat("`", field_name, "` is null.")); + } + return converter(json_field); +} + +template +absl::StatusOr> GetNullableField(const nlohmann::json& json, + absl::string_view field_name, + Converter converter) { + auto field_it = json.find(field_name); + if (field_it == json.end()) { + return absl::InvalidArgumentError( + absl::StrCat("`", field_name, "` is undefined.")); + } + const nlohmann::json& json_field = field_it.value(); + if (json_field.is_null()) { + return std::nullopt; + } + return converter(json_field); +} + +inline bool IsString(const nlohmann::json& json) { return json.is_string(); } + +inline absl::StatusOr JsonToString(const nlohmann::json& json) { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_string()) { + return absl::InvalidArgumentError("json is not a string."); + } + return json.get(); +} + +inline bool IsBool(const nlohmann::json& json) { return json.is_boolean(); } + +inline absl::StatusOr JsonToBool(const nlohmann::json& json) { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_boolean()) { + return absl::InvalidArgumentError("json is not a boolean."); + } + return json.get(); +} + +inline bool IsInt64(const nlohmann::json& json) { + return json.is_number_integer(); +} + +inline absl::StatusOr JsonToInt64(const nlohmann::json& json) { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_number_integer()) { + return absl::InvalidArgumentError("json is not an integer."); + } + return json.get(); +} + +inline bool IsDouble(const nlohmann::json& json) { return json.is_number(); } + +inline absl::StatusOr JsonToDouble(const nlohmann::json& json) { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_number()) { + return absl::InvalidArgumentError("json is not a number."); + } + return json.get(); +} + +template +inline Converter Enum( + std::function(absl::string_view)> string_to_enum) { + return [=](const nlohmann::json& json) -> absl::StatusOr { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_string()) { + return absl::InvalidArgumentError("json is not a string."); + } + return string_to_enum(json.get()); + }; +} + +template +Converter> Nullable(Converter converter) { + return [=](const nlohmann::json& json) -> absl::StatusOr> { + if (json.is_null()) { + return std::nullopt; + } + return converter(json); + }; +} + +template +Converter> List(Converter elem_converter) { + return [=](const nlohmann::json& json) -> absl::StatusOr> { + if (json.is_null()) { + return absl::InvalidArgumentError("json is null."); + } + if (!json.is_array()) { + return absl::InvalidArgumentError("json is not an array."); + } + std::vector result; + for (const nlohmann::json& element : json) { + MALDOCA_ASSIGN_OR_RETURN(T value, elem_converter(element)); + result.push_back(std::move(value)); + } + return result; + }; +} + +template +struct VariantOption { + std::function predicate; + Converter converter; +}; + +// JsonToVariant: +// Takes VariantOption option1, ..., VariantOption optionk; +// Returns absl::StatusOr>. +// +// If option1.predicate(json), then return option1.converter(json); +// ... +// If optionk.predicate(json), then return optionk.converter(json). +// Otherwise, returns absl::InvalidArgumentError("Invalid type: "). + +namespace internal { +template +absl::StatusOr JsonToVariantRecursive(const nlohmann::json& json) { + return absl::InvalidArgumentError("Invalid type: "); +} + +template +absl::StatusOr JsonToVariantRecursive(const nlohmann::json& json, + VariantOption option, + VariantOption... rest) { + if (option.predicate(json)) { + MALDOCA_ASSIGN_OR_RETURN(T value, option.converter(json)); + return Variant(std::move(value)); + } + return JsonToVariantRecursive(json, std::move(rest)...); +} +} // namespace internal + +template +Converter> Variant(VariantOption... options) { + return + [=](const nlohmann::json& json) -> absl::StatusOr> { + return internal::JsonToVariantRecursive>( + json, std::move(options)...); + }; +} + +inline absl::StatusOr GetType(const nlohmann::json& json) { + auto type_it = json.find("type"); + if (type_it == json.end()) { + return absl::InvalidArgumentError("`type` is undefined."); + } + const nlohmann::json& json_type = type_it.value(); + if (json_type.is_null()) { + return absl::InvalidArgumentError("json_type is null."); + } + if (!json_type.is_string()) { + return absl::InvalidArgumentError("`json_type` expected to be string."); + } + return json_type.get(); +} + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_FROM_JSON_UTILS_H_ diff --git a/maldoca/astgen/ast_gen_main.cc b/maldoca/astgen/ast_gen_main.cc index b030da6..44a5ff7 100644 --- a/maldoca/astgen/ast_gen_main.cc +++ b/maldoca/astgen/ast_gen_main.cc @@ -28,7 +28,13 @@ #include "absl/strings/str_cat.h" #include "maldoca/astgen/ast_def.h" #include "maldoca/astgen/ast_def.pb.h" -#include "maldoca/astgen/ast_gen.h" +#include "maldoca/astgen/ast_from_json_printer.h" +#include "maldoca/astgen/ast_header_printer.h" +#include "maldoca/astgen/ast_serialize_printer.h" +#include "maldoca/astgen/ast_source_printer.h" +#include "maldoca/astgen/ast_to_ir_source_printer.h" +#include "maldoca/astgen/ir_table_gen_printer.h" +#include "maldoca/astgen/ir_to_ast_source_printer.h" #include "maldoca/base/filesystem.h" #include "maldoca/base/path.h" #include "maldoca/base/status_macros.h" diff --git a/maldoca/astgen/ast_gen_test.cc b/maldoca/astgen/ast_gen_test.cc index 81dd1c5..fdc6d64 100644 --- a/maldoca/astgen/ast_gen_test.cc +++ b/maldoca/astgen/ast_gen_test.cc @@ -12,8 +12,6 @@ // See the License for the specific language governing permissions and // limitations under the License. -#include "maldoca/astgen/ast_gen.h" - #include #include #include @@ -23,7 +21,10 @@ #include "absl/strings/ascii.h" #include "maldoca/astgen/ast_def.h" #include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_from_json_printer.h" +#include "maldoca/astgen/ast_header_printer.h" #include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/ts_interface_printer.h" #include "maldoca/astgen/type.h" #include "maldoca/base/filesystem.h" #include "maldoca/base/testing/status_matchers.h" @@ -136,387 +137,5 @@ TEST(PrintFieldDef, PrintMultiLineTitleWithEmptyLine) { absl::StripAsciiWhitespace(kExpectedOutput)); } -// ============================================================================= -// AstFromJsonPrinter::PrintBuiltinFromJson() -// ============================================================================= - -TEST(AstFromJsonPrinterTest, TestPrintAssignBuiltinFromJson) { - static const char kExpectedOutput[] = R"( -my_lhs = my_rhs.get(); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintBuiltinFromJson( - AstFromJsonPrinter::Action::kAssign, - AstFromJsonPrinter::CheckJsonType::kNo, - BuiltinType(BuiltinTypeKind::kString, "UsedLanguage"), Symbol("my_lhs"), - Symbol("my_rhs")); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintDefBuiltinFromJson) { - static const char kExpectedOutput[] = R"( -auto my_lhs = my_rhs.get(); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintBuiltinFromJson( - AstFromJsonPrinter::Action::kDef, - AstFromJsonPrinter::CheckJsonType::kNo, - BuiltinType(BuiltinTypeKind::kString, "UsedLanguage"), Symbol("my_lhs"), - Symbol("my_rhs")); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintReturnBuiltinFromJson) { - static const char kExpectedOutput[] = R"( -return my_rhs.get(); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintBuiltinFromJson( - AstFromJsonPrinter::Action::kReturn, - AstFromJsonPrinter::CheckJsonType::kNo, - BuiltinType(BuiltinTypeKind::kString, "UsedLanguage"), Symbol("my_lhs"), - Symbol("my_rhs")); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintAssignClassFromJson) { - static const char kExpectedOutput[] = R"( -MALDOCA_ASSIGN_OR_RETURN(my_lhs, UsedLanguageClassType::FromJson(my_rhs)); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintClassFromJson(AstFromJsonPrinter::Action::kAssign, - ClassType(Symbol("ClassType"), "UsedLanguage"), - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintDefClassFromJson) { - static const char kExpectedOutput[] = R"( -MALDOCA_ASSIGN_OR_RETURN(auto my_lhs, UsedLanguageClassType::FromJson(my_rhs)); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintClassFromJson(AstFromJsonPrinter::Action::kDef, - ClassType(Symbol("ClassType"), "UsedLanguage"), - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintReturnClassFromJson) { - static const char kExpectedOutput[] = R"( -return UsedLanguageClassType::FromJson(my_rhs); - )"; - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintClassFromJson(AstFromJsonPrinter::Action::kReturn, - ClassType(Symbol("ClassType"), "UsedLanguage"), - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -// ============================================================================= -// AstFromJsonPrinter::PrintVariantFromJson() -// ============================================================================= - -TEST(AstFromJsonPrinterTest, TestPrintAssignVariantFromJson) { - static const char kExpectedOutput[] = R"( -if (my_rhs.is_string()) { - my_lhs = my_rhs.get(); -} else if (IsClassType(my_rhs)) { - MALDOCA_ASSIGN_OR_RETURN(my_lhs, UsedLanguageClassType::FromJson(my_rhs)); -} else { - auto result = absl::InvalidArgumentError("my_rhs has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{my_rhs.dump()}); - return result; -} - )"; - - std::vector> types; - types.push_back( - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage")); - types.push_back( - absl::make_unique(Symbol("ClassType"), "UsedLanguage")); - auto variant_type = VariantType(std::move(types), "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintVariantFromJson(AstFromJsonPrinter::Action::kAssign, - variant_type, Symbol("my_lhs"), - Symbol("my_rhs"), "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintDefVariantFromJson) { - static const char kExpectedOutput[] = R"( -std::variant> my_lhs; -if (my_rhs.is_string()) { - my_lhs = my_rhs.get(); -} else if (IsClassType(my_rhs)) { - MALDOCA_ASSIGN_OR_RETURN(my_lhs, UsedLanguageClassType::FromJson(my_rhs)); -} else { - auto result = absl::InvalidArgumentError("my_rhs has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{my_rhs.dump()}); - return result; -} - )"; - - std::vector> types; - types.push_back( - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage")); - types.push_back( - absl::make_unique(Symbol("ClassType"), "UsedLanguage")); - auto variant_type = VariantType(std::move(types), "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintVariantFromJson(AstFromJsonPrinter::Action::kDef, variant_type, - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintReturnVariantFromJson) { - static const char kExpectedOutput[] = R"( -if (my_rhs.is_string()) { - return my_rhs.get(); -} else if (IsClassType(my_rhs)) { - return UsedLanguageClassType::FromJson(my_rhs); -} else { - auto result = absl::InvalidArgumentError("my_rhs has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{my_rhs.dump()}); - return result; -} - )"; - - std::vector> types; - types.push_back( - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage")); - types.push_back( - absl::make_unique(Symbol("ClassType"), "UsedLanguage")); - auto variant_type = VariantType(std::move(types), "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintVariantFromJson(AstFromJsonPrinter::Action::kReturn, - variant_type, Symbol("my_lhs"), - Symbol("my_rhs"), "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -// ============================================================================= -// AstFromJsonPrinter::PrintListFromJson() -// ============================================================================= - -TEST(AstFromJsonPrinterTest, TestPrintAssignListFromJson) { - static const char kExpectedOutput[] = R"( -if (!my_rhs.is_array()) { - return absl::InvalidArgumentError("my_rhs expected to be array."); -} - -std::vector my_lhs_value; -for (const nlohmann::json& my_rhs_element : my_rhs) { - if (my_rhs_element.is_null()) { - return absl::InvalidArgumentError("my_rhs_element is null."); - } - if (!my_rhs_element.is_string()) { - return absl::InvalidArgumentError("Expecting my_rhs_element.is_string()."); - } - auto my_lhs_element = my_rhs_element.get(); - my_lhs_value.push_back(std::move(my_lhs_element)); -} -my_lhs = std::move(my_lhs_value); - )"; - - auto element_type = - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage"); - auto list_type = - ListType(std::move(element_type), MaybeNull::kNo, "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintListFromJson(AstFromJsonPrinter::Action::kAssign, list_type, - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintDefListFromJson) { - static const char kExpectedOutput[] = R"( -if (!my_rhs.is_array()) { - return absl::InvalidArgumentError("my_rhs expected to be array."); -} - -std::vector my_lhs; -for (const nlohmann::json& my_rhs_element : my_rhs) { - if (my_rhs_element.is_null()) { - return absl::InvalidArgumentError("my_rhs_element is null."); - } - if (!my_rhs_element.is_string()) { - return absl::InvalidArgumentError("Expecting my_rhs_element.is_string()."); - } - auto my_lhs_element = my_rhs_element.get(); - my_lhs.push_back(std::move(my_lhs_element)); -} - )"; - - auto element_type = - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage"); - auto list_type = - ListType(std::move(element_type), MaybeNull::kNo, "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintListFromJson(AstFromJsonPrinter::Action::kDef, list_type, - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintReturnListFromJson) { - static const char kExpectedOutput[] = R"( -if (!my_rhs.is_array()) { - return absl::InvalidArgumentError("my_rhs expected to be array."); -} - -std::vector my_lhs; -for (const nlohmann::json& my_rhs_element : my_rhs) { - if (my_rhs_element.is_null()) { - return absl::InvalidArgumentError("my_rhs_element is null."); - } - if (!my_rhs_element.is_string()) { - return absl::InvalidArgumentError("Expecting my_rhs_element.is_string()."); - } - auto my_lhs_element = my_rhs_element.get(); - my_lhs.push_back(std::move(my_lhs_element)); -} -return my_lhs; - )"; - - auto element_type = - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage"); - auto list_type = - ListType(std::move(element_type), MaybeNull::kNo, "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintListFromJson(AstFromJsonPrinter::Action::kReturn, list_type, - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - -TEST(AstFromJsonPrinterTest, TestPrintDefListOfOptionalElementsFromJson) { - static const char kExpectedOutput[] = R"( -if (!my_rhs.is_array()) { - return absl::InvalidArgumentError("my_rhs expected to be array."); -} - -std::vector> my_lhs; -for (const nlohmann::json& my_rhs_element : my_rhs) { - std::optional my_lhs_element; - if (!my_rhs_element.is_null()) { - if (!my_rhs_element.is_string()) { - return absl::InvalidArgumentError("Expecting my_rhs_element.is_string()."); - } - my_lhs_element = my_rhs_element.get(); - } - my_lhs.push_back(std::move(my_lhs_element)); -} - )"; - - auto element_type = - absl::make_unique(BuiltinTypeKind::kString, "UsedLanguage"); - auto list_type = - ListType(std::move(element_type), MaybeNull::kYes, "UsedLanguage"); - - std::string output; - { - google::protobuf::io::StringOutputStream os(&output); - AstFromJsonPrinter printer(&os); - printer.PrintListFromJson(AstFromJsonPrinter::Action::kDef, list_type, - Symbol("my_lhs"), Symbol("my_rhs"), - "UsedLanguage"); - } - - EXPECT_EQ(absl::StripAsciiWhitespace(output), - absl::StripAsciiWhitespace(kExpectedOutput)); -} - } // namespace } // namespace maldoca diff --git a/maldoca/astgen/ast_gen_utils.h b/maldoca/astgen/ast_gen_utils.h new file mode 100644 index 0000000..cc91620 --- /dev/null +++ b/maldoca/astgen/ast_gen_utils.h @@ -0,0 +1,206 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_GEN_UTILS_H_ +#define MALDOCA_ASTGEN_AST_GEN_UTILS_H_ + +#include + +#include +#include +#include +#include +#include +#include + +#include "absl/algorithm/container.h" +#include "absl/strings/ascii.h" +#include "absl/strings/str_join.h" +#include "absl/strings/str_split.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/base/path.h" +#include "google/protobuf/io/printer.h" + +namespace maldoca { + +inline constexpr absl::string_view kJsonValueVariableName = "json"; +inline constexpr absl::string_view kOsValueVariableName = "os"; + +inline std::string GetAstHeaderPath(absl::string_view ast_path) { + return JoinPath(ast_path, "ast.generated.h"); +} + +struct TabPrinterOptions { + std::function print_prefix = nullptr; + std::function print_separator = nullptr; + std::function print_postfix = nullptr; +}; + +class TabPrinter : private TabPrinterOptions { + public: + explicit TabPrinter(TabPrinterOptions options) + : TabPrinterOptions(std::move(options)) {} + + ~TabPrinter() { + if (!is_first_) { + if (print_postfix) { + print_postfix(); + } + } + } + + void Print() { + if (is_first_) { + if (print_prefix) { + print_prefix(); + } + is_first_ = false; + } else { + if (print_separator) { + print_separator(); + } + } + } + + private: + bool is_first_ = true; +}; + +// Helper for printing an if-statement. +// +// Usage: +// IfStmtPrinter printer(...); +// printer.PrintCase({ +// [&] { +// PrintConditionHere(); +// }, +// [&] { +// PrintBodyHere(); +// }, +// }); +// printer.PrintCase({ +// [&] { +// PrintAnotherConditionHere(); +// }, +// [&] { +// PrintAnotherBodyHere(); +// }, +// }); +// +// This helper adds the "else" keyword to all subsequent cases. +class IfStmtPrinter { + public: + explicit IfStmtPrinter(google::protobuf::io::Printer* printer) + : is_first_(true), printer_(printer) {} + + struct IfStmtCase { + std::function condition; + std::function body; + }; + + void PrintCase(const IfStmtCase& kase) { + if (is_first_) { + printer_->Print("if ("); + is_first_ = false; + } else { + printer_->Print(" else if ("); + } + kase.condition(); + printer_->Print(") {\n"); + { + auto indent = printer_->WithIndent(); + kase.body(); + } + printer_->Print("}"); + } + + private: + bool is_first_; + google::protobuf::io::Printer* printer_; +}; + +// Consistently unindent lines of code so that the outmost line has no +// indentation. +// +// Example: +// +// Input: +// ``` +// abc +// abc +// abc +// ``` +// +// Output: +// ``` +// abc +// abc +// abc +// ``` +inline std::string UnIndentedSource(absl::string_view source) { + source = absl::StripTrailingAsciiWhitespace(source); + + std::vector lines = absl::StrSplit(source, '\n'); + + // Remove leading empty lines. + lines.erase(lines.begin(), absl::c_find_if(lines, [](const auto& line) { + return !line.empty(); + })); + + size_t min_indent = absl::c_accumulate( + lines, std::numeric_limits::max(), + [](size_t current_min, const std::string& line) { + size_t first_non_whitespace = line.find_first_not_of(' '); + if (first_non_whitespace == std::string::npos) { + return current_min; + } + return std::min(current_min, first_non_whitespace); + }); + + for (auto& line : lines) { + if (line.size() >= min_indent) { + line.erase(0, min_indent); + } + } + + return absl::StrJoin(lines, "\n"); +} + +// FieldIs{Argument,Region}: +// +// If a field has ignore_in_ir(), then we don't define anything in the op. +// +// Example: Node::start does not lead to any argument/region in JSIR because we +// want to store the information in mlir::Location. +// +// If a field has enclose_in_region(), then it's an MLIR "region"; otherwise +// it's an MLIR "argument". +// +// An argument is either an mlir::Attribute or an mlir::Value; +// A region is an mlir::Region. +// +// See FieldDefPb::enclose_in_region for why we need to enclose certain fields +// in a region. +inline bool FieldIsArgument(const FieldDef* field) { + return !field->ignore_in_ir() && !field->enclose_in_region(); +} + +inline bool FieldIsRegion(const FieldDef* field) { + return !field->ignore_in_ir() && field->enclose_in_region(); +} + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_GEN_UTILS_H_ diff --git a/maldoca/astgen/ast_header_printer.cc b/maldoca/astgen/ast_header_printer.cc new file mode 100644 index 0000000..04ab91b --- /dev/null +++ b/maldoca/astgen/ast_header_printer.cc @@ -0,0 +1,352 @@ +// 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 "maldoca/astgen/ast_header_printer.h" + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { + +void AstHeaderPrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path) { + auto header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + PrintEnterHeaderGuard(header_path); + Println(); + + Println("// IWYU pragma: begin_keep"); + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeader("absl/status/statusor.h"); + PrintIncludeHeader("absl/strings/string_view.h"); + PrintIncludeHeader("nlohmann/json.hpp"); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + for (const EnumDef& enum_def : ast.enum_defs()) { + PrintEnum(enum_def, ast.lang_name()); + Println(); + } + + for (const NodeDef* node : ast.topological_sorted_nodes()) { + PrintNode(*node, ast.lang_name()); + Println(); + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); + Println(); + + PrintExitHeaderGuard(header_path); +} + +void AstHeaderPrinter::PrintEnum(const EnumDef& enum_def, + absl::string_view lang_name) { + auto vars = WithVars({ + {"EnumName", (Symbol(lang_name) + enum_def.name()).ToPascalCase()}, + {"enum_name", enum_def.name().ToSnakeCase()}, + }); + + Println("enum class $EnumName$ {"); + { + auto indent = WithIndent(); + for (const EnumMemberDef& member : enum_def.members()) { + auto vars = WithVars({ + {"kMemberName", (Symbol("k") + member.name()).ToCamelCase()}, + }); + + Println("$kMemberName$,"); + } + } + Println("};"); + Println(); + + Println("absl::string_view $EnumName$ToString($EnumName$ $enum_name$);"); + Println( + "absl::StatusOr<$EnumName$> StringTo$EnumName$(absl::string_view s);"); +} + +void AstHeaderPrinter::PrintNode(const NodeDef& node, + absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + {"json_variable", kJsonValueVariableName}, + {"os_variable", kOsValueVariableName}, + }); + + if (node.node_type_enum().has_value()) { + PrintEnum(*node.node_type_enum().value(), lang_name); + Println(); + } + + Print("class $NodeType$"); + if (!node.parents().empty()) { + Print(" : "); + TabPrinter separator_printer{{ + .print_separator = [&] { Print(", "); }, + }}; + for (const NodeDef* parent : node.parents()) { + auto vars = WithVars({ + {"BaseType", (Symbol(lang_name) + parent->name()).ToPascalCase()}, + }); + + separator_printer.Print(); + Print("public virtual $BaseType$"); + } + } + Println(" {"); + + // Always print "public:" because the declaration of FromJson() always + // exists. + Println(" public:"); + { + auto indent = WithIndent(); + + // Constructor + if (!node.aggregated_fields().empty()) { + PrintConstructor(node, lang_name); + Println(); + } + + // Destructor + if (node.parents().empty() && !node.children().empty()) { + Println("virtual ~$NodeType$() = default;"); + Println(); + } + + // Get type enum. + if (node.node_type_enum().has_value()) { + auto node_type_enum_name = node.node_type_enum().value()->name(); + auto vars = WithVars({ + {"NodeTypeEnum", + (Symbol(lang_name) + node_type_enum_name).ToPascalCase()}, + {"node_type_enum", node_type_enum_name.ToCcVarName()}, + }); + + Println("virtual $NodeTypeEnum$ $node_type_enum$() const = 0;"); + Println(); + + } else if (node.children().empty()) { + for (const NodeDef* ancestor : node.ancestors()) { + if (!ancestor->node_type_enum().has_value()) { + continue; + } + + auto root_type_enum_name = ancestor->node_type_enum().value()->name(); + auto vars = WithVars({ + {"RootTypeEnum", + (Symbol(lang_name) + root_type_enum_name).ToPascalCase()}, + {"root_type_enum", root_type_enum_name.ToCcVarName()}, + {"NodeTypeNoLang", Symbol(node.name()).ToPascalCase()}, + }); + + Println("$RootTypeEnum$ $root_type_enum$() const override {"); + Println(" return $RootTypeEnum$::k$NodeTypeNoLang$;"); + Println("}"); + Println(); + } + } + + // Serialize + if (node.parents().empty()) { + if (node.children().empty()) { + // Non-virtual. + Println("void Serialize(std::ostream& $os_variable$) const;"); + Println(); + } else { + // Virtual base. + // We define a pure virtual function here, and override it in leaf + // types. + Println( + "virtual void Serialize(std::ostream& $os_variable$) " + "const = 0;"); + Println(); + } + } else { + if (node.children().empty()) { + // Leaf type. + // We override the virtual function. + Println( + "void Serialize(std::ostream& $os_variable$) " + "const override;"); + Println(); + } else { + // Non-leaf type - skipped. + // We only override in leaf types. Here it's still pure virtual. + } + } + + // FromJson + Println( + "static absl::StatusOr> FromJson(" + "const nlohmann::json& $json_variable$);"); + Println(); + + // Getters and setters. + for (const FieldDef& field : node.fields()) { + PrintGetterSetterDeclarations(field, lang_name); + Println(); + } + } + + Println(" protected:"); + { + auto indent = WithIndent(); + + // SerializeFields + Println("// Internal function used by Serialize()."); + Println("// Sets the fields defined in this class."); + Println("// Does not set fields defined in ancestors."); + Println( + "void SerializeFields(std::ostream& $os_variable$, " + "bool &needs_comma) const;"); + + // GetFromJson() functions. + if (!node.fields().empty()) { + Println(); + Println("// Internal functions used by FromJson()."); + Println("// Extracts a field from a JSON object."); + for (const FieldDef& field : node.fields()) { + PrintGetFromJson(field, lang_name); + } + } + } + + // Print member variables. + if (!node.fields().empty()) { + Println(); + Println(" private:"); + { + auto indent = WithIndent(); + for (const FieldDef& field : node.fields()) { + PrintMemberVariable(field, lang_name); + } + } + } + + Println("};"); +} + +void AstHeaderPrinter::PrintConstructor(const NodeDef& node, + absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + }); + Print("explicit $NodeType$("); + if (!node.aggregated_fields().empty()) { + Println(); + { + auto indent = WithIndent(4); + TabPrinter separator_printer{{ + .print_separator = [this] { Print(",\n"); }, + }}; + for (const FieldDef* field : node.aggregated_fields()) { + auto vars = WithVars({ + {"cc_type", CcType(*field)}, + {"field_name", field->name().ToCcVarName()}, + }); + + separator_printer.Print(); + Print("$cc_type$ $field_name$"); + } + } + } + Println(");"); +} + +void AstHeaderPrinter::PrintGetterSetterDeclarations( + const FieldDef& field, absl::string_view lang_name) { + std::string cc_getter_type = CcMutableGetterType(field); + std::string cc_const_getter_type = CcConstGetterType(field); + + auto vars = WithVars({ + {"cc_getter_type", cc_getter_type}, + {"cc_const_getter_type", cc_const_getter_type}, + {"cc_type", CcType(field)}, + {"field_name", field.name().ToCcVarName()}, + }); + + // If the mutable getter would return the same type as the const getter, skip + // the mutable getter. + if (cc_getter_type != cc_const_getter_type) { + Println("$cc_getter_type$ $field_name$();"); + } + Println("$cc_const_getter_type$ $field_name$() const;"); + Println("void set_$field_name$($cc_type$ $field_name$);"); +} + +void AstHeaderPrinter::PrintMemberVariable(const FieldDef& field, + absl::string_view lang_name) { + auto vars = WithVars({ + {"cc_type", CcType(field)}, + {"field_name", field.name().ToCcVarName()}, + }); + + Println("$cc_type$ $field_name$_;"); +} + +void AstHeaderPrinter::PrintGetFromJson(const FieldDef& field, + absl::string_view lang_name) { + auto vars = WithVars({ + {"cc_type", CcType(field)}, + {"FieldName", field.name().ToPascalCase()}, + {"os_variable", kOsValueVariableName}, + }); + + Println( + "static absl::StatusOr<$cc_type$> " + "Get$FieldName$(const nlohmann::json& $json_variable$);"); +} + +std::string PrintAstHeader(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + AstHeaderPrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ast_header_printer.h b/maldoca/astgen/ast_header_printer.h new file mode 100644 index 0000000..0078bf8 --- /dev/null +++ b/maldoca/astgen/ast_header_printer.h @@ -0,0 +1,124 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_HEADER_PRINTER_H_ +#define MALDOCA_ASTGEN_AST_HEADER_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +// Printer of the C++ header for the AST. +class AstHeaderPrinter : public CcPrinterBase { + public: + explicit AstHeaderPrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + // Prints the "ast.generated.h" header file. + // + // - cc_namespace: The C++ namespace for all the AST node classes. + // Example: "maldoca::astgen". + // + // - ast_path: The directory for the AST code. + // "ast.generated.h" is in that directory. + // This is used to generate the header guard. + // + // See test cases in test/ for examples. + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + + // Prints the enum definition and the prototypes of string conversion + // functions. + // + // Example: + // enum UnaryOperator { + // kMinus, + // ... + // }; + // + // absl::string_view UnaryOperatorToString(UnaryOperator unary_operator); + // absl::StatusOr StringToUnaryOperator(absl::string_view s); + void PrintEnum(const EnumDef& enum_def, absl::string_view lang_name); + + // Prints the class declaration for a node. + // + // See test cases in test/ for examples. + void PrintNode(const NodeDef& node, absl::string_view lang_name); + + // Prints the constructor of a node class. + // + // Example: + // explicit Variable(std::string identifier) + // : Expression(), identifier_(std::move(identifier)) {} + void PrintConstructor(const NodeDef& node, absl::string_view lang_name); + + // Prints the getter and setter declarations for a field. + // + // Format: + // (); + // () const; + // void set_( ); + // + // - cc_mutable_getter_type: See `Type::CcMutableGetterType()`. + // - cc_const_getter_type: See `Type::CcConstGetterType()`. + // - cc_type: See `Type::CcType()`. + // + // Example: + // Expression* right(); + // const Expression* right() const; + // void set_right(std::unique_ptr right); + void PrintGetterSetterDeclarations(const FieldDef& field, + absl::string_view lang_name); + + // Prints a member variable declaration. + // + // Format: + // _; + // + // - cc_type: The C++ value type. See `Type::CcType()`. + // - field_name_: We print the name in snake_case and add a '_'. + // + // Example: + // std::unique_ptr right_; + void PrintMemberVariable(const FieldDef& field, absl::string_view lang_name); + + // Format: + // static absl::StatusOr<> + // GetFromJson(const nlohmann::json& json); + // + // Example: + // static absl::StatusOr> + // GetRightFromJson(const nlohmann::json& json); + void PrintGetFromJson(const FieldDef& field, absl::string_view lang_name); +}; + +// Prints the "ast.generated.h" header file. +// +// - cc_namespace: The C++ namespace for all the AST node classes. +// Example: "maldoca::astgen". +// +// - ast_path: The directory for the AST code. +// "ast.generated.h" is in that directory. +// This is used to generate the header guard. +std::string PrintAstHeader(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_HEADER_PRINTER_H_ diff --git a/maldoca/astgen/ast_serialize_printer.cc b/maldoca/astgen/ast_serialize_printer.cc new file mode 100644 index 0000000..7d8bdc4 --- /dev/null +++ b/maldoca/astgen/ast_serialize_printer.cc @@ -0,0 +1,428 @@ +// 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 "maldoca/astgen/ast_serialize_printer.h" + +#include +#include + +#include "absl/log/check.h" +#include "absl/log/log.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { + +void AstSerializePrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path) { + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + }); + + auto header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + Println("// IWYU pragma: begin_keep"); + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeaders({ + std::string(header_path), + "absl/log/log.h", + "absl/memory/memory.h", + "absl/status/status.h", + "absl/strings/string_view.h", + "nlohmann/json.hpp", + "maldoca/base/status_macros.h", + }); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + Println( + R"(void MaybeAddComma(std::ostream &$os_variable$, bool &needs_comma) { + if (needs_comma) { + $os_variable$ << ","; + } + needs_comma = true; +} +)"); + + for (const auto& node : ast.topological_sorted_nodes()) { + PrintTitle((Symbol(ast.lang_name()) + node->name()).ToPascalCase()); + Println(); + + PrintSerializeFieldsFunction(*node, ast.lang_name()); + Println(); + + if (node->children().empty()) { + PrintSerializeFunction(*node, ast.lang_name()); + Println(); + } + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); +} + +void AstSerializePrinter::PrintBuiltinSerialize(const BuiltinType& type, + const std::string& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + {"lhs", lhs}, + {"rhs", rhs}, + }); + + if (!lhs.empty()) { + Println("$os_variable$ << $lhs$ << (nlohmann::json($rhs$)).dump();"); + } else { + Println("$os_variable$ << (nlohmann::json($rhs$)).dump();"); + } +} + +void AstSerializePrinter::PrintEnumSerialize(const EnumType& type, + const std::string& lhs, + const std::string& rhs, + absl::string_view lang_name) { + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + {"lhs", lhs}, + {"rhs", rhs}, + {"EnumName", (Symbol(lang_name) + type.name()).ToPascalCase()}, + }); + + if (!lhs.empty()) { + Println( + R"($os_variable$ << $lhs$ << "\"" << $EnumName$ToString($rhs$) << "\"";)"); + } else { + Println(R"($os_variable$ << "\"" << $EnumName$ToString($rhs$) << "\"";)"); + } +} + +void AstSerializePrinter::PrintClassSerialize(const ClassType& type, + const std::string& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + {"lhs", lhs}, + {"rhs", rhs}, + }); + + if (!lhs.empty()) { + Println("$os_variable$ << $lhs$;"); + } + Println("$rhs$->Serialize($os_variable$);"); +} + +void AstSerializePrinter::PrintVariantSerialize(const VariantType& variant_type, + const std::string& lhs, + const std::string& rhs, + absl::string_view lang_name) { + auto vars = WithVars({ + {"lhs", lhs}, + {"rhs", rhs}, + }); + + Println("switch ($rhs$.index()) {"); + { + auto indent = WithIndent(); + for (size_t i = 0; i != variant_type.types().size(); ++i) { + auto vars = WithVars({ + {"i", std::to_string(i)}, + }); + + Println("case $i$: {"); + { + auto indent = WithIndent(); + const ScalarType& type = *variant_type.types()[i]; + PrintSerialize(type, lhs, absl::StrFormat("std::get<%zu>(%s)", i, rhs), + lang_name); + Println("break;"); + } + + Println("}"); + } + + Println("default:"); + Println(" LOG(FATAL) << \"Unreachable code.\";"); + } + Println("}"); +} + +void AstSerializePrinter::PrintListSerialize(const ListType& list_type, + const std::string& lhs, + const std::string& rhs, + absl::string_view lang_name) { + constexpr char kRhsElement[] = "element"; + CHECK_NE(lhs, kRhsElement); + CHECK_NE(rhs, kRhsElement); + + constexpr char kLhsElement[] = "element_json"; + CHECK_NE(lhs, kLhsElement); + CHECK_NE(rhs, kLhsElement); + + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + {"lhs", lhs}, + {"rhs", rhs}, + {"lhs_element", kLhsElement}, + {"rhs_element", kRhsElement}, + }); + + if (!lhs.empty()) { + Println(R"($os_variable$ << $lhs$ << "[";)"); + } else { + Println(R"($os_variable$ << "[";)"); + } + Println("{"); + { + auto indent = WithIndent(); + + Println("bool needs_comma = false;"); + Println("for (const auto& $rhs_element$ : $rhs$) {"); + { + auto indent = WithIndent(); + Println("MaybeAddComma($os_variable$, needs_comma);"); + PrintNullableToJson(list_type.element_type(), + list_type.element_maybe_null(), "", kRhsElement, + lang_name); + } + Println("}"); + } + Println("}"); + Println(R"($os_variable$ << "]";)"); +} + +void AstSerializePrinter::PrintSerialize(const Type& type, + const std::string& lhs, + const std::string& rhs, + absl::string_view lang_name) { + switch (type.kind()) { + case TypeKind::kBuiltin: { + const auto& builtin_type = static_cast(type); + PrintBuiltinSerialize(builtin_type, lhs, rhs); + break; + } + + case TypeKind::kEnum: { + const auto& enum_type = static_cast(type); + PrintEnumSerialize(enum_type, lhs, rhs, lang_name); + break; + } + + case TypeKind::kClass: { + const auto& class_type = static_cast(type); + PrintClassSerialize(class_type, lhs, rhs); + break; + } + + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + PrintVariantSerialize(variant_type, lhs, rhs, lang_name); + break; + } + + case TypeKind::kList: { + const auto& list_type = static_cast(type); + PrintListSerialize(list_type, lhs, rhs, lang_name); + break; + } + } +} + +void AstSerializePrinter::PrintNullableToJson(const Type& type, + MaybeNull maybe_null, + const std::string& lhs, + const std::string& rhs, + absl::string_view lang_name) { + switch (maybe_null) { + case MaybeNull::kNo: { + PrintSerialize(type, lhs, rhs, lang_name); + break; + } + + case MaybeNull::kYes: { + auto vars = WithVars({ + {"os_variable", kOsValueVariableName}, + {"lhs", lhs}, + {"rhs", rhs}, + }); + + Println("if ($rhs$.has_value()) {"); + { + auto indent = WithIndent(); + auto rhs_value = absl::StrCat(rhs, ".value()"); + PrintSerialize(type, lhs, rhs_value, lang_name); + } + Println("} else {"); + { + auto indent = WithIndent(); + + if (!lhs.empty()) { + Println(R"($os_variable$ << $lhs$ << "null";)"); + } else { + Println(R"($os_variable$ << "null";)"); + } + } + Println("}"); + break; + } + } +} + +void AstSerializePrinter::PrintSerializeFieldsFunction( + const NodeDef& node, absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + {"os_variable", kOsValueVariableName}, + }); + + Println( + "void $NodeType$::SerializeFields(std::ostream& $os_variable$, " + "bool &needs_comma) const {"); + { + auto indent = WithIndent(); + + for (const FieldDef& field : node.fields()) { + // E.g. "\"fieldName\":" + auto lhs = absl::StrFormat(R"("\"%s\":")", field.name().ToCamelCase()); + + // E.g. field_name_ + auto rhs = absl::StrCat(field.name().ToCcVarName(), "_"); + + switch (field.optionalness()) { + case OPTIONALNESS_UNSPECIFIED: { + LOG(FATAL) << "Invalid Optionalness. Should be a bug."; + break; + } + + case OPTIONALNESS_REQUIRED: { + Println("MaybeAddComma($os_variable$, needs_comma);"); + PrintSerialize(field.type(), lhs, rhs, lang_name); + break; + } + + case OPTIONALNESS_MAYBE_UNDEFINED: { + auto vars = WithVars({ + {"rhs", rhs}, + }); + + // If == std::nullopt, the assignment does not happen. + Println("if ($rhs$.has_value()) {"); + { + auto indent = WithIndent(); + auto rhs_value = absl::StrCat(rhs, ".value()"); + Println("MaybeAddComma($os_variable$, needs_comma);"); + PrintSerialize(field.type(), lhs, rhs_value, lang_name); + } + Println("}"); + + break; + } + case OPTIONALNESS_MAYBE_NULL: { + Println("MaybeAddComma($os_variable$, needs_comma);"); + PrintNullableToJson(field.type(), MaybeNull::kYes, lhs, rhs, + lang_name); + break; + } + } + } + } + Println("}"); +} + +void AstSerializePrinter::PrintSerializeFunction(const NodeDef& node, + absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + {"NodeTypeNoLangName", node.name()}, + {"os_variable", kOsValueVariableName}, + }); + + Println("void $NodeType$::Serialize(std::ostream& $os_variable$) const {"); + { + auto indent = WithIndent(); + + Println(R"($os_variable$ << "{";)"); + Println("{"); + { + auto indent = WithIndent(); + Println("bool needs_comma = false;"); + + // The "type" field. + if (!node.parents().empty() || !node.children().empty()) { + Println("MaybeAddComma($os_variable$, needs_comma);"); + Println(R"($os_variable$ << "\"type\":\"$NodeTypeNoLangName$\"";)"); + } + + // Assign fields of ancestors of this node. + for (const NodeDef* ancestor : node.ancestors()) { + auto vars = WithVars({ + {"AncestorType", + (Symbol(lang_name) + ancestor->name()).ToPascalCase()}, + }); + Println( + "$AncestorType$::SerializeFields($os_variable$, " + "needs_comma);"); + } + + // Assign fields of the node itself. + Println("$NodeType$::SerializeFields($os_variable$, needs_comma);"); + } + Println("}"); + + Println(R"($os_variable$ << "}";)"); + } + Println("}"); +} + +std::string PrintAstToJson(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + AstSerializePrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ast_serialize_printer.h b/maldoca/astgen/ast_serialize_printer.h new file mode 100644 index 0000000..5a4810c --- /dev/null +++ b/maldoca/astgen/ast_serialize_printer.h @@ -0,0 +1,93 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_SERIALIZE_PRINTER_H_ +#define MALDOCA_ASTGEN_AST_SERIALIZE_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +// Printer of the C++ Serialize() function for the AST. +class AstSerializePrinter : public CcPrinterBase { + public: + explicit AstSerializePrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + + private: + // Print*Serialize() + // + // Prints either: + // - An assignment " = ConvertSerialize();", or + // - A variable definition "nlohmann::json = ConvertSerialize();" + // + // - lhs: If printing an assignment, an lvalue expression of type + // nlohmann::json; if printing a variable definition, the name of that + // variable. + // - rhs: An expression of type `type.CcType()`. + void PrintBuiltinSerialize(const BuiltinType& type, const std::string& lhs, + const std::string& rhs); + + void PrintEnumSerialize(const EnumType& type, const std::string& lhs, + const std::string& rhs, absl::string_view lang_name); + + void PrintClassSerialize(const ClassType& type, const std::string& lhs, + const std::string& rhs); + + void PrintVariantSerialize(const VariantType& variant_type, + const std::string& lhs, const std::string& rhs, + absl::string_view lang_name); + + void PrintListSerialize(const ListType& list_type, const std::string& lhs, + const std::string& rhs, absl::string_view lang_name); + + void PrintSerialize(const Type& type, const std::string& lhs, + const std::string& rhs, absl::string_view lang_name); + + void PrintNullableToJson(const Type& type, MaybeNull maybe_null, + const std::string& lhs, const std::string& rhs, + absl::string_view lang_name); + + void PrintSerializeFieldsFunction(const NodeDef& node, + absl::string_view lang_name); + + void PrintSerializeFunction(const NodeDef& node, absl::string_view lang_name); + + void PrintSerializeFunctionOverload(const NodeDef& node, + absl::string_view lang_name); +}; + +// Prints the "ast_to_json.generated.cc" source file. +// +// - cc_namespace: The C++ namespace for all the AST node classes. +// Example: "maldoca::astgen". +// +// - ast_path: The directory for the AST code. +// "ast.generated.h" is in that directory. +// This is used to print the #include. +std::string PrintAstToJson(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_SERIALIZE_PRINTER_H_ diff --git a/maldoca/astgen/ast_source_printer.cc b/maldoca/astgen/ast_source_printer.cc new file mode 100644 index 0000000..6eedf5f --- /dev/null +++ b/maldoca/astgen/ast_source_printer.cc @@ -0,0 +1,412 @@ +// 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 "maldoca/astgen/ast_source_printer.h" + +#include +#include + +#include "absl/strings/escaping.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { + +void AstSourcePrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path) { + auto header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + PrintIncludeHeader(header_path); + Println(); + + Println("// IWYU pragma: begin_keep"); + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeader("absl/container/flat_hash_map.h"); + PrintIncludeHeader("absl/memory/memory.h"); + PrintIncludeHeader("absl/log/log.h"); + PrintIncludeHeader("absl/status/status.h"); + PrintIncludeHeader("absl/status/statusor.h"); + PrintIncludeHeader("absl/strings/str_cat.h"); + PrintIncludeHeader("absl/strings/string_view.h"); + PrintIncludeHeader("nlohmann/json.hpp"); + PrintIncludeHeader("maldoca/base/status_macros.h"); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + for (const EnumDef& enum_def : ast.enum_defs()) { + PrintEnum(enum_def, ast.lang_name()); + Println(); + } + + for (const NodeDef* node : ast.topological_sorted_nodes()) { + PrintNode(*node, ast.lang_name()); + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); +} + +void AstSourcePrinter::PrintEnum(const EnumDef& enum_def, + absl::string_view lang_name) { + auto vars = WithVars({ + {"EnumName", (Symbol(lang_name) + enum_def.name()).ToPascalCase()}, + {"enum_name", enum_def.name().ToSnakeCase()}, + }); + + Println("absl::string_view $EnumName$ToString($EnumName$ $enum_name$) {"); + { + auto indent = WithIndent(); + Println("switch ($enum_name$) {"); + { + auto indent = WithIndent(); + for (const EnumMemberDef& member : enum_def.members()) { + auto vars = WithVars({ + {"kMemberName", (Symbol("k") + member.name()).ToCamelCase()}, + {"string_value", absl::CEscape(member.string_value())}, + }); + + Println("case $EnumName$::$kMemberName$:"); + Println(" return \"$string_value$\";"); + } + } + Println("}"); + } + Println("}"); + Println(); + + Println( + "absl::StatusOr<$EnumName$> StringTo$EnumName$(absl::string_view s) {"); + { + auto indent = WithIndent(); + + Println( + "static const auto *kMap = " + "new absl::flat_hash_map {"); + { + auto indent = WithIndent(4); + for (const EnumMemberDef& member : enum_def.members()) { + auto vars = WithVars({ + {"kMemberName", (Symbol("k") + member.name()).ToCamelCase()}, + {"string_value", absl::CEscape(member.string_value())}, + }); + + Println("{\"$string_value$\", $EnumName$::$kMemberName$},"); + } + } + Println("};"); + Println(); + + const auto code = UnIndentedSource(R"( +auto it = kMap->find(s); +if (it == kMap->end()) { + return absl::InvalidArgumentError(absl::StrCat("Invalid string for $EnumName$: ", s)); +} +return it->second; + )"); + Println(code); + } + Println("}"); +} + +void AstSourcePrinter::PrintNode(const NodeDef& node, + absl::string_view lang_name) { + PrintTitle((Symbol(lang_name) + node.name()).ToPascalCase()); + Println(); + + auto vars = WithVars({ + {"NodeType", ClassType(Symbol(node.name()), lang_name).CcType()}, + }); + + if (node.node_type_enum().has_value()) { + PrintEnum(*node.node_type_enum().value(), lang_name); + Println(); + } + + if (!node.aggregated_fields().empty()) { + PrintConstructor(node, lang_name); + Println(); + } + + for (const FieldDef& field : node.fields()) { + const Type& type = field.type(); + bool is_optional = field.optionalness() != OPTIONALNESS_REQUIRED; + + std::string cc_getter_type = CcMutableGetterType(field); + std::string cc_const_getter_type = CcConstGetterType(field); + + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + {"cc_getter_type", cc_getter_type}, + {"cc_const_getter_type", cc_const_getter_type}, + {"cc_type", CcType(field)}, + {"field_name", field.name().ToCcVarName()}, + }); + + // If both the mutable getter and const getter would have the same return + // type, then we just skip the mutable getter and only keep the const + // getter. + if (cc_getter_type != cc_const_getter_type) { + Println("$cc_getter_type$ $NodeType$::$field_name$() {"); + { + auto indent = WithIndent(); + PrintGetterBody(field.name(), type, is_optional); + } + Println("}"); + Println(); + } + + Println("$cc_const_getter_type$ $NodeType$::$field_name$() const {"); + { + auto indent = WithIndent(); + PrintGetterBody(field.name(), type, is_optional); + } + Println("}"); + Println(); + + Println("void $NodeType$::set_$field_name$($cc_type$ $field_name$) {"); + { + auto indent = WithIndent(); + PrintSetterBody(field.name(), type, is_optional); + } + Println("}"); + Println(); + } +} + +void AstSourcePrinter::PrintConstructor(const NodeDef& node, + absl::string_view lang_name) { + auto vars = WithVars({ + {"NodeType", (Symbol(lang_name) + node.name()).ToPascalCase()}, + }); + Print("$NodeType$::$NodeType$("); + if (!node.aggregated_fields().empty()) { + Println(); + auto indent = WithIndent(4); + + TabPrinter separator_printer{{ + .print_separator = [this] { Print(",\n"); }, + }}; + for (const FieldDef* field : node.aggregated_fields()) { + auto vars = WithVars({ + {"cc_type", CcType(*field)}, + {"field_name", field->name().ToCcVarName()}, + }); + + separator_printer.Print(); + Print("$cc_type$ $field_name$"); + } + } + Println(")"); + + { + auto indent = WithIndent(4); + + TabPrinter tab_printer{{ + .print_prefix = + [&] { + Print(": "); + Indent(); + }, + .print_separator = [&] { Print(",\n"); }, + .print_postfix = [&] { Outdent(); }, + }}; + for (const NodeDef* ancestor : node.ancestors()) { + tab_printer.Print(); + + auto vars = WithVars({ + {"AncestorType", + (Symbol(lang_name) + ancestor->name()).ToPascalCase()}, + }); + Print("$AncestorType$("); + + TabPrinter ancestor_tab_printer{{ + .print_separator = [&] { Print(", "); }, + }}; + for (const FieldDef* field : ancestor->aggregated_fields()) { + ancestor_tab_printer.Print(); + + auto vars = WithVars({ + {"field_name", field->name().ToCcVarName()}, + }); + Print("std::move($field_name$)"); + } + + Print(")"); + } + + for (const FieldDef& field : node.fields()) { + auto vars = WithVars({ + {"field_name", field.name().ToCcVarName()}, + }); + + tab_printer.Print(); + Print("$field_name$_(std::move($field_name$))"); + } + } + + Println(" {}"); +} + +void AstSourcePrinter::PrintGetterBody(const std::string& cc_expr, + const Type& type) { + auto vars = WithVars({ + {"cc_expr", cc_expr}, + }); + + switch (type.kind()) { + case TypeKind::kBuiltin: { + Println("return $cc_expr$;"); + break; + } + + case TypeKind::kEnum: { + Println("return $cc_expr$;"); + break; + } + + case TypeKind::kClass: { + Println("return $cc_expr$.get();"); + break; + } + + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + + Println("switch ($cc_expr$.index()) {"); + { + auto indent = WithIndent(); + + for (size_t i = 0; i != variant_type.types().size(); ++i) { + auto vars = WithVars({ + {"i", std::to_string(i)}, + }); + const ScalarType& type = *variant_type.types().at(i); + + Println("case $i$: {"); + { + auto indent = WithIndent(); + PrintGetterBody(absl::StrFormat("std::get<%zu>(%s)", i, cc_expr), + type); + } + Println("}"); + } + + Println("default:"); + Println(" LOG(FATAL) << \"Unreachable code.\";"); + } + Println("}"); + + break; + } + + case TypeKind::kList: { + Println("return &$cc_expr$;"); + break; + } + } +} + +void AstSourcePrinter::PrintGetterBody(const Symbol& field_name, + const Type& type, bool is_optional) { + if (is_optional) { + auto vars = WithVars({ + {"field_name", field_name.ToCcVarName()}, + }); + + Println("if (!$field_name$_.has_value()) {"); + Println(" return std::nullopt;"); + Println("} else {"); + { + auto indent = WithIndent(); + auto value_cc_expr = absl::StrCat(field_name.ToCcVarName(), "_.value()"); + PrintGetterBody(value_cc_expr, type); + } + Println("}"); + + } else { + PrintGetterBody(absl::StrCat(field_name.ToCcVarName(), "_"), type); + } +} + +void AstSourcePrinter::PrintSetterBody(const Symbol& field_name, + const Type& type, bool is_optional) { + auto vars = WithVars({ + {"field_name", field_name.ToCcVarName()}, + }); + + if (type.IsA()) { + const auto& builtin_type = static_cast(type); + switch (builtin_type.builtin_kind()) { + case BuiltinTypeKind::kBool: + case BuiltinTypeKind::kDouble: + Println("$field_name$_ = $field_name$;"); + return; + default: + break; + } + } + + if (type.IsA()) { + Println("$field_name$_ = $field_name$;"); + return; + } + + Println("$field_name$_ = std::move($field_name$);"); +} + +std::string PrintAstSource(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + AstSourcePrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ast_source_printer.h b/maldoca/astgen/ast_source_printer.h new file mode 100644 index 0000000..0fdc730 --- /dev/null +++ b/maldoca/astgen/ast_source_printer.h @@ -0,0 +1,92 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_SOURCE_PRINTER_H_ +#define MALDOCA_ASTGEN_AST_SOURCE_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +// Printer of the C++ source for the AST. +class AstSourcePrinter : public CcPrinterBase { + public: + explicit AstSourcePrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + // Prints the "ast.generated.cc" file, which includes the definitions of + // getters and setters of all the AST node classes. + // + // - cc_namespace: A namespace separated by "::". + // This is used to print C++ namespaces. + // + // - ast_path: The directory for the AST code. + // "ast.generated.h" is in that directory. + // This is used to print the #include. + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); + + private: + void PrintConstructor(const NodeDef& node, absl::string_view lang_name); + + // Prints the string conversion functions. + // + // Example: + // + // absl::string_view UnaryOperatorToString(UnaryOperator unary_operator) { + // ... + // } + // + // absl::StatusOr StringToUnaryOperator(absl::string_view s) { + // ... + // } + void PrintEnum(const EnumDef& enum_def, absl::string_view lang_name); + + // Prints the getters and setters of one AST node class. + void PrintNode(const NodeDef& node, absl::string_view lang_name); + + // Prints the C++ code that returns a value that's compatible with the types + // `type.CcMutableGetterType()` and `type.CcConstGetterType()`. + // + // `cc_expr` is an lvalue expression of the type `type.CcType()`. + void PrintGetterBody(const std::string& cc_expr, const Type& type); + + // Prints the C++ code that returns a value that's compatible with the types + // `type.CcMutableGetterType(is_optional)` and + // `type.CcConstGetterType(is_optional)`. + // + // `cc_expr` is an lvalue expression of the type `type.CcType()`. + void PrintGetterBody(const Symbol& field_name, const Type& type, + bool is_optional); + + // Prints the C++ code that sets one field. + // + // `field_name` is an lvalue expression that has the type + // `type.CcType(is_optional)`. We need to set the field `field_name_`. + void PrintSetterBody(const Symbol& field_name, const Type& type, + bool is_optional); +}; + +std::string PrintAstSource(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path); +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_SOURCE_PRINTER_H_ diff --git a/maldoca/astgen/ast_to_ir_source_printer.cc b/maldoca/astgen/ast_to_ir_source_printer.cc new file mode 100644 index 0000000..26dc2d4 --- /dev/null +++ b/maldoca/astgen/ast_to_ir_source_printer.cc @@ -0,0 +1,788 @@ +// 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 "maldoca/astgen/ast_to_ir_source_printer.h" + +#include +#include +#include + +#include "absl/algorithm/container.h" +#include "absl/base/attributes.h" +#include "absl/log/check.h" +#include "absl/log/log.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/str_format.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { +namespace { + +MaybeNull OptionalnessToMaybeNull(Optionalness optionalness) { + switch (optionalness) { + case OPTIONALNESS_UNSPECIFIED: + case OPTIONALNESS_REQUIRED: + return MaybeNull::kNo; + case OPTIONALNESS_MAYBE_NULL: + case OPTIONALNESS_MAYBE_UNDEFINED: + return MaybeNull::kYes; + } +} + +static Symbol GetVisitor(const NodeDef& node, FieldKind kind) { + auto visitor = Symbol("Visit") + node.name(); + if (kind == FIELD_KIND_ATTR) { + visitor += "Attr"; + } + if (kind == FIELD_KIND_LVAL) { + visitor += "Ref"; + } + return visitor; +} + +// Gets the name of the *RegionEndOp. +// - For an lval or rval (expression): ExprRegionEndOp. +// - For a list of lvals or rvals (expressions): ExprsRegionEndOp. +Symbol GetRegionEndOp(const AstDef& ast, const FieldDef& field) { + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + + Symbol region_end_op; + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Unspecified FieldKind."; + case FIELD_KIND_ATTR: + LOG(FATAL) << "Unsupported FieldKind: " << field.kind(); + case FIELD_KIND_RVAL: + case FIELD_KIND_LVAL: { + if (field.type().IsA()) { + return ir_name + "ExprsRegionEndOp"; + } else { + return ir_name + "ExprRegionEndOp"; + } + } + case FIELD_KIND_STMT: { + return Symbol{}; + } + } +} + +} // namespace + +void AstToIrSourcePrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path) { + auto ast_header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + Println("// IWYU pragma: begin_keep"); + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println(); + + PrintIncludeHeader( + absl::StrCat(ir_path, "/conversion/ast_to_", ast.lang_name(), "ir.h")); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeaders({ + "llvm/ADT/APFloat.h", + "mlir/IR/Attributes.h", + "mlir/IR/Block.h", + "mlir/IR/Builders.h", + "mlir/IR/BuiltinAttributes.h", + "mlir/IR/BuiltinTypes.h", + "mlir/IR/Operation.h", + "mlir/IR/Region.h", + "mlir/IR/Value.h", + "absl/cleanup/cleanup.h", + "absl/log/check.h", + "absl/log/log.h", + "absl/types/optional.h", + "absl/types/variant.h", + std::string(ast_header_path), + absl::StrCat(ir_path, "/ir.h"), + }); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + for (const auto* node : ast.topological_sorted_nodes()) { + if (!node->children().empty()) { + for (FieldKind kind : node->aggregated_kinds()) { + PrintNonLeafNode(ast, *node, kind); + } + } + + if (!node->should_generate_ir_op()) { + continue; + } + + for (FieldKind kind : node->aggregated_kinds()) { + PrintLeafNode(ast, *node, kind); + } + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); +} + +void AstToIrSourcePrinter::PrintNonLeafNode(const AstDef& ast, + const NodeDef& node, + FieldKind kind) { + auto ir_op_name = node.ir_op_name(ast.lang_name(), kind); + std::string return_type; + if (ir_op_name.has_value()) { + return_type = ir_op_name.value().ToPascalCase(); + } else { + switch (kind) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Invalid FieldKind: FIELD_KIND_UNSPECIFIED."; + case FIELD_KIND_ATTR: { + return_type = "mlir::Attribute"; + break; + } + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: { + return_type = "mlir::Value"; + break; + } + case FIELD_KIND_STMT: { + return_type = "mlir::Operation*"; + break; + } + } + } + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + auto visitor = GetVisitor(node, kind); + + auto vars = WithVars({ + {"Ret", return_type}, + {"Name", (Symbol(ast.lang_name()) + node.name()).ToPascalCase()}, + {"IrName", ir_name.ToPascalCase()}, + {"Visitor", visitor.ToPascalCase()}, + }); + + Println( + "$Ret$ AstTo$IrName$::$Visitor$(mlir::OpBuilder &builder, const $Name$ " + "*node) {"); + { + auto indent = WithIndent(); + for (const NodeDef* leaf : node.leafs()) { + auto vars = WithVars({ + {"LeafName", (Symbol(ast.lang_name()) + leaf->name()).ToPascalCase()}, + {"leaf_name", Symbol(leaf->name()).ToCcVarName()}, + {"LeafVisitor", GetVisitor(*leaf, kind).ToPascalCase()}, + }); + Println( + "if (auto *$leaf_name$ = dynamic_cast(node)) {"); + Println(" return $LeafVisitor$(builder, $leaf_name$);"); + Println("}"); + } + + Println("LOG(FATAL) << \"Unreachable code.\";"); + } + Println("}"); + Println(); +} + +void AstToIrSourcePrinter::PrintLeafNode(const AstDef& ast, const NodeDef& node, + FieldKind kind) { + auto ir_op_name = node.ir_op_name(ast.lang_name(), kind).value(); + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + + auto visitor = Symbol("Visit") + node.name(); + if (kind == FIELD_KIND_LVAL) { + visitor += "Ref"; + } + + auto creator = Symbol("Create"); + switch (kind) { + case FIELD_KIND_UNSPECIFIED: + case FIELD_KIND_ATTR: + LOG(FATAL) << "Unsupported kind: " << kind; + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: + creator += "Expr"; + break; + case FIELD_KIND_STMT: + creator += "Stmt"; + break; + } + + auto vars = WithVars({ + {"OpName", ir_op_name.ToPascalCase()}, + {"Name", (Symbol(ast.lang_name()) + node.name()).ToPascalCase()}, + {"IrName", ir_name.ToPascalCase()}, + {"Visitor", visitor.ToPascalCase()}, + {"Creator", creator.ToPascalCase()}, + }); + + Println( + "$OpName$ AstTo$IrName$::$Visitor$(mlir::OpBuilder &builder, const " + "$Name$ *node) {"); + { + auto indent = WithIndent(); + + for (const auto* field : node.aggregated_fields()) { + if (FieldIsArgument(field)) { + PrintField(ast, node, *field); + } + } + + bool has_regions = absl::c_any_of( + node.aggregated_fields(), + [](const FieldDef* field) { return FieldIsRegion(field); }); + if (has_regions) { + Print("auto op = "); + } else { + Print("return "); + } + + Print("$Creator$<$OpName$>(builder, node"); + { + auto indent = WithIndent(4); + for (const auto* field : node.aggregated_fields()) { + if (!FieldIsArgument(field)) { + continue; + } + + const auto mlir_field_name = (Symbol("mlir") + field->name()); + auto vars = WithVars({ + {"mlir_field_name", mlir_field_name.ToCcVarName()}, + }); + + Print(", $mlir_field_name$"); + } + } + Println(");"); + + if (has_regions) { + for (const auto* field : node.aggregated_fields()) { + if (FieldIsRegion(field)) { + PrintRegion(ast, node, *field); + } + } + + Println("return op;"); + } + } + + Println("}"); + Println(); +} + +void AstToIrSourcePrinter::PrintField(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + MaybeNull maybe_null = OptionalnessToMaybeNull(field.optionalness()); + + auto lhs = Symbol("mlir") + field.name(); + auto rhs = absl::StrCat("node->", field.name().ToCcVarName(), "()"); + PrintNullableToIr(ast, Action::kDef, field.type(), maybe_null, RefOrVal::kRef, + field.kind(), lhs, rhs); +} + +void AstToIrSourcePrinter::PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + MaybeNull maybe_null = OptionalnessToMaybeNull(field.optionalness()); + + auto lhs = Symbol("mlir") + field.name(); + auto lhs_region = lhs + "region"; + auto rhs = absl::StrCat("node->", field.name().ToCcVarName(), "()"); + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + + auto vars = WithVars({ + {"lhs", lhs.ToCcVarName()}, + {"lhs_region", lhs_region.ToCcVarName()}, + {"mlirGetter", field.name().ToMlirGetter()}, + {"rhs", rhs}, + }); + + auto populate_region = [&] { + Println("mlir::Region &$lhs_region$ = op.$mlirGetter$();"); + Println("AppendNewBlockAndPopulate(builder, $lhs_region$, [&] {"); + { + auto indent = WithIndent(); + + Action action = [&] { + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Unspecified FieldKind."; + case FIELD_KIND_ATTR: + LOG(FATAL) << "Unsupported FieldKind: " << field.kind(); + case FIELD_KIND_RVAL: + case FIELD_KIND_LVAL: { + return Action::kDef; + } + case FIELD_KIND_STMT: { + return Action::kCreate; + } + } + }(); + + Symbol region_end_op = GetRegionEndOp(ast, field); + PrintToIr(ast, action, field.type(), RefOrVal::kRef, field.kind(), lhs, + rhs); + + auto vars = WithVars({ + {"RegionEndOp", region_end_op.ToPascalCase()}, + }); + + switch (action) { + case Action::kAssign: + LOG(FATAL) << "Unsupported Action: Assign."; + case Action::kCreate: + break; + case Action::kDef: { + Println("CreateStmt<$RegionEndOp$>(builder, nullptr, $lhs$);"); + break; + } + } + } + Println("});"); + }; + + switch (maybe_null) { + case MaybeNull::kYes: { + Println("if ($rhs$.has_value()) {"); + { + auto indent = WithIndent(); + absl::StrAppend(&rhs, ".value()"); + auto vars = WithVars({ + {"rhs", rhs}, + }); + populate_region(); + } + Println("}"); + break; + } + case MaybeNull::kNo: + populate_region(); + break; + } +} + +void AstToIrSourcePrinter::PrintBuiltinToIr(const AstDef& ast, Action action, + const BuiltinType& type, + const Symbol& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"mlir_type", type.CcMlirBuilderType(FIELD_KIND_ATTR)}, + {"lhs", lhs.ToCcVarName()}, + {"rhs", rhs}, + }); + + switch (action) { + case Action::kDef: + Print("$mlir_type$ "); + ABSL_FALLTHROUGH_INTENDED; + case Action::kAssign: + Print("$lhs$ = "); + break; + case Action::kCreate: + break; + } + + switch (type.builtin_kind()) { + case BuiltinTypeKind::kBool: { + Print("builder.getBoolAttr($rhs$)"); + break; + } + case BuiltinTypeKind::kInt64: { + Print("builder.getI64IntegerAttr($rhs$)"); + break; + } + case BuiltinTypeKind::kString: { + Print("builder.getStringAttr($rhs$)"); + break; + } + case BuiltinTypeKind::kDouble: { + Print("builder.getF64FloatAttr($rhs$)"); + break; + } + } + + Println(";"); +} + +void AstToIrSourcePrinter::PrintClassToIr(const AstDef& ast, Action action, + const ClassType& type, FieldKind kind, + const Symbol& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"ClassName", type.name().ToPascalCase()}, + {"lhs", lhs.ToCcVarName()}, + {"rhs", rhs}, + }); + + switch (action) { + case Action::kDef: { + auto vars = WithVars({ + {"cc_mlir_type", type.CcMlirBuilderType(kind)}, + }); + Print("$cc_mlir_type$ "); + ABSL_FALLTHROUGH_INTENDED; + } + case Action::kAssign: + Print("$lhs$ = "); + break; + case Action::kCreate: + break; + } + + switch (kind) { + case FIELD_KIND_UNSPECIFIED: + case FIELD_KIND_ATTR: + Println("Visit$ClassName$Attr(builder, $rhs$);"); + break; + case FIELD_KIND_RVAL: + case FIELD_KIND_STMT: { + Println("Visit$ClassName$(builder, $rhs$);"); + break; + } + case FIELD_KIND_LVAL: { + Println("Visit$ClassName$Ref(builder, $rhs$);"); + break; + } + } +} + +void AstToIrSourcePrinter::PrintClassToIr(const AstDef& ast, Action action, + const ClassType& type, + RefOrVal ref_or_val, FieldKind kind, + const Symbol& lhs, + const std::string& rhs) { + switch (ref_or_val) { + case RefOrVal::kRef: + return PrintClassToIr(ast, action, type, kind, lhs, rhs); + case RefOrVal::kVal: + return PrintClassToIr(ast, action, type, kind, lhs, + absl::StrCat(rhs, ".get()")); + } +} + +void AstToIrSourcePrinter::PrintEnumToIr(const AstDef& ast, Action action, + const EnumType& type, + const Symbol& lhs, + const std::string& rhs) { + auto enum_name = (Symbol(ast.lang_name()) + type.name()).ToPascalCase(); + auto rhs_str = absl::StrCat(enum_name, "ToString(", rhs, ")"); + + BuiltinType string_type{BuiltinTypeKind::kString, ast.lang_name()}; + return PrintBuiltinToIr(ast, action, string_type, lhs, rhs_str); +} + +void AstToIrSourcePrinter::PrintVariantToIr(const AstDef& ast, Action action, + const VariantType& type, + RefOrVal ref_or_val, FieldKind kind, + const Symbol& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"lhs", lhs.ToCcVarName()}, + {"rhs", rhs}, + }); + + Action case_action; + switch (action) { + case Action::kDef: { + auto vars = WithVars({ + {"cc_mlir_type", type.CcMlirBuilderType(kind)}, + }); + Println("$cc_mlir_type$ $lhs$;"); + case_action = Action::kAssign; + break; + } + case Action::kAssign: + case_action = Action::kAssign; + break; + case Action::kCreate: + case_action = Action::kCreate; + break; + } + + Println("switch ($rhs$.index()) {"); + { + auto indent = WithIndent(); + + for (size_t i = 0; i != type.types().size(); ++i) { + auto vars = WithVars({ + {"i", std::to_string(i)}, + }); + + Println("case $i$: {"); + { + auto indent = WithIndent(); + const ScalarType& scalar_type = *type.types()[i]; + PrintToIr(ast, case_action, scalar_type, ref_or_val, kind, lhs, + absl::StrFormat("std::get<%zu>(%s)", i, rhs)); + Println("break;"); + } + + Println("}"); + } + + Println("default:"); + Println(" LOG(FATAL) << \"Unreachable code.\";"); + } + Println("}"); +} + +void AstToIrSourcePrinter::PrintListToIr(const AstDef& ast, Action action, + const ListType& type, FieldKind kind, + const Symbol& lhs, + const std::string& rhs) { + const auto lhs_element = Symbol("mlir_element"); + const auto rhs_element = "element"; + + auto vars = WithVars({ + {"lhs", lhs.ToCcVarName()}, + {"lhs_data", (lhs + "data").ToCcVarName()}, + {"rhs", rhs}, + {"lhs_element", lhs_element.ToCcVarName()}, + {"rhs_element", rhs_element}, + }); + + switch (kind) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "FieldKind unspecified."; + case FIELD_KIND_STMT: { + // Case: List of Statements. + CHECK(action == Action::kCreate) + << "We never collect statement ops in a vector."; + + Println("for (const auto &$rhs_element$ : *$rhs$) {"); + { + auto indent = WithIndent(); + PrintNullableToIr(ast, Action::kCreate, type.element_type(), + type.element_maybe_null(), RefOrVal::kVal, kind, + lhs_element, rhs_element); + } + Println("}"); + break; + } + case FIELD_KIND_ATTR: { + // Case: List of Attributes. + // + // We first create and fill a std::vector and then + // convert it into a mlir::ArrayAttr (what the builder takes). + + Println("std::vector $lhs_data$;"); + Println("for (const auto &$rhs_element$ : *$rhs$) {"); + { + auto indent = WithIndent(); + PrintNullableToIr(ast, Action::kDef, type.element_type(), + type.element_maybe_null(), RefOrVal::kVal, kind, + lhs_element, rhs_element); + Println("$lhs_data$.push_back(std::move($lhs_element$));"); + } + Println("}"); + + switch (action) { + case Action::kDef: { + Println("auto $lhs$ = builder.getArrayAttr($lhs_data$);"); + break; + } + case Action::kAssign: { + Println("$lhs$ = builder.getArrayAttr($lhs_data$);"); + break; + } + case Action::kCreate: + LOG(FATAL) << "We never put attributes in a region."; + } + break; + } + + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: { + // Case: List of Values. + // + // We create and fill a std::vector which can be implicitly + // converted to a mlir::ValueRange (what the builder takes). + + switch (action) { + case Action::kDef: + Println("std::vector $lhs$;"); + break; + case Action::kAssign: + // Do nothing. + break; + case Action::kCreate: + LOG(FATAL) << "We must put expressions in a vector."; + } + + Println("for (const auto &$rhs_element$ : *$rhs$) {"); + { + auto indent = WithIndent(); + switch (type.element_maybe_null()) { + case MaybeNull::kNo: { + PrintToIr(ast, Action::kDef, type.element_type(), RefOrVal::kVal, + kind, lhs_element, rhs_element); + break; + } + + case MaybeNull::kYes: { + // Unfortunately, in the std::vector we can't have any + // nullptr. In order to represent optional, we need the special + // irNoneOp. + + Println("mlir::Value $lhs_element$;"); + Println("if ($rhs_element$.has_value()) {"); + { + auto indent = WithIndent(); + PrintToIr(ast, Action::kAssign, type.element_type(), + RefOrVal::kVal, kind, lhs_element, + absl::StrCat(rhs_element, ".value()")); + } + Println("} else {"); + { + auto indent = WithIndent(); + auto none_op = + Symbol(absl::StrCat(ast.lang_name(), "ir")) + "NoneOp"; + auto vars = WithVars({ + {"NoneOp", none_op.ToPascalCase()}, + }); + + Println("$lhs_element$ = CreateExpr<$NoneOp$>(builder, node);"); + } + Println("}"); + + break; + } + } + + Println("$lhs$.push_back(std::move($lhs_element$));"); + } + + Println("}"); + } + } +} + +void AstToIrSourcePrinter::PrintToIr(const AstDef& ast, Action action, + const Type& type, RefOrVal ref_or_val, + FieldKind kind, const Symbol& lhs, + const std::string& rhs) { + switch (type.kind()) { + case TypeKind::kBuiltin: { + const auto& builtin_type = static_cast(type); + return PrintBuiltinToIr(ast, action, builtin_type, lhs, rhs); + } + + case TypeKind::kClass: { + const auto& class_type = static_cast(type); + return PrintClassToIr(ast, action, class_type, ref_or_val, kind, lhs, + rhs); + } + + case TypeKind::kEnum: { + const auto& enum_type = static_cast(type); + return PrintEnumToIr(ast, action, enum_type, lhs, rhs); + } + + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + return PrintVariantToIr(ast, action, variant_type, ref_or_val, kind, lhs, + rhs); + } + + case TypeKind::kList: { + const auto& list_type = static_cast(type); + CHECK(ref_or_val == RefOrVal::kRef); + return PrintListToIr(ast, action, list_type, kind, lhs, rhs); + } + } +} + +void AstToIrSourcePrinter::PrintNullableToIr(const AstDef& ast, Action action, + const Type& type, + MaybeNull maybe_null, + RefOrVal ref_or_val, + FieldKind kind, const Symbol& lhs, + const std::string& rhs) { + auto vars = WithVars({ + {"lhs", lhs.ToCcVarName()}, + {"rhs", rhs}, + }); + + switch (maybe_null) { + case MaybeNull::kYes: { + Action non_null_action; + switch (action) { + case Action::kAssign: + non_null_action = Action::kAssign; + break; + case Action::kCreate: + non_null_action = Action::kCreate; + break; + case Action::kDef: { + auto vars = WithVars({ + {"mlir_type", type.CcMlirBuilderType(kind)}, + }); + Println("$mlir_type$ $lhs$;"); + non_null_action = Action::kAssign; + break; + } + } + Println("if ($rhs$.has_value()) {"); + { + auto indent = WithIndent(); + auto new_rhs = absl::StrCat(rhs, ".value()"); + PrintToIr(ast, non_null_action, type, ref_or_val, kind, lhs, new_rhs); + } + Println("}"); + break; + } + + case MaybeNull::kNo: { + PrintToIr(ast, action, type, ref_or_val, kind, lhs, rhs); + break; + } + } +} + +std::string PrintAstToIrSource(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + AstToIrSourcePrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path, ir_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ast_to_ir_source_printer.h b/maldoca/astgen/ast_to_ir_source_printer.h new file mode 100644 index 0000000..36d4774 --- /dev/null +++ b/maldoca/astgen/ast_to_ir_source_printer.h @@ -0,0 +1,201 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_AST_TO_IR_SOURCE_PRINTER_H_ +#define MALDOCA_ASTGEN_AST_TO_IR_SOURCE_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +class AstToIrSourcePrinter : public CcPrinterBase { + public: + explicit AstToIrSourcePrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + // Action: What to do with the converted IR value/attribute. + // + // - Def: Define a variable. + // - Assign: Assign the value/attribute to an existing variable. + // - Create: Just create the value/attribute and ignore it. + // + // See comments for Print*ToIr for more details. + enum class Action { + kDef, + kAssign, + kCreate, + }; + + // Whether a C++ expression refers to a "reference" or a "value". + // + // Consider the following AST node: + // class CallExpression : ... { + // public: + // const Expression *func() const; + // const std::vector> *args() const; + // }; + // + // - The type of func() is "const Expression *". + // We consider this a "reference". + // + // - The type of args()[0] is "std::unique_ptr &". + // We consider this a "value". + // + // However, in the ASTGen type system, we refer them both as + // ClassType{"Expression"}. Therefore, we need this additional enum to make + // the distinction. + // + // If a function takes a "reference" but we have a "value", we need to call + // ".get()" to turn it into a "reference". + enum RefOrVal { + kRef, + kVal, + }; + + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path, absl::string_view ir_path); + + // Prints the Visit() function. + void PrintNonLeafNode(const AstDef& ast, const NodeDef& node, FieldKind kind); + + void PrintLeafNode(const AstDef& ast, const NodeDef& node, FieldKind kind); + + // =========================================================================== + // Print*ToIr + // =========================================================================== + // + // Prints the conversion of a C++ expression that represents a field from the + // AST to the corresponding MLIR value/attribute. The result is later used to + // build MLIR ops. + // - rhs: The original C++ expression that represents a field from the AST. + // + // - lhs: The name of the variable to assign to or create, after the + // conversion. + // + // - action: + // - kDef: + // mlir::Value = Convert(); + // - kAssign: + // = Convert(); + // - kCreate: + // Convert(); + // + // - type: The type of the AST field. + // + // - ref_or_val: See comments for RefOrVal. + // + // - kind: Kind of the field. See comments for FieldKind. + // If kind == FIELD_KIND_LVAL, then we need to append "Ref" to the op name. + void PrintBuiltinToIr(const AstDef& ast, Action action, + const BuiltinType& type, const Symbol& lhs, + const std::string& rhs); + + void PrintClassToIr(const AstDef& ast, Action action, const ClassType& type, + FieldKind kind, const Symbol& lhs, + const std::string& rhs); + + void PrintClassToIr(const AstDef& ast, Action action, const ClassType& type, + RefOrVal ref_or_val, FieldKind kind, const Symbol& lhs, + const std::string& rhs); + + void PrintEnumToIr(const AstDef& ast, Action action, const EnumType& type, + const Symbol& lhs, const std::string& rhs); + + void PrintVariantToIr(const AstDef& ast, Action action, + const VariantType& type, RefOrVal ref_or_val, + FieldKind kind, const Symbol& lhs, + const std::string& rhs); + + void PrintListToIr(const AstDef& ast, Action action, const ListType& type, + FieldKind kind, const Symbol& lhs, const std::string& rhs); + + void PrintToIr(const AstDef& ast, Action action, const Type& type, + RefOrVal ref_or_val, FieldKind kind, const Symbol& lhs, + const std::string& rhs); + + void PrintNullableToIr(const AstDef& ast, Action action, const Type& type, + MaybeNull maybe_null, RefOrVal ref_or_val, + FieldKind kind, const Symbol& lhs, + const std::string& rhs); + + // Prints the code that converts an AST field to an MLIR value/attribute and + // stores the result in a new variable. + // + // Format: + // + // mlir_ = Visit(node->()); + // + // Example: + // + // mlir::Value mlir_object = VisitExpression(node->object()); + void PrintField(const AstDef& ast, const NodeDef& node, + const FieldDef& field); + + // Prints the code that converts an AST field to a region. The region has been + // created and the code just populates blocks and ops in it. + // + // Format: + // + // mlir::Region &mlir__region = op.(); + // AppendNewBlockAndPopulate(mlir__region, [&] { + // foo() into elements in the region.> + // }); + // + // Example: + // + // mlir::Region &mlir_body_region = op.body(); + // AppendNewBlockAndPopulate(mlir_body_region, [&] { + // for (const auto &element : *node->body()) { + // VisitStatement(element.get()); + // } + // }); + void PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field); +}; + +// Prints the "ast_toir.generated.cc" file. +// +// - cc_namespace: The namespace where all IR op classes live. +// +// - ast_path: The directory for the AST code. +// +// "ast.generated.h" is in that directory. +// +// This is used to print the #inclueds. +// +// - ir_path: The directory for the IR code. +// +// The following files are in that directory: +// - "ir_dialect.td" +// - "ir_ops.generated.td" +// - "interfaces.td" +// - "conversion/ast_to_ir.h" +// - "conversion/ast_to_ir.generated.cc" +// +// This is used to print the #includes and header guards. +std::string PrintAstToIrSource(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_AST_TO_IR_SOURCE_PRINTER_H_ diff --git a/maldoca/astgen/cc_printer_base.cc b/maldoca/astgen/cc_printer_base.cc new file mode 100644 index 0000000..376b36a --- /dev/null +++ b/maldoca/astgen/cc_printer_base.cc @@ -0,0 +1,136 @@ +// 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 "maldoca/astgen/cc_printer_base.h" + +#include +#include + +#include "absl/strings/ascii.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/str_join.h" +#include "absl/strings/str_replace.h" +#include "absl/strings/str_split.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_gen_utils.h" + +namespace maldoca { + +void CcPrinterBase::PrintLicense() { + static const auto* kCcLicenceString = new std::string{UnIndentedSource(R"cc( + // 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. + )cc")}; + + Println(kCcLicenceString->c_str()); +} + +void CcPrinterBase::PrintEnterNamespace(absl::string_view cc_namespace) { + for (absl::string_view cc_namespace_piece : + absl::StrSplit(cc_namespace, "::")) { + auto vars = WithVars({ + {"cc_namespace_piece", std::string(cc_namespace_piece)}, + }); + Println("namespace $cc_namespace_piece$ {"); + } +} + +void CcPrinterBase::PrintExitNamespace(absl::string_view cc_namespace) { + std::vector pieces = absl::StrSplit(cc_namespace, "::"); + for (auto it = pieces.rbegin(); it != pieces.rend(); ++it) { + auto vars = WithVars({ + {"cc_namespace_piece", std::string(*it)}, + }); + Println("} // namespace $cc_namespace_piece$"); + } +} + +static std::string ToHeaderGuard(absl::string_view header_path) { + std::string header_guard = absl::AsciiStrToUpper(header_path); + absl::StrReplaceAll({{"/", "_"}, {".", "_"}}, &header_guard); + absl::StrAppend(&header_guard, "_"); + return header_guard; +} + +void CcPrinterBase::PrintEnterHeaderGuard(absl::string_view header_path) { + auto vars = WithVars({ + {"HEADER_GUARD", ToHeaderGuard(header_path)}, + }); + + Println("#ifndef $HEADER_GUARD$"); + Println("#define $HEADER_GUARD$"); +} + +void CcPrinterBase::PrintExitHeaderGuard(absl::string_view header_path) { + auto vars = WithVars({ + {"HEADER_GUARD", ToHeaderGuard(header_path)}, + }); + + Println("#endif // $HEADER_GUARD$"); +} + +void CcPrinterBase::PrintIncludeHeader(absl::string_view header_path) { + auto vars = WithVars({ + {"header_path", std::string(header_path)}, + }); + + Println("#include \"$header_path$\""); +} + +void CcPrinterBase::PrintIncludeHeaders(std::vector header_paths) { + for (absl::string_view header_path : header_paths) { + PrintIncludeHeader(header_path); + } +} + +void CcPrinterBase::PrintTitle(absl::string_view title) { + std::vector commented_lines; + for (absl::string_view line : absl::StrSplit(title, '\n')) { + if (line.empty()) { + commented_lines.push_back("//"); + } else { + commented_lines.push_back(absl::StrCat("// ", line)); + } + } + std::string commented_title = absl::StrJoin(commented_lines, "\n"); + + auto vars = WithVars({ + {"CommentedTitle", commented_title}, + }); + + static const auto* kCode = new std::string(absl::StripAsciiWhitespace(R"( +// ============================================================================= +$CommentedTitle$ +// ============================================================================= + )")); + + Println(kCode->c_str()); +} + +void CcPrinterBase::PrintCodeGenerationWarning() { + PrintTitle("STOP!! DO NOT MODIFY!! THIS FILE IS AUTOMATICALLY GENERATED."); +} + +} // namespace maldoca diff --git a/maldoca/astgen/cc_printer_base.h b/maldoca/astgen/cc_printer_base.h new file mode 100644 index 0000000..3dfae34 --- /dev/null +++ b/maldoca/astgen/cc_printer_base.h @@ -0,0 +1,133 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_CC_PRINTER_BASE_H_ +#define MALDOCA_ASTGEN_CC_PRINTER_BASE_H_ + +#include +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/printer_base.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +// Common functions for printing C++ code. +class CcPrinterBase : public AstGenPrinterBase { + public: + explicit CcPrinterBase(google::protobuf::io::ZeroCopyOutputStream* os) + : AstGenPrinterBase(os) {} + + // Print Apache license comment. + void PrintLicense(); + + // Example: + // + // Input: + // cc_namespace == "maldoca::astgen" + // + // Output: + // ``` + // namespace maldoca { + // namespace astgen { + // ``` + void PrintEnterNamespace(absl::string_view cc_namespace); + + // Example: + // + // Input: + // cc_namespace == "maldoca::astgen" + // + // Output: + // ``` + // } // namespace astgen + // } // namespace maldoca + // ``` + void PrintExitNamespace(absl::string_view cc_namespace); + + // Example: + // + // Input: + // header_path == "maldoca/astgen/test/lambda/ast.h" + // + // Output: + // ``` + // #ifndef MALDOCA_ASTGEN_TEST_LAMBDA_AST_H_ + // #define MALDOCA_ASTGEN_TEST_LAMBDA_AST_H_ + // ``` + void PrintEnterHeaderGuard(absl::string_view header_path); + + // Example: + // + // Input: + // header_path == "maldoca/astgen/test/lambda/ast.h" + // + // Output: + // ``` + // #endif // MALDOCA_ASTGEN_TEST_LAMBDA_AST_H_ + // ``` + void PrintExitHeaderGuard(absl::string_view header_path); + + // Example: + // + // Input: + // header_path == "maldoca/astgen/test/lambda/ast.h" + // + // Output: + // ``` + // #include "maldoca/astgen/test/lambda/ast.h" + // ``` + void PrintIncludeHeader(absl::string_view header_path); + + // Prints headers in alphabetical order by sorting a copy of the header paths. + void PrintIncludeHeaders(std::vector header_paths); + + // Example: + // + // Input: + // title == "BinaryExpression" + // + // Output: + // ``` + // // ======================================================================== + // // BinaryExpression + // // ======================================================================== + // ``` + void PrintTitle(absl::string_view title); + + // Output: + // // ======================================================================== + // // STOP!! DO NOT MODIFY!! THIS FILE IS AUTOMATICALLY GENERATED. + // // ======================================================================== + void PrintCodeGenerationWarning(); + + // Some convenient wrappers for printing C++ types. + std::string CcType(const FieldDef& field) const { + return field.type().CcType(field.optionalness()); + } + + std::string CcMutableGetterType(const FieldDef& field) const { + return field.type().CcMutableGetterType(field.optionalness()); + } + + std::string CcConstGetterType(const FieldDef& field) const { + return field.type().CcConstGetterType(field.optionalness()); + } +}; + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_CC_PRINTER_BASE_H_ diff --git a/maldoca/astgen/ir_table_gen_printer.cc b/maldoca/astgen/ir_table_gen_printer.cc new file mode 100644 index 0000000..031ecdd --- /dev/null +++ b/maldoca/astgen/ir_table_gen_printer.cc @@ -0,0 +1,449 @@ +// 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 "maldoca/astgen/ir_table_gen_printer.h" + +#include +#include +#include + +#include "absl/algorithm/container.h" +#include "absl/log/log.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { + +void IrTableGenPrinter::PrintAst(const AstDef& ast, absl::string_view ir_path) { + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + // E.g. lang_name == "js", then ir_name == "jsir". + const auto ir_name = absl::StrCat(ast.lang_name(), "ir"); + + // E.g. "/jsir_ops.generated.td". + const auto td_path = absl::StrCat(ir_path, "/", ir_name, "_ops.generated.td"); + + PrintEnterHeaderGuard(td_path); + Println(); + + std::vector imports = { + "mlir/Interfaces/ControlFlowInterfaces.td", + "mlir/Interfaces/InferTypeOpInterface.td", + "mlir/Interfaces/LoopLikeInterface.td", + "mlir/Interfaces/SideEffectInterfaces.td", + "mlir/IR/OpBase.td", + "mlir/IR/SymbolInterfaces.td", + absl::StrCat(ir_path, "/interfaces.td"), + absl::StrCat(ir_path, "/", ast.lang_name(), "ir_dialect.td"), + absl::StrCat(ir_path, "/", ast.lang_name(), "ir_types.td"), + }; + for (const auto& import : imports) { + Println(absl::StrCat("include \"", import, "\"")); + } + Println(); + + bool has_expr_region = false; + bool has_exprs_region = false; + for (const auto* node : ast.topological_sorted_nodes()) { + for (const auto* field : node->aggregated_fields()) { + if (!field->enclose_in_region()) { + continue; + } + if (field->kind() != FIELD_KIND_LVAL && + field->kind() != FIELD_KIND_RVAL) { + continue; + } + if (field->type().IsA()) { + has_exprs_region = true; + } else { + has_expr_region = true; + } + } + } + + const auto region_end_comment = UnIndentedSource(R"( +// $ir$.*_region_end: An artificial op at the end of a region to collect +// expression-related values. +// +// Take $ir$.exprs_region_end as example: +// ====================================== +// +// Consider the following function declaration: +// ``` +// function foo(arg1, arg2 = defaultValue) { +// ... +// } +// ``` +// +// We lower it to the following IR (simplified): +// ``` +// %0 = $ir$.identifier_ref {"foo"} +// $ir$.function_declaration(%0) ( +// // params +// { +// %1 = $ir$.identifier_ref {"a"} +// %2 = $ir$.identifier_ref {"b"} +// %3 = $ir$.identifier {"defaultValue"} +// %4 = $ir$.assignment_pattern_ref(%2, %3) +// $ir$.exprs_region_end(%1, %4) +// }, +// // body +// { +// ... +// } +// ) +// ``` +// +// We can see that: +// +// 1. We put the parameter-related ops in a region, instead of taking them as +// normal arguments. In other words, we don't do this: +// +// ``` +// %0 = $ir$.identifier_ref {"foo"} +// %1 = $ir$.identifier_ref {"a"} +// %2 = $ir$.identifier_ref {"b"} +// %3 = $ir$.identifier {"defaultValue"} +// %4 = $ir$.assignment_pattern_ref(%2, %3) +// $ir$.function_declaration(%0, [%1, %4]) ( +// // body +// { +// ... +// } +// ) +// ``` +// +// The reason is that sometimes an argument might have a default value, and +// the evaluation of that default value happens once for each function call +// (i.e. it happens "within" the function). If we take the parameter as +// normal argument, then %3 is only evaluated once - at function definition +// time. +// +// 2. Even though the function has two parameters, we use 4 ops to represent +// them. This is because some parameters are more complex and require more +// than one op. +// +// 3. We use "$ir$.exprs_region_end" to list the "top-level" ops for the +// parameters. In the example above, ops [%2, %3, %4] all represent the +// parameter "b = defaultValue", but %4 is the top-level one. In other words, +// %4 is the root of the tree [%2, %3, %4]. +// +// 4. Strictly speaking, we don't really need "$ir$.exprs_region_end". The ops +// within the "params" region form several trees, and we can figure out what +// the roots are (a root is an op whose return value is not used by any other +// op). So the use of "$ir$.exprs_region_end" is mostly for convenience. + )"); + + if (has_expr_region || has_exprs_region) { + Symbol ir{absl::StrCat(ast.lang_name(), "ir")}; + + auto vars = WithVars({ + {"ir", ir.ToSnakeCase()}, + {"Ir", ir.ToPascalCase()}, + }); + Println(region_end_comment); + + if (has_expr_region) { + const auto expr_region_end = UnIndentedSource(R"( + def $Ir$ExprRegionEndOp : $Ir$_Op<"expr_region_end", [Terminator]> { + let arguments = (ins + AnyType: $$argument + ); + } + )"); + Println(expr_region_end); + Println(); + } + + if (has_exprs_region) { + const auto exprs_region_end = UnIndentedSource(R"( + def $Ir$ExprsRegionEndOp : $Ir$_Op<"exprs_region_end", [Terminator]> { + let arguments = (ins + Variadic: $$arguments + ); + } + )"); + Println(exprs_region_end); + Println(); + } + } + + for (const auto* node : ast.topological_sorted_nodes()) { + if (!node->should_generate_ir_op()) { + continue; + } + + for (auto kind : node->aggregated_kinds()) { + PrintNode(ast, *node, kind); + } + } + + PrintExitHeaderGuard(td_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()}, + {"op_mnemonic", node.ir_op_mnemonic(kind).value().ToCcVarName()}, + {"Name", node.name()}, + {"name", Symbol(node.name()).ToCcVarName()}, + {"IrName", Symbol(ir_name).ToPascalCase()}, + {"HirName", Symbol(hir_name).ToPascalCase()}, + }); + + std::vector traits; + for (const NodeDef* parent : node.parents()) { + if (!absl::c_linear_search(parent->aggregated_kinds(), kind)) { + continue; + } + auto parent_ir_op_name = parent->ir_op_name(ast.lang_name(), kind); + if (!parent_ir_op_name.has_value()) { + continue; + } + traits.push_back(*parent_ir_op_name + "Traits"); + } + + // When there is more than one variadic operand, we must append the + // AttrSizedOperandSegments trait. This is because MLIR internally stores + // operands as a single array and without additional information, it cannot + // attributes ranges of that array into the corresponding variadic operands. + // + // MLIR doesn't allow universally adding AttrSizedOperandSegments - only ops + // with more than one variadic operand are allowed. + // + // See: https://mlir.llvm.org/docs/OpDefinitions/#variadic-operands + size_t num_variadic_operands = 0; + for (const FieldDef& field : node.fields()) { + if (field.enclose_in_region()) { + continue; + } + + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: { + LOG(QFATAL) << node.name() << "::" << field.name().ToCcVarName() + << ": FieldKind unspecified."; + } + case FIELD_KIND_ATTR: + case FIELD_KIND_STMT: { + break; + } + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: { + if (field.type().IsA() || + field.optionalness() == OPTIONALNESS_MAYBE_NULL || + field.optionalness() == OPTIONALNESS_MAYBE_UNDEFINED) { + num_variadic_operands++; + } + } + } + } + if (num_variadic_operands > 1) { + traits.push_back(Symbol("AttrSizedOperandSegments")); + } + + if (absl::c_any_of(node.aggregated_fields(), FieldIsRegion)) { + traits.push_back(Symbol("NoTerminator")); + } + + for (auto mlir_trait : node.aggregated_additional_mlir_traits()) { + switch (mlir_trait) { + case MLIR_TRAIT_INVALID: + LOG(FATAL) << "Invalid MlirTrait."; + case MLIR_TRAIT_PURE: + traits.push_back(Symbol("Pure")); + break; + case MLIR_TRAIT_ISOLATED_FROM_ABOVE: + traits.push_back(Symbol("IsolatedFromAbove")); + break; + } + } + + if (traits.empty()) { + Println("def $OpName$ : $IrName$_Op<\"$op_mnemonic$\", []> {"); + } else { + // Example: + // ``` + // def JsirBinaryExpressionOp : Jsir_Op< + // "binary_expression", [ + // DeclareOpInterfaceMethods, + // DeclareOpInterfaceMethods + // ]> { + // ``` + Print( + "def $OpName$ : $HirName$_Op<\n" + " \"$op_mnemonic$\", [\n"); + + { + auto indent = WithIndent(8); + TabPrinter tab_printer{{ + .print_separator = [&] { Print(",\n"); }, + }}; + + for (const Symbol& trait : traits) { + auto vars = WithVars({ + {"Trait", trait.ToPascalCase()}, + }); + + tab_printer.Print(); + Print("$Trait$"); + } + } + + Println("\n ]> {"); + } + { + auto indent = WithIndent(); + TabPrinter line_separator_printer{{ + .print_separator = [&] { Print("\n"); }, + }}; + if (node.has_fold()) { + line_separator_printer.Print(); + Println("let hasFolder = 1;"); + } + + if (absl::c_any_of(node.aggregated_fields(), FieldIsArgument)) { + line_separator_printer.Print(); + + Println("let arguments = (ins"); + { + auto indent = WithIndent(); + TabPrinter separator_printer{{ + .print_separator = [&] { Print(",\n"); }, + }}; + for (const auto* field : node.aggregated_fields()) { + if (!FieldIsArgument(field)) { + continue; + } + + separator_printer.Print(); + PrintArgument(ast, node, *field); + } + } + Println(); + Println(");"); + } + + if (absl::c_any_of(node.aggregated_fields(), FieldIsRegion)) { + line_separator_printer.Print(); + + Println("let regions = (region"); + { + auto indent = WithIndent(); + TabPrinter separator_printer{{ + .print_separator = [&] { Print(",\n"); }, + }}; + for (const auto* field : node.aggregated_fields()) { + if (!FieldIsRegion(field)) { + continue; + } + + separator_printer.Print(); + PrintRegion(ast, node, *field); + } + } + Println(); + Println(");"); + } + + // Only expressions have results. + if (kind == FIELD_KIND_LVAL || kind == FIELD_KIND_RVAL) { + line_separator_printer.Print(); + + Println("let results = (outs"); + Println(" $IrName$AnyType"); + Println(");"); + } + } + + Println("}"); + Println(); +} + +void IrTableGenPrinter::PrintArgument(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + auto vars = WithVars({ + {"type", field.type().TdType(field.optionalness(), field.kind())}, + {"name", field.name().ToCcVarName()}, + }); + Print("$type$: $$$name$"); +} + +void IrTableGenPrinter::PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + std::string region_type = [&] { + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "FieldKind is unspecified."; + case FIELD_KIND_ATTR: + LOG(FATAL) << "Region of attributes not supported."; + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: + if (field.type().IsA()) { + return "ExprsRegion"; + } else { + return "ExprRegion"; + } + case FIELD_KIND_STMT: + if (field.type().IsA()) { + return "StmtsRegion"; + } else { + return "StmtRegion"; + } + } + }(); + + switch (field.optionalness()) { + case OPTIONALNESS_UNSPECIFIED: + LOG(FATAL) << "Optionalness unspecified."; + case OPTIONALNESS_REQUIRED: + break; + case OPTIONALNESS_MAYBE_NULL: + case OPTIONALNESS_MAYBE_UNDEFINED: + region_type = absl::StrCat("OptionalRegion<", region_type, ">"); + } + + auto vars = WithVars({ + {"name", field.name().ToCcVarName()}, + {"RegionType", region_type}, + }); + + Print("$RegionType$: $$$name$"); +} + +std::string PrintIrTableGen(const AstDef& ast, absl::string_view ir_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + IrTableGenPrinter printer(&os); + printer.PrintAst(ast, ir_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ir_table_gen_printer.h b/maldoca/astgen/ir_table_gen_printer.h new file mode 100644 index 0000000..f9e03c7 --- /dev/null +++ b/maldoca/astgen/ir_table_gen_printer.h @@ -0,0 +1,92 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_IR_TABLE_GEN_PRINTER_H_ +#define MALDOCA_ASTGEN_IR_TABLE_GEN_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +class IrTableGenPrinter : public CcPrinterBase { + public: + explicit IrTableGenPrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + void PrintAst(const AstDef& ast, absl::string_view ir_path); + + // Example: + // + // def JsirWithStatementOp : Jsir_Op< + // "with_statement", [ + // JsirStatementOpInterfaceTraits + // ]> { + // let arguments = (ins + // AnyType: $object + // ); + // + // let regions = (region + // AnyRegion: $body + // ); + // } + void PrintNode(const AstDef& ast, const NodeDef& node, FieldKind kind); + + // Prints an argument for an op in MLIR ODS. + // + // Format: + // + // : $ + // + // See Typd::TdType() for what the MLIR ODS type is for each Type. + // + // Example: + // + // AnyType: $object + void PrintArgument(const AstDef& ast, const NodeDef& node, + const FieldDef& field); + + // Prints a region in an op in MLIR ODS. + // + // Format: + // + // AnyRegion: $ + // + // Example: + // + // AnyRegion: $body + void PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field); +}; + +// Prints the "ir_ops.generated.td" TableGen file. +// +// - ir_path: The directory for the IR code. +// +// The following files are in that directory: +// - "ir_dialect.td" +// - "ir_ops.generated.td" +// - "interfaces.td" +// +// This is used to print the includes and header guards. +std::string PrintIrTableGen(const AstDef& ast, absl::string_view ir_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_IR_TABLE_GEN_PRINTER_H_ diff --git a/maldoca/astgen/ir_to_ast_source_printer.cc b/maldoca/astgen/ir_to_ast_source_printer.cc new file mode 100644 index 0000000..14aa0bf --- /dev/null +++ b/maldoca/astgen/ir_to_ast_source_printer.cc @@ -0,0 +1,540 @@ +// 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 "maldoca/astgen/ir_to_ast_source_printer.h" + +#include +#include + +#include "absl/base/attributes.h" +#include "absl/container/btree_map.h" +#include "absl/log/check.h" +#include "absl/log/log.h" +#include "absl/strings/str_cat.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/symbol.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { +namespace { + +MaybeNull OptionalnessToMaybeNull(Optionalness optionalness) { + switch (optionalness) { + case OPTIONALNESS_UNSPECIFIED: + case OPTIONALNESS_REQUIRED: + return MaybeNull::kNo; + case OPTIONALNESS_MAYBE_NULL: + case OPTIONALNESS_MAYBE_UNDEFINED: + return MaybeNull::kYes; + } +} + +static Symbol GetVisitor(const NodeDef& node, FieldKind kind) { + auto visitor = Symbol("Visit") + node.name(); + if (kind == FIELD_KIND_ATTR) { + visitor += "Attr"; + } + if (kind == FIELD_KIND_LVAL) { + visitor += "Ref"; + } + return visitor; +} + +} // namespace + +void IrToAstSourcePrinter::PrintAst(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path) { + auto ast_header_path = GetAstHeaderPath(ast_path); + + PrintLicense(); + Println(); + + PrintCodeGenerationWarning(); + Println(); + + Println("// IWYU pragma: begin_keep"); + Println("// NOLINTBEGIN(whitespace/line_length)"); + Println("// clang-format off"); + Println(); + + PrintIncludeHeader( + absl::StrCat(ir_path, "/conversion/", ast.lang_name(), "ir_to_ast.h")); + Println(); + + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println("#include "); + Println(); + + PrintIncludeHeaders({ + "llvm/ADT/APFloat.h", + "llvm/ADT/TypeSwitch.h", + "llvm/Support/Casting.h", + "mlir/IR/Attributes.h", + "mlir/IR/Block.h", + "mlir/IR/Builders.h", + "mlir/IR/BuiltinAttributes.h", + "mlir/IR/BuiltinTypes.h", + "mlir/IR/Operation.h", + "mlir/IR/Region.h", + "mlir/IR/Value.h", + "absl/cleanup/cleanup.h", + "absl/log/check.h", + "absl/log/log.h", + "absl/status/status.h", + "absl/status/statusor.h", + "absl/strings/str_cat.h", + "absl/types/optional.h", + "absl/types/variant.h", + "maldoca/astgen/ir_to_ast_util.h", + "maldoca/base/status_macros.h", + std::string(ast_header_path), + absl::StrCat(ir_path, "/ir.h"), + }); + Println(); + + PrintEnterNamespace(cc_namespace); + Println(); + + for (const auto* node : ast.topological_sorted_nodes()) { + if (!node->children().empty()) { + for (FieldKind kind : node->aggregated_kinds()) { + PrintNonLeafNode(ast, *node, kind); + } + } + + if (!node->should_generate_ir_op()) { + continue; + } + + for (FieldKind kind : node->aggregated_kinds()) { + PrintLeafNode(ast, *node, kind); + } + } + + Println("// clang-format on"); + Println("// NOLINTEND(whitespace/line_length)"); + Println("// IWYU pragma: end_keep"); + Println(); + + PrintExitNamespace(cc_namespace); +} + +void IrToAstSourcePrinter::PrintNonLeafNode(const AstDef& ast, + const NodeDef& node, + FieldKind kind) { + auto ir_op_name = node.ir_op_name(ast.lang_name(), kind); + std::string input_type; + if (ir_op_name.has_value()) { + input_type = ir_op_name->ToPascalCase(); + } else { + switch (kind) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Invalid FieldKind: FIELD_KIND_UNSPECIFIED."; + case FIELD_KIND_ATTR: + input_type = "mlir::Attribute"; + break; + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: + case FIELD_KIND_STMT: + input_type = "mlir::Operation*"; + break; + } + } + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + auto visitor = GetVisitor(node, kind); + + auto vars = WithVars({ + {"InputType", input_type}, + {"BaseName", + kind == FIELD_KIND_ATTR ? "mlir::Attribute" : "mlir::Operation*"}, + {"Name", (Symbol(ast.lang_name()) + node.name()).ToPascalCase()}, + {"name", kind == FIELD_KIND_ATTR ? "attr" : "op"}, + {"IrName", ir_name.ToPascalCase()}, + {"Visitor", visitor.ToPascalCase()}, + }); + + Println("absl::StatusOr>"); + Println("$IrName$ToAst::$Visitor$($InputType$ $name$) {"); + { + auto indent = WithIndent(); + Println("using Ret = absl::StatusOr>;"); + Println("return llvm::TypeSwitch<$BaseName$, Ret>($name$)"); + { + auto indent = WithIndent(); + for (const NodeDef* leaf : node.leafs()) { + auto vars = WithVars({ + {"LeafOpName", + leaf->ir_op_name(ast.lang_name(), kind)->ToPascalCase()}, + {"LeafVisitor", GetVisitor(*leaf, kind).ToPascalCase()}, + }); + Println(".Case([&]($LeafOpName$ $name$) {"); + Println(" return $LeafVisitor$($name$);"); + Println("})"); + } + + Println(".Default([&]($BaseName$ op) {"); + Println(" return absl::InvalidArgumentError(\"Unrecognized op\");"); + Println("});"); + } + } + Println("}"); + Println(); +} + +void IrToAstSourcePrinter::PrintLeafNode(const AstDef& ast, const NodeDef& node, + FieldKind kind) { + auto ir_op_name = node.ir_op_name(ast.lang_name(), kind).value(); + auto ir_name = Symbol(absl::StrCat(ast.lang_name(), "ir")); + + auto visitor = Symbol("Visit") + node.name(); + if (kind == FIELD_KIND_LVAL) { + visitor += "Ref"; + } + + auto vars = WithVars({ + {"OpName", ir_op_name.ToPascalCase()}, + {"Name", (Symbol(ast.lang_name()) + node.name()).ToPascalCase()}, + {"name", kind == FIELD_KIND_ATTR ? "attr" : "op"}, + {"IrName", ir_name.ToPascalCase()}, + {"Visitor", visitor.ToPascalCase()}, + }); + + Println("absl::StatusOr>"); + Println("$IrName$ToAst::$Visitor$($OpName$ $name$) {"); + { + auto indent = WithIndent(); + for (const auto* field : node.aggregated_fields()) { + if (FieldIsArgument(field)) { + PrintField(ast, node, *field); + } else if (FieldIsRegion(field)) { + PrintRegion(ast, node, *field); + } + } + + // Call the constructor. + Print("return Create<$Name$>(\n"); + { + auto indent = WithIndent(4); + Print("$name$"); + + for (const FieldDef* field : node.aggregated_fields()) { + if (!FieldIsArgument(field) && !FieldIsRegion(field)) { + continue; + } + + auto vars = WithVars({ + {"field_name", field->name().ToCcVarName()}, + }); + Print(",\nstd::move($field_name$)"); + } + } + + Println(");"); + } + Println("}"); + Println(); +} + +void IrToAstSourcePrinter::PrintField(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + MaybeNull maybe_null = OptionalnessToMaybeNull(field.optionalness()); + + auto mlir_getter = field.name().ToMlirGetter(); + + std::string rhs; + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Unspecified FieldKind."; + case FIELD_KIND_ATTR: { + rhs = absl::StrCat("op.", mlir_getter, "Attr()"); + break; + } + case FIELD_KIND_LVAL: + case FIELD_KIND_RVAL: { + rhs = absl::StrCat("op.", mlir_getter, "()"); + break; + } + case FIELD_KIND_STMT: { + LOG(FATAL) << "Unsupported FieldKind."; + } + } + + auto vars = WithVars({ + {"lhs", field.name().ToCcVarName()}, + {"rhs", rhs}, + }); + + Println("MALDOCA_ASSIGN_OR_RETURN("); + { + auto indent = WithIndent(4); + Println("auto $lhs$,"); + Print("Convert(\n"); + { + auto indent = WithIndent(4); + Println("$rhs$,"); + PrintConverter(ast, field.type(), ast.lang_name(), field.kind(), + maybe_null); + Println(); + } + Println(")"); + } + Println(");"); +} + +void IrToAstSourcePrinter::PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field) { + MaybeNull maybe_null = OptionalnessToMaybeNull(field.optionalness()); + + std::string converter_type = [&]() -> std::string { + switch (field.kind()) { + case FIELD_KIND_UNSPECIFIED: + LOG(FATAL) << "Unspecified FieldKind."; + case FIELD_KIND_ATTR: + LOG(FATAL) << "Unsupported FieldKind: " << field.kind(); + case FIELD_KIND_RVAL: + case FIELD_KIND_LVAL: { + if (field.type().IsA()) { + auto end_op = + Symbol(absl::StrCat(ast.lang_name(), "ir")) + "ExprsRegionEndOp"; + return absl::StrCat("ExprsRegion<", end_op.ToPascalCase(), ">"); + } else { + auto end_op = + Symbol(absl::StrCat(ast.lang_name(), "ir")) + "ExprRegionEndOp"; + return absl::StrCat("ExprRegion<", end_op.ToPascalCase(), ">"); + } + } + case FIELD_KIND_STMT: { + if (field.type().IsA()) { + return "StmtsRegion"; + } else { + return "StmtRegion"; + } + } + } + }(); + + auto vars = WithVars({ + {"ConverterType", converter_type}, + {"lhs", field.name().ToCcVarName()}, + {"mlirGetter", field.name().ToMlirGetter()}, + }); + + Println("MALDOCA_ASSIGN_OR_RETURN("); + { + auto indent = WithIndent(4); + Println("auto $lhs$,"); + Print("Convert(\n"); + { + auto indent = WithIndent(4); + Println("op.$mlirGetter$(),"); + + switch (maybe_null) { + case MaybeNull::kYes: { + Println("Nullable("); + { + auto indent = WithIndent(4); + Print("$ConverterType$(\n"); + { + auto indent = WithIndent(4); + PrintConverter(ast, field.type(), ast.lang_name(), field.kind(), + MaybeNull::kNo); + Println(); + } + Println(")"); + } + Println(")"); + break; + } + case MaybeNull::kNo: { + Print("$ConverterType$(\n"); + { + auto indent = WithIndent(4); + PrintConverter(ast, field.type(), ast.lang_name(), field.kind(), + MaybeNull::kNo); + Println(); + } + Println(")"); + } + } + } + Println(")"); + } + Println(");"); +} + +void IrToAstSourcePrinter::PrintConverter(const AstDef& ast, const Type& type, + absl::string_view lang_name, + FieldKind kind, + MaybeNull maybe_null) { + if (maybe_null == MaybeNull::kYes) { + if (kind == FIELD_KIND_LVAL || kind == FIELD_KIND_RVAL) { + auto none_op = Symbol(absl::StrCat(ast.lang_name(), "ir")) + "NoneOp"; + Print(absl::StrCat("Nullable<", none_op.ToPascalCase(), ">(\n")); + } else { + Print("Nullable(\n"); + } + { + auto indent = WithIndent(4); + PrintConverter(ast, type, lang_name, kind, MaybeNull::kNo); + Println(); + } + Print(")"); + return; + } + + switch (type.kind()) { + case TypeKind::kList: { + const auto& list_type = static_cast(type); + PrintListConverter(ast, list_type, lang_name, kind); + break; + } + + case TypeKind::kVariant: { + const auto& variant_type = static_cast(type); + PrintVariantConverter(ast, variant_type, lang_name, kind); + break; + } + + case TypeKind::kClass: { + const auto& class_type = static_cast(type); + PrintClassConverter(class_type, lang_name, kind); + break; + } + + case TypeKind::kEnum: { + const auto& enum_type = static_cast(type); + PrintEnumConverter(enum_type, lang_name); + break; + } + + case TypeKind::kBuiltin: { + const auto& builtin_type = static_cast(type); + PrintBuiltinConverter(builtin_type, kind); + break; + } + } +} + +void IrToAstSourcePrinter::PrintBuiltinConverter( + const BuiltinType& builtin_type, FieldKind kind) { + switch (builtin_type.builtin_kind()) { + case BuiltinTypeKind::kString: + Print("ToString()"); + break; + case BuiltinTypeKind::kBool: + Print("ToBool()"); + break; + case BuiltinTypeKind::kInt64: + Print("ToInt64()"); + break; + case BuiltinTypeKind::kDouble: + Print("ToDouble()"); + break; + default: + LOG(FATAL) << "Unreachable code."; + } +} + +void IrToAstSourcePrinter::PrintEnumConverter(const EnumType& enum_type, + absl::string_view lang_name) { + auto enum_name = Symbol(lang_name) + enum_type.name(); + + auto vars = WithVars({ + {"EnumName", enum_name.ToPascalCase()}, + {"cc_type", enum_type.CcType()}, + }); + Print("Enum<$cc_type$>(StringTo$EnumName$)"); +} + +void IrToAstSourcePrinter::PrintClassConverter(const ClassType& class_type, + absl::string_view lang_name, + FieldKind kind) { + auto visitor = Symbol("Visit") + class_type.name(); + if (kind == FIELD_KIND_ATTR) { + visitor += "Attr"; + } + if (kind == FIELD_KIND_LVAL) { + visitor += "Ref"; + } + + auto vars = WithVars({{"Visitor", visitor.ToPascalCase()}}); + if (kind == FIELD_KIND_ATTR) { + Print("ToAttrConverter($Visitor$)"); + } else { + Print("ToOpConverter($Visitor$)"); + } +} + +void IrToAstSourcePrinter::PrintVariantConverter( + const AstDef& ast, const VariantType& variant_type, + absl::string_view lang_name, FieldKind kind) { + if (kind == FIELD_KIND_ATTR) { + Println("AttrVariant("); + } else { + Println("OpVariant("); + } + { + auto indent = WithIndent(4); + TabPrinter tab_printer{{ + .print_separator = [this] { Print(",\n"); }, + }}; + + for (const auto& type : variant_type.types()) { + tab_printer.Print(); + PrintConverter(ast, *type, lang_name, kind, MaybeNull::kNo); + } + Println(); + } + Print(")"); +} + +void IrToAstSourcePrinter::PrintListConverter(const AstDef& ast, + const ListType& list_type, + absl::string_view lang_name, + FieldKind kind) { + Println("List("); + { + auto indent = WithIndent(4); + PrintConverter(ast, list_type.element_type(), lang_name, kind, + list_type.element_maybe_null()); + Println(); + } + Print(")"); +} + +std::string PrintIrToAstSource(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path) { + std::string str; + { + google::protobuf::io::StringOutputStream os(&str); + IrToAstSourcePrinter printer(&os); + printer.PrintAst(ast, cc_namespace, ast_path, ir_path); + } + + return str; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ir_to_ast_source_printer.h b/maldoca/astgen/ir_to_ast_source_printer.h new file mode 100644 index 0000000..528177d --- /dev/null +++ b/maldoca/astgen/ir_to_ast_source_printer.h @@ -0,0 +1,73 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_IR_TO_AST_SOURCE_PRINTER_H_ +#define MALDOCA_ASTGEN_IR_TO_AST_SOURCE_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/cc_printer_base.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +class IrToAstSourcePrinter : public CcPrinterBase { + public: + explicit IrToAstSourcePrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : CcPrinterBase(os) {} + + void PrintAst(const AstDef& ast, absl::string_view cc_namespace, + absl::string_view ast_path, absl::string_view ir_path); + + // Prints the Visit() function. + void PrintNonLeafNode(const AstDef& ast, const NodeDef& node, FieldKind kind); + + void PrintLeafNode(const AstDef& ast, const NodeDef& node, FieldKind kind); + + void PrintField(const AstDef& ast, const NodeDef& node, + const FieldDef& field); + + void PrintRegion(const AstDef& ast, const NodeDef& node, + const FieldDef& field); + + void PrintConverter(const AstDef& ast, const Type& type, + absl::string_view lang_name, FieldKind kind, + MaybeNull maybe_null); + + void PrintBuiltinConverter(const BuiltinType& builtin_type, FieldKind kind); + + void PrintEnumConverter(const EnumType& enum_type, + absl::string_view lang_name); + + void PrintClassConverter(const ClassType& class_type, + absl::string_view lang_name, FieldKind kind); + + void PrintVariantConverter(const AstDef& ast, const VariantType& variant_type, + absl::string_view lang_name, FieldKind kind); + + void PrintListConverter(const AstDef& ast, const ListType& list_type, + absl::string_view lang_name, FieldKind kind); +}; + +std::string PrintIrToAstSource(const AstDef& ast, + absl::string_view cc_namespace, + absl::string_view ast_path, + absl::string_view ir_path); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_IR_TO_AST_SOURCE_PRINTER_H_ diff --git a/maldoca/astgen/ir_to_ast_util.h b/maldoca/astgen/ir_to_ast_util.h new file mode 100644 index 0000000..056302e --- /dev/null +++ b/maldoca/astgen/ir_to_ast_util.h @@ -0,0 +1,598 @@ +// Copyright 2025 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. + +#ifndef MALDOCA_ASTGEN_IR_TO_AST_UTIL_H_ +#define MALDOCA_ASTGEN_IR_TO_AST_UTIL_H_ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "llvm/Support/Casting.h" +#include "mlir/IR/Attributes.h" +#include "mlir/IR/Block.h" +#include "mlir/IR/BuiltinAttributes.h" +#include "mlir/IR/OpDefinition.h" +#include "mlir/IR/Operation.h" +#include "mlir/IR/Region.h" +#include "mlir/IR/Value.h" +#include "mlir/IR/ValueRange.h" +#include "absl/status/status.h" +#include "absl/status/statusor.h" +#include "absl/strings/string_view.h" +#include "maldoca/base/status_macros.h" + +namespace maldoca { + +template +class ToOpConverter { + public: + // Specifically ignoring `explicit` to allow for implicit construction in + // `ToOpConverter`. + // NOLINTNEXTLINE(google-explicit-constructor) + ToOpConverter(std::function(OpT)> typed_op_converter) + : typed_op_converter_(std::move(typed_op_converter)), + match_op_([](mlir::Operation* op) { + if constexpr (std::is_same_v) { + return true; + } else { + return llvm::isa(op); + } + }) {} + + explicit ToOpConverter( + std::function(OpT)> typed_op_converter, + std::function(mlir::Operation*)> op_converter) + : typed_op_converter_(std::move(typed_op_converter)), + op_converter_(std::move(op_converter)), + match_op_([](mlir::Operation* op) { + if constexpr (std::is_same_v) { + return true; + } else { + return llvm::isa(op); + } + }) {} + + explicit ToOpConverter( + std::function(OpT)> typed_op_converter, + std::function match_op) + : typed_op_converter_(std::move(typed_op_converter)), + match_op_(std::move(match_op)) {} + + explicit ToOpConverter( + std::function(OpT)> typed_op_converter, + std::function(mlir::Operation*)> op_converter, + std::function match_op) + : typed_op_converter_(std::move(typed_op_converter)), + op_converter_(std::move(op_converter)), + match_op_(std::move(match_op)) {} + + absl::StatusOr operator()(OpT op) const { return typed_op_converter_(op); } + + // Only enable this overload if OpT is NOT mlir::Operation* + template , bool> = true> + absl::StatusOr operator()(mlir::Operation* op) const { + if (op_converter_ != nullptr) { + return op_converter_(op); + } + + if (op == nullptr) { + return absl::InvalidArgumentError("Input is null."); + } + + auto typed_op = llvm::dyn_cast(op); + if (typed_op == nullptr) { + return absl::InvalidArgumentError("Input is not of type OpT."); + } + + return typed_op_converter_(typed_op); + } + + absl::StatusOr operator()(mlir::Value value) const { + if (value == nullptr) { + return (*this)(static_cast(nullptr)); + } + return (*this)(value.getDefiningOp()); + } + + bool MatchOp(mlir::Operation* op) const { return match_op_(op); } + + private: + std::function(OpT)> typed_op_converter_; + std::function(mlir::Operation*)> op_converter_ = nullptr; + std::function match_op_; +}; + +// Deduction guide for ToOpConverter to allow implicit deduction from function +// pointers. +template +ToOpConverter(absl::StatusOr (*)(OpT)) -> ToOpConverter; + +template +class ToAttrConverter { + public: + // Specifically ignoring `explicit` to allow for implicit construction in + // `ToAttrConverter`. + // NOLINTNEXTLINE(google-explicit-constructor) + ToAttrConverter(std::function(AttrT)> typed_attr_converter) + : typed_attr_converter_(std::move(typed_attr_converter)) {} + + explicit ToAttrConverter( + std::function(AttrT)> typed_attr_converter, + std::function(mlir::Attribute)> attr_converter) + : typed_attr_converter_(std::move(typed_attr_converter)), + attr_converter_(std::move(attr_converter)) {} + + absl::StatusOr operator()(AttrT attr) const { + return typed_attr_converter_(attr); + } + + // Only enable this overload if AttrT is NOT mlir::Attribute + template , bool> = true> + absl::StatusOr operator()(mlir::Attribute attr) const { + if (attr_converter_ != nullptr) { + return attr_converter_(attr); + } + + if (attr == nullptr) { + return absl::InvalidArgumentError("Input is null."); + } + + auto typed_attr = llvm::dyn_cast(attr); + if (typed_attr == nullptr) { + return absl::InvalidArgumentError("Input is not of type AttrT."); + } + + return typed_attr_converter_(typed_attr); + } + + private: + std::function(AttrT)> typed_attr_converter_; + std::function(mlir::Attribute)> attr_converter_ = nullptr; +}; + +// Deduction guide for ToAttrConverter to allow implicit deduction from function +// pointers. +template +ToAttrConverter(absl::StatusOr (*)(AttrT)) -> ToAttrConverter; + +template +class ToOpsConverter { + public: + ToOpsConverter(std::function>(mlir::ValueRange)> + values_converter, + std::function>(mlir::Block*)> + block_converter) + : values_converter_(std::move(values_converter)), + block_converter_(std::move(block_converter)) {} + + absl::StatusOr> operator()(mlir::ValueRange values) const { + if (values_converter_ == nullptr) { + return absl::UnimplementedError("values_converter_ is null."); + } + return values_converter_(values); + } + + absl::StatusOr> operator()(mlir::Block* block) const { + if (block_converter_ == nullptr) { + return absl::UnimplementedError("block_converter_ is null."); + } + return block_converter_(block); + } + + private: + std::function>(mlir::ValueRange)> + values_converter_ = nullptr; + std::function>(mlir::Block*)> block_converter_ = + nullptr; +}; + +template +class ToRegionConverter { + public: + // Specifically ignoring `explicit` to allow for implicit construction in + // `ToRegionConverter`. + // NOLINTNEXTLINE(google-explicit-constructor) + ToRegionConverter(std::function(mlir::Region&)> converter) + : converter_(std::move(converter)) {} + + absl::StatusOr operator()(mlir::Region& region) const { + if (converter_ == nullptr) { + return absl::UnimplementedError("converter_ is null."); + } + return converter_(region); + } + + private: + std::function(mlir::Region&)> converter_ = nullptr; +}; + +template +ToOpConverter> OpVariant( + ToOpConverter... converters) { + return ToOpConverter>( + [=](mlir::Operation* op) -> absl::StatusOr> { + std::optional> result; + bool matched = false; + absl::Status last_error = + absl::InvalidArgumentError("No variant matched."); + ( + [&] { + if (!matched) { + auto val_or = converters(op); + if (val_or.ok()) { + matched = true; + result = std::variant(*std::move(val_or)); + } else if (!absl::IsInvalidArgument(val_or.status())) { + last_error = val_or.status(); + } + } + }(), + ...); + if (!result.has_value()) { + return last_error; + } + return *std::move(result); + }, + /*op_converter=*/nullptr, + /*match_op=*/ + [=](mlir::Operation* op) { return (converters.MatchOp(op) || ...); }); +} + +template +ToAttrConverter> Nullable( + ToAttrConverter converter) { + return ToAttrConverter>{ + /*typed_attr_converter=*/ + [=](AttrT attr) -> absl::StatusOr> { + if (attr == nullptr) { + return std::nullopt; + } + return converter(attr); + }, + /*attr_converter=*/ + [=](mlir::Attribute attr) -> absl::StatusOr> { + if (attr == nullptr) { + return std::nullopt; + } + return converter(attr); + }}; +} + +template +ToOpConverter> Nullable(ToOpConverter converter) { + return ToOpConverter>{ + /*typed_op_converter=*/ + [=](OpT op) -> absl::StatusOr> { + if (op == nullptr) { + return std::nullopt; + } + return converter(op); + }, + /*op_converter=*/ + [=](mlir::Operation* op) -> absl::StatusOr> { + if (op == nullptr) { + return std::nullopt; + } + return converter(op); + }, + /*match_op=*/ + [=](mlir::Operation* op) { + return op == nullptr || converter.MatchOp(op); + }}; +} + +template +ToOpConverter> Nullable(ToOpConverter converter) { + return ToOpConverter>{ + /*typed_op_converter=*/ + [=](OpT op) -> absl::StatusOr> { + if (op == nullptr) { + return std::nullopt; + } + if (llvm::isa(op)) { + return std::nullopt; + } + return converter(op); + }, + /*op_converter=*/ + [=](mlir::Operation* op) -> absl::StatusOr> { + if (op == nullptr) { + return std::nullopt; + } + if (llvm::isa(op)) { + return std::nullopt; + } + return converter(op); + }, + /*match_op=*/ + [=](mlir::Operation* op) { + return op == nullptr || llvm::isa(op) || converter.MatchOp(op); + }}; +} + +template +ToRegionConverter> Nullable(ToRegionConverter converter) { + return ToRegionConverter>( + [=](mlir::Region& region) -> absl::StatusOr> { + if (region.empty()) { + return std::nullopt; + } + return converter(region); + }); +} + +template +absl::StatusOr GetExprRegionValue(mlir::Region& region) { + if (!region.hasOneBlock()) { + return absl::InvalidArgumentError("Region should have exactly one block."); + } + mlir::Block& block = region.front(); + if (block.empty()) { + return absl::InvalidArgumentError("Block cannot be empty."); + } + auto expr_region_end = llvm::dyn_cast(block.back()); + if (expr_region_end == nullptr) { + return absl::InvalidArgumentError( + "Block should end with expected terminator."); + } + return expr_region_end.getArgument(); +} + +template +absl::StatusOr GetExprsRegionValues(mlir::Region& region) { + if (!region.hasOneBlock()) { + return absl::InvalidArgumentError("Region should have exactly one block."); + } + mlir::Block& block = region.front(); + if (block.empty()) { + return absl::InvalidArgumentError("Block cannot be empty."); + } + auto exprs_region_end = llvm::dyn_cast(block.back()); + if (exprs_region_end == nullptr) { + return absl::InvalidArgumentError( + "Block should end with expected terminator."); + } + return exprs_region_end.getArguments(); +} + +inline absl::StatusOr GetStmtRegionOperation( + mlir::Region& region) { + if (!region.hasOneBlock()) { + return absl::InvalidArgumentError("Region should have exactly one block."); + } + mlir::Block& block = region.front(); + if (block.empty()) { + return absl::InvalidArgumentError("Block cannot be empty."); + } + return &block.back(); +} + +inline absl::StatusOr GetStmtsRegionBlock(mlir::Region& region) { + if (!region.hasOneBlock()) { + return absl::InvalidArgumentError("Region should have exactly one block."); + } + mlir::Block& block = region.front(); + return █ +} + +template +ToRegionConverter ExprRegion(ToOpConverter converter) { + return ToRegionConverter([=](mlir::Region& region) -> absl::StatusOr { + MALDOCA_ASSIGN_OR_RETURN(auto val, GetExprRegionValue(region)); + return Convert(val, converter); + }); +} + +template +ToRegionConverter> ExprsRegion(ToOpsConverter converter) { + return ToRegionConverter>( + [=](mlir::Region& region) -> absl::StatusOr> { + MALDOCA_ASSIGN_OR_RETURN(auto vals, + GetExprsRegionValues(region)); + return Convert(vals, converter); + }); +} + +template +ToRegionConverter StmtRegion(ToOpConverter converter) { + return ToRegionConverter([=](mlir::Region& region) -> absl::StatusOr { + MALDOCA_ASSIGN_OR_RETURN(auto op, GetStmtRegionOperation(region)); + return Convert(op, converter); + }); +} + +template +ToRegionConverter> StmtsRegion(ToOpsConverter converter) { + return ToRegionConverter>( + [=](mlir::Region& region) -> absl::StatusOr> { + MALDOCA_ASSIGN_OR_RETURN(auto block, GetStmtsRegionBlock(region)); + return Convert(block, converter); + }); +} + +template +inline ToAttrConverter Enum( + std::function(absl::string_view)> string_to_enum) { + return ToAttrConverter( + [=](mlir::StringAttr attr) -> absl::StatusOr { + return string_to_enum(attr.str()); + }); +} + +template +ToAttrConverter> AttrVariant( + ToAttrConverter... converters) { + return ToAttrConverter>( + [=](mlir::Attribute attr) -> absl::StatusOr> { + std::optional> result; + bool matched = false; + absl::Status last_error = + absl::InvalidArgumentError("No variant matched."); + ( + [&] { + if (!matched) { + auto val_or = converters(attr); + if (val_or.ok()) { + matched = true; + result = std::variant(*std::move(val_or)); + } else if (!absl::IsInvalidArgument(val_or.status())) { + last_error = val_or.status(); + } + } + }(), + ...); + if (!result.has_value()) { + return last_error; + } + return *std::move(result); + }); +} + +template +ToAttrConverter> List( + ToAttrConverter elem_converter) { + return ToAttrConverter>( + [=](mlir::ArrayAttr attr) -> absl::StatusOr> { + std::vector result; + result.reserve(attr.size()); + for (mlir::Attribute element : attr.getValue()) { + MALDOCA_ASSIGN_OR_RETURN(T value, elem_converter(element)); + result.push_back(std::move(value)); + } + return result; + }); +} + +template +ToOpsConverter List(ToOpConverter elem_converter) { + return ToOpsConverter( + /*values_converter=*/ + [=](mlir::ValueRange values) -> absl::StatusOr> { + std::vector result; + result.reserve(values.size()); + for (mlir::Value element : values) { + MALDOCA_ASSIGN_OR_RETURN(T value, elem_converter(element)); + result.push_back(std::move(value)); + } + return result; + }, + /*block_converter=*/ + [=](mlir::Block* block) -> absl::StatusOr> { + std::vector result; + if (block == nullptr) { + return result; + } + for (mlir::Operation& element : *block) { + if (element.hasTrait()) { + continue; + } + if (!elem_converter.MatchOp(&element)) { + continue; + } + auto casted = llvm::dyn_cast(&element); + if (!casted) { + continue; + } + MALDOCA_ASSIGN_OR_RETURN(T value, elem_converter(casted)); + result.push_back(std::move(value)); + } + return result; + }); +} + +template +absl::StatusOr> Convert(mlir::ValueRange values, + const ToOpsConverter& converter) { + return converter(values); +} + +template +absl::StatusOr Convert(mlir::Value value, + const ToOpConverter& converter) { + return converter(value); +} + +template +absl::StatusOr> Convert(mlir::Block* block, + const ToOpsConverter& converter) { + return converter(block); +} + +template +absl::StatusOr Convert(mlir::Region& region, + const ToRegionConverter& converter) { + return converter(region); +} + +template +absl::StatusOr Convert(mlir::Operation* op, + ToOpConverter converter) { + return converter(op); +} + +template +absl::StatusOr Convert(mlir::Attribute attr, + ToAttrConverter converter) { + return converter(attr); +} + +// Attr converters +inline bool IsBool(mlir::Attribute attr) { + return llvm::isa(attr); +} +inline ToAttrConverter ToBool() { + return ToAttrConverter( + [](mlir::BoolAttr attr) -> absl::StatusOr { + return attr.getValue(); + }); +} +inline bool IsString(mlir::Attribute attr) { + return llvm::isa(attr); +} +inline ToAttrConverter ToString() { + return ToAttrConverter( + [](mlir::StringAttr attr) -> absl::StatusOr { + return attr.str(); + }); +} +inline bool IsDouble(mlir::Attribute attr) { + return llvm::isa(attr); +} +inline ToAttrConverter ToDouble() { + return ToAttrConverter( + [](mlir::FloatAttr attr) -> absl::StatusOr { + return attr.getValueAsDouble(); + }); +} +inline bool IsInt64(mlir::Attribute attr) { + return llvm::isa(attr); +} +inline ToAttrConverter ToInt64() { + return ToAttrConverter( + [](mlir::IntegerAttr attr) -> absl::StatusOr { + return attr.getValue().getSExtValue(); + }); +} + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_IR_TO_AST_UTIL_H_ diff --git a/maldoca/astgen/printer_base.h b/maldoca/astgen/printer_base.h new file mode 100644 index 0000000..efd40d5 --- /dev/null +++ b/maldoca/astgen/printer_base.h @@ -0,0 +1,41 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_PRINTER_BASE_H_ +#define MALDOCA_ASTGEN_PRINTER_BASE_H_ + +#include + +#include "google/protobuf/io/printer.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +class AstGenPrinterBase : public google::protobuf::io::Printer { + public: + explicit AstGenPrinterBase(google::protobuf::io::ZeroCopyOutputStream* os) + : google::protobuf::io::Printer(os, /*variable_delimiter=*/'$') {} + + template + void Println(Args&&... args) { + Print(std::forward(args)...); + Print("\n"); + } + + void Println() { Println(""); } +}; + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_PRINTER_BASE_H_ diff --git a/maldoca/astgen/symbol.cc b/maldoca/astgen/symbol.cc index 221ad09..f99de05 100644 --- a/maldoca/astgen/symbol.cc +++ b/maldoca/astgen/symbol.cc @@ -61,18 +61,18 @@ Symbol::Symbol(absl::string_view str) { } } -Symbol &Symbol::operator+=(const Symbol &other) { +Symbol& Symbol::operator+=(const Symbol& other) { words_.insert(words_.end(), other.words_.begin(), other.words_.end()); return *this; } -Symbol &Symbol::operator+=(Symbol &&other) { +Symbol& Symbol::operator+=(Symbol&& other) { words_.insert(words_.end(), std::make_move_iterator(other.words_.begin()), std::make_move_iterator(other.words_.end())); return *this; } -Symbol &Symbol::operator+=(absl::string_view other) { +Symbol& Symbol::operator+=(absl::string_view other) { return operator+=(Symbol(other)); } @@ -80,7 +80,7 @@ std::string Symbol::ToSnakeCase() const { return absl::StrJoin(words_, "_"); } bool Symbol::IsReservedKeyword() const { // https://en.cppreference.com/w/cpp/keyword - static const auto *kReservedKeywords = new absl::flat_hash_set{ + static const auto* kReservedKeywords = new absl::flat_hash_set{ "alignas", "alignof", "and", @@ -206,7 +206,7 @@ std::string Symbol::ToMlirGetter() const { std::string Symbol::ToPascalCase() const { std::string result; - for (const auto &word : words_) { + for (const auto& word : words_) { result.push_back(absl::ascii_toupper(word[0])); result.append(word.substr(1)); } @@ -215,7 +215,7 @@ std::string Symbol::ToPascalCase() const { std::string Symbol::ToCamelCase() const { std::string result; - for (const auto &word : words_) { + for (const auto& word : words_) { if (result.empty()) { result = word; } else { diff --git a/maldoca/astgen/test/BUILD b/maldoca/astgen/test/BUILD index 76f8d28..e160f8c 100644 --- a/maldoca/astgen/test/BUILD +++ b/maldoca/astgen/test/BUILD @@ -31,7 +31,14 @@ cc_library( deps = [ "//maldoca/astgen:ast_def", "//maldoca/astgen:ast_def_cc_proto", - "//maldoca/astgen:ast_gen", + "//maldoca/astgen:ast_from_json_printer", + "//maldoca/astgen:ast_header_printer", + "//maldoca/astgen:ast_serialize_printer", + "//maldoca/astgen:ast_source_printer", + "//maldoca/astgen:ast_to_ir_source_printer", + "//maldoca/astgen:ir_table_gen_printer", + "//maldoca/astgen:ir_to_ast_source_printer", + "//maldoca/astgen:ts_interface_printer", "//maldoca/base:filesystem", "//maldoca/base:get_runfiles_dir", "//maldoca/base:status", diff --git a/maldoca/astgen/test/assign/BUILD b/maldoca/astgen/test/assign/BUILD index 48d7459..42ba62f 100644 --- a/maldoca/astgen/test/assign/BUILD +++ b/maldoca/astgen/test/assign/BUILD @@ -54,6 +54,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", @@ -173,12 +174,7 @@ cc_library( ":air_types_inc_gen", ":interfaces_inc_gen", "@llvm-project//llvm:Support", - "@llvm-project//mlir:Analysis", - "@llvm-project//mlir:ControlFlowInterfaces", "@llvm-project//mlir:IR", "@llvm-project//mlir:InferTypeOpInterface", - "@llvm-project//mlir:Parser", - "@llvm-project//mlir:SideEffectInterfaces", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/assign/ast_from_json.generated.cc b/maldoca/astgen/test/assign/ast_from_json.generated.cc index 1516eda..be9a769 100644 --- a/maldoca/astgen/test/assign/ast_from_json.generated.cc +++ b/maldoca/astgen/test/assign/ast_from_json.generated.cc @@ -35,26 +35,12 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // AExpression // ============================================================================= @@ -81,19 +67,11 @@ AExpression::FromJson(const nlohmann::json& json) { absl::StatusOr AIdentifier::GetName(const nlohmann::json& json) { - auto name_it = json.find("name"); - if (name_it == json.end()) { - return absl::InvalidArgumentError("`name` is undefined."); - } - const nlohmann::json& json_name = name_it.value(); - - if (json_name.is_null()) { - return absl::InvalidArgumentError("json_name is null."); - } - if (!json_name.is_string()) { - return absl::InvalidArgumentError("Expecting json_name.is_string()."); - } - return json_name.get(); + return GetRequiredField( + json, + "name", + JsonToString + ); } absl::StatusOr> @@ -114,30 +92,20 @@ AIdentifier::FromJson(const nlohmann::json& json) { absl::StatusOr> AAssignment::GetLhs(const nlohmann::json& json) { - auto lhs_it = json.find("lhs"); - if (lhs_it == json.end()) { - return absl::InvalidArgumentError("`lhs` is undefined."); - } - const nlohmann::json& json_lhs = lhs_it.value(); - - if (json_lhs.is_null()) { - return absl::InvalidArgumentError("json_lhs is null."); - } - return AIdentifier::FromJson(json_lhs); + return GetRequiredField>( + json, + "lhs", + AIdentifier::FromJson + ); } absl::StatusOr> AAssignment::GetRhs(const nlohmann::json& json) { - auto rhs_it = json.find("rhs"); - if (rhs_it == json.end()) { - return absl::InvalidArgumentError("`rhs` is undefined."); - } - const nlohmann::json& json_rhs = rhs_it.value(); - - if (json_rhs.is_null()) { - return absl::InvalidArgumentError("json_rhs is null."); - } - return AExpression::FromJson(json_rhs); + return GetRequiredField>( + json, + "rhs", + AExpression::FromJson + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/assign/ast_gen_test.cc b/maldoca/astgen/test/assign/ast_gen_test.cc index 568c194..f740d1c 100644 --- a/maldoca/astgen/test/assign/ast_gen_test.cc +++ b/maldoca/astgen/test/assign/ast_gen_test.cc @@ -21,10 +21,9 @@ namespace { INSTANTIATE_TEST_SUITE_P( Assign, AstGenTest, ::testing::Values(AstGenTestParam{ - .ast_def_path = - "maldoca/astgen/test/assign/ast_def.textproto", + .ast_def_path = "maldoca/astgen/test/assign/ast_def.textproto", .ts_interface_path = "maldoca/astgen/test/" - "assign/ast_ts_interface.generated", + "assign/ast_ts_interface.generated", .cc_namespace = "maldoca", .ast_path = "maldoca/astgen/test/assign", .ir_path = "maldoca/astgen/test/assign", @@ -32,15 +31,12 @@ INSTANTIATE_TEST_SUITE_P( "maldoca/astgen/test/assign/ast.generated.h", .expected_ast_source_path = "maldoca/astgen/test/assign/ast.generated.cc", - .expected_ast_to_json_path = - "maldoca/astgen/test/" - "assign/ast_to_json.generated.cc", - .expected_ast_from_json_path = - "maldoca/astgen/test/" - "assign/ast_from_json.generated.cc", - .expected_ir_tablegen_path = - "maldoca/astgen/test/" - "assign/air_ops.generated.td", + .expected_ast_to_json_path = "maldoca/astgen/test/" + "assign/ast_to_json.generated.cc", + .expected_ast_from_json_path = "maldoca/astgen/test/" + "assign/ast_from_json.generated.cc", + .expected_ir_tablegen_path = "maldoca/astgen/test/" + "assign/air_ops.generated.td", .expected_ast_to_ir_source_path = "maldoca/astgen/test/assign/conversion/" "ast_to_air.generated.cc", diff --git a/maldoca/astgen/test/assign/conversion/BUILD b/maldoca/astgen/test/assign/conversion/BUILD index 8f43991..1f61067 100644 --- a/maldoca/astgen/test/assign/conversion/BUILD +++ b/maldoca/astgen/test/assign/conversion/BUILD @@ -46,6 +46,7 @@ cc_library( srcs = ["air_to_ast.generated.cc"], hdrs = ["air_to_ast.h"], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/astgen/test/assign:ast", "//maldoca/astgen/test/assign:ir", "//maldoca/base:status", diff --git a/maldoca/astgen/test/assign/conversion/air_to_ast.generated.cc b/maldoca/astgen/test/assign/conversion/air_to_ast.generated.cc index d2cced5..77653f5 100644 --- a/maldoca/astgen/test/assign/conversion/air_to_ast.generated.cc +++ b/maldoca/astgen/test/assign/conversion/air_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/astgen/test/assign/ast.generated.h" #include "maldoca/astgen/test/assign/ir.h" @@ -71,7 +72,13 @@ AirToAst::VisitExpression(AirExpressionOpInterface op) { absl::StatusOr> AirToAst::VisitIdentifier(AirIdentifierOp op) { - std::string name = op.getNameAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto name, + Convert( + op.getNameAttr(), + ToString() + ) + ); return Create( op, std::move(name)); @@ -79,7 +86,13 @@ AirToAst::VisitIdentifier(AirIdentifierOp op) { absl::StatusOr> AirToAst::VisitIdentifierRef(AirIdentifierRefOp op) { - std::string name = op.getNameAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto name, + Convert( + op.getNameAttr(), + ToString() + ) + ); return Create( op, std::move(name)); @@ -87,20 +100,20 @@ AirToAst::VisitIdentifierRef(AirIdentifierRefOp op) { absl::StatusOr> AirToAst::VisitAssignment(AirAssignmentOp op) { - auto lhs_op = llvm::dyn_cast(op.getLhs().getDefiningOp()); - if (lhs_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected AirIdentifierRefOp, got ", - op.getLhs().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr lhs, VisitIdentifierRef(lhs_op)); - auto rhs_op = llvm::dyn_cast(op.getRhs().getDefiningOp()); - if (rhs_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected AirExpressionOpInterface, got ", - op.getRhs().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr rhs, VisitExpression(rhs_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto lhs, + Convert( + op.getLhs(), + ToOpConverter(VisitIdentifierRef) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto rhs, + Convert( + op.getRhs(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(lhs), diff --git a/maldoca/astgen/test/assign/conversion/air_to_ast.h b/maldoca/astgen/test/assign/conversion/air_to_ast.h index ae51d54..6c6b9b5 100644 --- a/maldoca/astgen/test/assign/conversion/air_to_ast.h +++ b/maldoca/astgen/test/assign/conversion/air_to_ast.h @@ -26,20 +26,20 @@ namespace maldoca { class AirToAst { public: - absl::StatusOr> VisitExpression( + static absl::StatusOr> VisitExpression( AirExpressionOpInterface op); - absl::StatusOr> VisitIdentifier( + static absl::StatusOr> VisitIdentifier( AirIdentifierOp op); - absl::StatusOr> VisitIdentifierRef( + static absl::StatusOr> VisitIdentifierRef( AirIdentifierRefOp op); - absl::StatusOr> VisitAssignment( + static absl::StatusOr> VisitAssignment( AirAssignmentOp op); template - std::unique_ptr Create(mlir::Operation *op, Args &&...args) { + static std::unique_ptr Create(mlir::Operation *op, Args &&...args) { return absl::make_unique(std::forward(args)...); } }; diff --git a/maldoca/astgen/test/assign/conversion/ast_to_air.generated.cc b/maldoca/astgen/test/assign/conversion/ast_to_air.generated.cc index 77e875b..b5f2ef3 100644 --- a/maldoca/astgen/test/assign/conversion/ast_to_air.generated.cc +++ b/maldoca/astgen/test/assign/conversion/ast_to_air.generated.cc @@ -45,30 +45,30 @@ namespace maldoca { -AirExpressionOpInterface AstToAir::VisitExpression(const AExpression *node) { +AirExpressionOpInterface AstToAir::VisitExpression(mlir::OpBuilder &builder, const AExpression *node) { if (auto *identifier = dynamic_cast(node)) { - return VisitIdentifier(identifier); + return VisitIdentifier(builder, identifier); } if (auto *assignment = dynamic_cast(node)) { - return VisitAssignment(assignment); + return VisitAssignment(builder, assignment); } LOG(FATAL) << "Unreachable code."; } -AirIdentifierOp AstToAir::VisitIdentifier(const AIdentifier *node) { - mlir::StringAttr mlir_name = builder_.getStringAttr(node->name()); - return CreateExpr(node, mlir_name); +AirIdentifierOp AstToAir::VisitIdentifier(mlir::OpBuilder &builder, const AIdentifier *node) { + mlir::StringAttr mlir_name = builder.getStringAttr(node->name()); + return CreateExpr(builder, node, mlir_name); } -AirIdentifierRefOp AstToAir::VisitIdentifierRef(const AIdentifier *node) { - mlir::StringAttr mlir_name = builder_.getStringAttr(node->name()); - return CreateExpr(node, mlir_name); +AirIdentifierRefOp AstToAir::VisitIdentifierRef(mlir::OpBuilder &builder, const AIdentifier *node) { + mlir::StringAttr mlir_name = builder.getStringAttr(node->name()); + return CreateExpr(builder, node, mlir_name); } -AirAssignmentOp AstToAir::VisitAssignment(const AAssignment *node) { - mlir::Value mlir_lhs = VisitIdentifierRef(node->lhs()); - mlir::Value mlir_rhs = VisitExpression(node->rhs()); - return CreateExpr(node, mlir_lhs, mlir_rhs); +AirAssignmentOp AstToAir::VisitAssignment(mlir::OpBuilder &builder, const AAssignment *node) { + mlir::Value mlir_lhs = VisitIdentifierRef(builder, node->lhs()); + mlir::Value mlir_rhs = VisitExpression(builder, node->rhs()); + return CreateExpr(builder, node, mlir_lhs, mlir_rhs); } // clang-format on diff --git a/maldoca/astgen/test/assign/conversion/ast_to_air.h b/maldoca/astgen/test/assign/conversion/ast_to_air.h index 5d9b27d..ded62c0 100644 --- a/maldoca/astgen/test/assign/conversion/ast_to_air.h +++ b/maldoca/astgen/test/assign/conversion/ast_to_air.h @@ -23,24 +23,25 @@ namespace maldoca { class AstToAir { public: - explicit AstToAir(mlir::OpBuilder &builder) : builder_(builder) {} + static AirIdentifierOp VisitIdentifier(mlir::OpBuilder& builder, + const AIdentifier* node); - AirIdentifierOp VisitIdentifier(const AIdentifier *node); + static AirIdentifierRefOp VisitIdentifierRef(mlir::OpBuilder& builder, + const AIdentifier* node); - AirIdentifierRefOp VisitIdentifierRef(const AIdentifier *node); + static AirAssignmentOp VisitAssignment(mlir::OpBuilder& builder, + const AAssignment* node); - AirAssignmentOp VisitAssignment(const AAssignment *node); - - AirExpressionOpInterface VisitExpression(const AExpression *node); + static AirExpressionOpInterface VisitExpression(mlir::OpBuilder& builder, + const AExpression* node); private: template - Op CreateExpr(const Node *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + static Op CreateExpr(mlir::OpBuilder& builder, const Node* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/assign/conversion/conversion_test.cc b/maldoca/astgen/test/assign/conversion/conversion_test.cc index 71d59bf..8d85a60 100644 --- a/maldoca/astgen/test/assign/conversion/conversion_test.cc +++ b/maldoca/astgen/test/assign/conversion/conversion_test.cc @@ -46,10 +46,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToAir::VisitAssignment, + .ast_to_ir_visit = AstToAir::VisitAssignment, .ir_to_ast_visit = &AirToAst::VisitAssignment, .expected_ir_dump = kExpectedIrDump, }); @@ -88,10 +87,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToAir::VisitAssignment, + .ast_to_ir_visit = AstToAir::VisitAssignment, .ir_to_ast_visit = &AirToAst::VisitAssignment, .expected_ir_dump = kExpectedIrDump, }); diff --git a/maldoca/astgen/test/ast_gen_test_util.cc b/maldoca/astgen/test/ast_gen_test_util.cc index 4b32746..52f7b2c 100644 --- a/maldoca/astgen/test/ast_gen_test_util.cc +++ b/maldoca/astgen/test/ast_gen_test_util.cc @@ -23,7 +23,14 @@ #include "absl/strings/ascii.h" #include "maldoca/astgen/ast_def.h" #include "maldoca/astgen/ast_def.pb.h" -#include "maldoca/astgen/ast_gen.h" +#include "maldoca/astgen/ast_from_json_printer.h" +#include "maldoca/astgen/ast_header_printer.h" +#include "maldoca/astgen/ast_serialize_printer.h" +#include "maldoca/astgen/ast_source_printer.h" +#include "maldoca/astgen/ast_to_ir_source_printer.h" +#include "maldoca/astgen/ir_table_gen_printer.h" +#include "maldoca/astgen/ir_to_ast_source_printer.h" +#include "maldoca/astgen/ts_interface_printer.h" #include "maldoca/base/filesystem.h" #include "maldoca/base/get_runfiles_dir.h" #include "maldoca/base/status_macros.h" diff --git a/maldoca/astgen/test/conversion_test_util.h b/maldoca/astgen/test/conversion_test_util.h index fd80528..a9792ec 100644 --- a/maldoca/astgen/test/conversion_test_util.h +++ b/maldoca/astgen/test/conversion_test_util.h @@ -15,6 +15,7 @@ #ifndef MALDOCA_ASTGEN_TEST_CONVERSION_TEST_UTIL_H_ #define MALDOCA_ASTGEN_TEST_CONVERSION_TEST_UTIL_H_ +#include #include #include #include @@ -32,21 +33,18 @@ namespace maldoca { -class DummyIrToAst {}; - -template +template struct ConversionTestCase { std::string ast_json_string; std::unique_ptr ast; - OpT (AstToIr::*ast_to_ir_visit)(const NodeT *); - absl::StatusOr> (IrToAst::*ir_to_ast_visit)(OpT); + std::function ast_to_ir_visit; + std::function>(OpT)> ir_to_ast_visit; std::string expected_ir_dump; }; -template +template void TestIrConversion( - ConversionTestCase &&test_case) { + ConversionTestCase &&test_case) { if (!test_case.ast_json_string.empty()) { auto ast_json = nlohmann::json::parse(test_case.ast_json_string, /*callback=*/nullptr, @@ -69,8 +67,7 @@ void TestIrConversion( mlir::Block *block = &module->getBodyRegion().front(); builder.setInsertionPointToStart(block); - AstToIr ast_to_ir(builder); - OpT op = (ast_to_ir.*(test_case.ast_to_ir_visit))(test_case.ast.get()); + OpT op = test_case.ast_to_ir_visit(builder, test_case.ast.get()); std::string ir_dump; llvm::raw_string_ostream os(ir_dump); @@ -80,9 +77,8 @@ void TestIrConversion( absl::StripAsciiWhitespace(test_case.expected_ir_dump)); if (test_case.ir_to_ast_visit != nullptr) { - IrToAst ir_to_ast; MALDOCA_ASSERT_OK_AND_ASSIGN(auto raised_ast, - (ir_to_ast.*(test_case.ir_to_ast_visit))(op)); + test_case.ir_to_ast_visit(op)); std::stringstream test_case_ss; test_case.ast->Serialize(test_case_ss); diff --git a/maldoca/astgen/test/enum/BUILD b/maldoca/astgen/test/enum/BUILD index deed21b..15e93a9 100644 --- a/maldoca/astgen/test/enum/BUILD +++ b/maldoca/astgen/test/enum/BUILD @@ -56,6 +56,7 @@ cc_library( "ast.generated.h", ], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", @@ -175,12 +176,7 @@ cc_library( ":eir_types_inc_gen", ":interfaces_inc_gen", "@llvm-project//llvm:Support", - "@llvm-project//mlir:Analysis", - "@llvm-project//mlir:ControlFlowInterfaces", "@llvm-project//mlir:IR", "@llvm-project//mlir:InferTypeOpInterface", - "@llvm-project//mlir:Parser", - "@llvm-project//mlir:SideEffectInterfaces", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/enum/ast_from_json.generated.cc b/maldoca/astgen/test/enum/ast_from_json.generated.cc index f5f18ea..50d4add 100644 --- a/maldoca/astgen/test/enum/ast_from_json.generated.cc +++ b/maldoca/astgen/test/enum/ast_from_json.generated.cc @@ -35,6 +35,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" @@ -46,38 +47,20 @@ namespace maldoca { absl::StatusOr ENode::GetUnaryOperator(const nlohmann::json& json) { - auto unary_operator_it = json.find("unaryOperator"); - if (unary_operator_it == json.end()) { - return absl::InvalidArgumentError("`unaryOperator` is undefined."); - } - const nlohmann::json& json_unary_operator = unary_operator_it.value(); - - if (json_unary_operator.is_null()) { - return absl::InvalidArgumentError("json_unary_operator is null."); - } - if (!json_unary_operator.is_string()) { - return absl::InvalidArgumentError("`json_unary_operator` expected to be a string."); - } - std::string json_unary_operator_str = json_unary_operator.get(); - return StringToEUnaryOperator(json_unary_operator_str); + return GetRequiredField( + json, + "unaryOperator", + Enum(StringToEUnaryOperator) + ); } absl::StatusOr ENode::GetEscapedChar(const nlohmann::json& json) { - auto escaped_char_it = json.find("escapedChar"); - if (escaped_char_it == json.end()) { - return absl::InvalidArgumentError("`escapedChar` is undefined."); - } - const nlohmann::json& json_escaped_char = escaped_char_it.value(); - - if (json_escaped_char.is_null()) { - return absl::InvalidArgumentError("json_escaped_char is null."); - } - if (!json_escaped_char.is_string()) { - return absl::InvalidArgumentError("`json_escaped_char` expected to be a string."); - } - std::string json_escaped_char_str = json_escaped_char.get(); - return StringToEEscapedChar(json_escaped_char_str); + return GetRequiredField( + json, + "escapedChar", + Enum(StringToEEscapedChar) + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/enum/conversion/BUILD b/maldoca/astgen/test/enum/conversion/BUILD index cf1409b..311110d 100644 --- a/maldoca/astgen/test/enum/conversion/BUILD +++ b/maldoca/astgen/test/enum/conversion/BUILD @@ -46,6 +46,7 @@ cc_library( srcs = ["eir_to_ast.generated.cc"], hdrs = ["eir_to_ast.h"], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/astgen/test/enum:ast", "//maldoca/astgen/test/enum:ir", "//maldoca/base:status", diff --git a/maldoca/astgen/test/enum/conversion/ast_to_eir.generated.cc b/maldoca/astgen/test/enum/conversion/ast_to_eir.generated.cc index 18aba2a..c094ccf 100644 --- a/maldoca/astgen/test/enum/conversion/ast_to_eir.generated.cc +++ b/maldoca/astgen/test/enum/conversion/ast_to_eir.generated.cc @@ -45,10 +45,10 @@ namespace maldoca { -EirNodeOp AstToEir::VisitNode(const ENode *node) { - mlir::StringAttr mlir_unary_operator = builder_.getStringAttr(EUnaryOperatorToString(node->unary_operator())); - mlir::StringAttr mlir_escaped_char = builder_.getStringAttr(EEscapedCharToString(node->escaped_char())); - return CreateExpr(node, mlir_unary_operator, mlir_escaped_char); +EirNodeOp AstToEir::VisitNode(mlir::OpBuilder &builder, const ENode *node) { + mlir::StringAttr mlir_unary_operator = builder.getStringAttr(EUnaryOperatorToString(node->unary_operator())); + mlir::StringAttr mlir_escaped_char = builder.getStringAttr(EEscapedCharToString(node->escaped_char())); + return CreateExpr(builder, node, mlir_unary_operator, mlir_escaped_char); } // clang-format on diff --git a/maldoca/astgen/test/enum/conversion/ast_to_eir.h b/maldoca/astgen/test/enum/conversion/ast_to_eir.h index 9f6d6c4..f715cff 100644 --- a/maldoca/astgen/test/enum/conversion/ast_to_eir.h +++ b/maldoca/astgen/test/enum/conversion/ast_to_eir.h @@ -23,19 +23,16 @@ namespace maldoca { class AstToEir { public: - explicit AstToEir(mlir::OpBuilder &builder) : builder_(builder) {} - - EirNodeOp VisitNode(const ENode *node); + static EirNodeOp VisitNode(mlir::OpBuilder& builder, const ENode* node); private: template - Op CreateExpr(const Node *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - EirAnyType::get(builder_.getContext()), - std::forward(args)...); + static Op CreateExpr(mlir::OpBuilder& builder, const Node* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + EirAnyType::get(builder.getContext()), + std::forward(args)...); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/enum/conversion/conversion_test.cc b/maldoca/astgen/test/enum/conversion/conversion_test.cc index 7ad6ad2..2b53bc3 100644 --- a/maldoca/astgen/test/enum/conversion/conversion_test.cc +++ b/maldoca/astgen/test/enum/conversion/conversion_test.cc @@ -36,7 +36,7 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, .ast_to_ir_visit = &AstToEir::VisitNode, .ir_to_ast_visit = &EirToAst::VisitNode, diff --git a/maldoca/astgen/test/enum/conversion/eir_to_ast.generated.cc b/maldoca/astgen/test/enum/conversion/eir_to_ast.generated.cc index b4e7630..31e18ee 100644 --- a/maldoca/astgen/test/enum/conversion/eir_to_ast.generated.cc +++ b/maldoca/astgen/test/enum/conversion/eir_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/astgen/test/enum/ast.generated.h" #include "maldoca/astgen/test/enum/ir.h" @@ -56,8 +57,20 @@ namespace maldoca { absl::StatusOr> EirToAst::VisitNode(EirNodeOp op) { - MALDOCA_ASSIGN_OR_RETURN(EUnaryOperator unary_operator, StringToEUnaryOperator(op.getUnaryOperatorAttr().str())); - MALDOCA_ASSIGN_OR_RETURN(EEscapedChar escaped_char, StringToEEscapedChar(op.getEscapedCharAttr().str())); + MALDOCA_ASSIGN_OR_RETURN( + auto unary_operator, + Convert( + op.getUnaryOperatorAttr(), + Enum(StringToEUnaryOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto escaped_char, + Convert( + op.getEscapedCharAttr(), + Enum(StringToEEscapedChar) + ) + ); return Create( op, std::move(unary_operator), diff --git a/maldoca/astgen/test/enum/conversion/eir_to_ast.h b/maldoca/astgen/test/enum/conversion/eir_to_ast.h index 0a45e5f..00b4d23 100644 --- a/maldoca/astgen/test/enum/conversion/eir_to_ast.h +++ b/maldoca/astgen/test/enum/conversion/eir_to_ast.h @@ -26,10 +26,10 @@ namespace maldoca { class EirToAst { public: - absl::StatusOr> VisitNode(EirNodeOp op); + static absl::StatusOr> VisitNode(EirNodeOp op); template - std::unique_ptr Create(mlir::Operation *op, Args &&...args) { + static std::unique_ptr Create(mlir::Operation *op, Args &&...args) { return absl::make_unique(std::forward(args)...); } }; diff --git a/maldoca/astgen/test/lambda/BUILD b/maldoca/astgen/test/lambda/BUILD index 9023956..8f12d17 100644 --- a/maldoca/astgen/test/lambda/BUILD +++ b/maldoca/astgen/test/lambda/BUILD @@ -53,6 +53,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/astgen/test/lambda/ast_from_json.generated.cc b/maldoca/astgen/test/lambda/ast_from_json.generated.cc index 1e2902e..d5e3c96 100644 --- a/maldoca/astgen/test/lambda/ast_from_json.generated.cc +++ b/maldoca/astgen/test/lambda/ast_from_json.generated.cc @@ -35,26 +35,12 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // LaExpression // ============================================================================= @@ -83,19 +69,11 @@ LaExpression::FromJson(const nlohmann::json& json) { absl::StatusOr LaVariable::GetIdentifier(const nlohmann::json& json) { - auto identifier_it = json.find("identifier"); - if (identifier_it == json.end()) { - return absl::InvalidArgumentError("`identifier` is undefined."); - } - const nlohmann::json& json_identifier = identifier_it.value(); - - if (json_identifier.is_null()) { - return absl::InvalidArgumentError("json_identifier is null."); - } - if (!json_identifier.is_string()) { - return absl::InvalidArgumentError("Expecting json_identifier.is_string()."); - } - return json_identifier.get(); + return GetRequiredField( + json, + "identifier", + JsonToString + ); } absl::StatusOr> @@ -116,30 +94,20 @@ LaVariable::FromJson(const nlohmann::json& json) { absl::StatusOr> LaFunctionDefinition::GetParameter(const nlohmann::json& json) { - auto parameter_it = json.find("parameter"); - if (parameter_it == json.end()) { - return absl::InvalidArgumentError("`parameter` is undefined."); - } - const nlohmann::json& json_parameter = parameter_it.value(); - - if (json_parameter.is_null()) { - return absl::InvalidArgumentError("json_parameter is null."); - } - return LaVariable::FromJson(json_parameter); + return GetRequiredField>( + json, + "parameter", + LaVariable::FromJson + ); } absl::StatusOr> LaFunctionDefinition::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return LaExpression::FromJson(json_body); + return GetRequiredField>( + json, + "body", + LaExpression::FromJson + ); } absl::StatusOr> @@ -162,30 +130,20 @@ LaFunctionDefinition::FromJson(const nlohmann::json& json) { absl::StatusOr> LaFunctionCall::GetFunction(const nlohmann::json& json) { - auto function_it = json.find("function"); - if (function_it == json.end()) { - return absl::InvalidArgumentError("`function` is undefined."); - } - const nlohmann::json& json_function = function_it.value(); - - if (json_function.is_null()) { - return absl::InvalidArgumentError("json_function is null."); - } - return LaExpression::FromJson(json_function); + return GetRequiredField>( + json, + "function", + LaExpression::FromJson + ); } absl::StatusOr> LaFunctionCall::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return LaExpression::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + LaExpression::FromJson + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/lambda/conversion/ast_to_lair.generated.cc b/maldoca/astgen/test/lambda/conversion/ast_to_lair.generated.cc index e99e573..268cbeb 100644 --- a/maldoca/astgen/test/lambda/conversion/ast_to_lair.generated.cc +++ b/maldoca/astgen/test/lambda/conversion/ast_to_lair.generated.cc @@ -45,48 +45,48 @@ namespace maldoca { -LairExpressionOpInterface AstToLair::VisitExpression(const LaExpression *node) { +LairExpressionOpInterface AstToLair::VisitExpression(mlir::OpBuilder &builder, const LaExpression *node) { if (auto *variable = dynamic_cast(node)) { - return VisitVariable(variable); + return VisitVariable(builder, variable); } if (auto *function_definition = dynamic_cast(node)) { - return VisitFunctionDefinition(function_definition); + return VisitFunctionDefinition(builder, function_definition); } if (auto *function_call = dynamic_cast(node)) { - return VisitFunctionCall(function_call); + return VisitFunctionCall(builder, function_call); } LOG(FATAL) << "Unreachable code."; } -LairVariableOp AstToLair::VisitVariable(const LaVariable *node) { - mlir::StringAttr mlir_identifier = builder_.getStringAttr(node->identifier()); - return CreateExpr(node, mlir_identifier); +LairVariableOp AstToLair::VisitVariable(mlir::OpBuilder &builder, const LaVariable *node) { + mlir::StringAttr mlir_identifier = builder.getStringAttr(node->identifier()); + return CreateExpr(builder, node, mlir_identifier); } -LairVariableRefOp AstToLair::VisitVariableRef(const LaVariable *node) { - mlir::StringAttr mlir_identifier = builder_.getStringAttr(node->identifier()); - return CreateExpr(node, mlir_identifier); +LairVariableRefOp AstToLair::VisitVariableRef(mlir::OpBuilder &builder, const LaVariable *node) { + mlir::StringAttr mlir_identifier = builder.getStringAttr(node->identifier()); + return CreateExpr(builder, node, mlir_identifier); } -LairFunctionDefinitionOp AstToLair::VisitFunctionDefinition(const LaFunctionDefinition *node) { - auto op = CreateExpr(node); +LairFunctionDefinitionOp AstToLair::VisitFunctionDefinition(mlir::OpBuilder &builder, const LaFunctionDefinition *node) { + auto op = CreateExpr(builder, node); mlir::Region &mlir_parameter_region = op.getParameter(); - AppendNewBlockAndPopulate(mlir_parameter_region, [&] { - mlir::Value mlir_parameter = VisitVariableRef(node->parameter()); - CreateStmt(node, mlir_parameter); + AppendNewBlockAndPopulate(builder, mlir_parameter_region, [&] { + mlir::Value mlir_parameter = VisitVariableRef(builder, node->parameter()); + CreateStmt(builder, nullptr, mlir_parameter); }); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - mlir::Value mlir_body = VisitExpression(node->body()); - CreateStmt(node, mlir_body); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + mlir::Value mlir_body = VisitExpression(builder, node->body()); + CreateStmt(builder, nullptr, mlir_body); }); return op; } -LairFunctionCallOp AstToLair::VisitFunctionCall(const LaFunctionCall *node) { - mlir::Value mlir_function = VisitExpression(node->function()); - mlir::Value mlir_argument = VisitExpression(node->argument()); - return CreateExpr(node, mlir_function, mlir_argument); +LairFunctionCallOp AstToLair::VisitFunctionCall(mlir::OpBuilder &builder, const LaFunctionCall *node) { + mlir::Value mlir_function = VisitExpression(builder, node->function()); + mlir::Value mlir_argument = VisitExpression(builder, node->argument()); + return CreateExpr(builder, node, mlir_function, mlir_argument); } // clang-format on diff --git a/maldoca/astgen/test/lambda/conversion/ast_to_lair.h b/maldoca/astgen/test/lambda/conversion/ast_to_lair.h index a374a36..d6600df 100644 --- a/maldoca/astgen/test/lambda/conversion/ast_to_lair.h +++ b/maldoca/astgen/test/lambda/conversion/ast_to_lair.h @@ -2,10 +2,10 @@ #define MALDOCA_ASTGEN_TEST_LAMBDA_CONVERSION_AST_TO_LAIR_H_ #include -#include #include "mlir/IR/Builders.h" -#include "absl/cleanup/cleanup.h" +#include "mlir/IR/Block.h" +#include "mlir/IR/Region.h" #include "maldoca/astgen/test/lambda/ast.generated.h" #include "maldoca/astgen/test/lambda/ir.h" @@ -13,46 +13,49 @@ namespace maldoca { class AstToLair { public: - explicit AstToLair(mlir::OpBuilder &builder) : builder_(builder) {} + static LairExpressionOpInterface VisitExpression(mlir::OpBuilder& builder, + const LaExpression* node); - LairExpressionOpInterface VisitExpression(const LaExpression *node); + static LairVariableOp VisitVariable(mlir::OpBuilder& builder, + const LaVariable* node); - LairVariableOp VisitVariable(const LaVariable *node); + static LairVariableRefOp VisitVariableRef(mlir::OpBuilder& builder, + const LaVariable* node); - LairVariableRefOp VisitVariableRef(const LaVariable *node); + static LairFunctionDefinitionOp VisitFunctionDefinition( + mlir::OpBuilder& builder, const LaFunctionDefinition* node); - LairFunctionDefinitionOp VisitFunctionDefinition( - const LaFunctionDefinition *node); - - LairFunctionCallOp VisitFunctionCall(const LaFunctionCall *node); + static LairFunctionCallOp VisitFunctionCall(mlir::OpBuilder& builder, + const LaFunctionCall* node); private: - template - Op CreateExpr(const JsNode *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + template + static Op CreateExpr(mlir::OpBuilder& builder, const void* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } - template - Op CreateStmt(const JsNode *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), mlir::TypeRange(), - std::forward(args)...); + template + static Op CreateStmt(mlir::OpBuilder& builder, const void* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), mlir::TypeRange(), + std::forward(args)...); } - void AppendNewBlockAndPopulate(mlir::Region ®ion, - std::function populate) { + static void AppendNewBlockAndPopulate(mlir::OpBuilder& builder, + mlir::Region& region, + std::function populate) { // Save insertion point. // Will revert at the end. - mlir::OpBuilder::InsertionGuard insertion_guard(builder_); + mlir::OpBuilder::InsertionGuard insertion_guard(builder); // Insert new block and point builder to it. - mlir::Block &block = region.emplaceBlock(); - builder_.setInsertionPointToStart(&block); + mlir::Block& block = region.emplaceBlock(); + builder.setInsertionPointToStart(&block); populate(); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/lambda/conversion/conversion_test.cc b/maldoca/astgen/test/lambda/conversion/conversion_test.cc index 05586a5..80ed6f4 100644 --- a/maldoca/astgen/test/lambda/conversion/conversion_test.cc +++ b/maldoca/astgen/test/lambda/conversion/conversion_test.cc @@ -52,7 +52,7 @@ module { TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLair::VisitFunctionDefinition, + .ast_to_ir_visit = AstToLair::VisitFunctionDefinition, .expected_ir_dump = kExpectedIrDump, }); } @@ -96,7 +96,7 @@ module { TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLair::VisitFunctionCall, + .ast_to_ir_visit = AstToLair::VisitFunctionCall, .expected_ir_dump = kExpectedIrDump, }); } diff --git a/maldoca/astgen/test/list/BUILD b/maldoca/astgen/test/list/BUILD index d21e963..0148443 100644 --- a/maldoca/astgen/test/list/BUILD +++ b/maldoca/astgen/test/list/BUILD @@ -54,6 +54,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", @@ -174,12 +175,7 @@ cc_library( ":liir_ops_inc_gen", ":liir_types_inc_gen", "@llvm-project//llvm:Support", - "@llvm-project//mlir:Analysis", - "@llvm-project//mlir:ControlFlowInterfaces", "@llvm-project//mlir:IR", "@llvm-project//mlir:InferTypeOpInterface", - "@llvm-project//mlir:Parser", - "@llvm-project//mlir:SideEffectInterfaces", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/list/ast_from_json.generated.cc b/maldoca/astgen/test/list/ast_from_json.generated.cc index 2a48abb..f3414b1 100644 --- a/maldoca/astgen/test/list/ast_from_json.generated.cc +++ b/maldoca/astgen/test/list/ast_from_json.generated.cc @@ -35,6 +35,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" @@ -90,57 +91,24 @@ LiClass2::FromJson(const nlohmann::json& json) { absl::StatusOr> LiSimpleList::GetStrings(const nlohmann::json& json) { - auto strings_it = json.find("strings"); - if (strings_it == json.end()) { - return absl::InvalidArgumentError("`strings` is undefined."); - } - const nlohmann::json& json_strings = strings_it.value(); - - if (json_strings.is_null()) { - return absl::InvalidArgumentError("json_strings is null."); - } - if (!json_strings.is_array()) { - return absl::InvalidArgumentError("json_strings expected to be array."); - } - - std::vector strings; - for (const nlohmann::json& json_strings_element : json_strings) { - if (json_strings_element.is_null()) { - return absl::InvalidArgumentError("json_strings_element is null."); - } - if (!json_strings_element.is_string()) { - return absl::InvalidArgumentError("Expecting json_strings_element.is_string()."); - } - auto strings_element = json_strings_element.get(); - strings.push_back(std::move(strings_element)); - } - return strings; + return GetRequiredField>( + json, + "strings", + List( + JsonToString + ) + ); } absl::StatusOr>> LiSimpleList::GetOperations(const nlohmann::json& json) { - auto operations_it = json.find("operations"); - if (operations_it == json.end()) { - return absl::InvalidArgumentError("`operations` is undefined."); - } - const nlohmann::json& json_operations = operations_it.value(); - - if (json_operations.is_null()) { - return absl::InvalidArgumentError("json_operations is null."); - } - if (!json_operations.is_array()) { - return absl::InvalidArgumentError("json_operations expected to be array."); - } - - std::vector> operations; - for (const nlohmann::json& json_operations_element : json_operations) { - if (json_operations_element.is_null()) { - return absl::InvalidArgumentError("json_operations_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto operations_element, LiClass1::FromJson(json_operations_element)); - operations.push_back(std::move(operations_element)); - } - return operations; + return GetRequiredField>>( + json, + "operations", + List>( + LiClass1::FromJson + ) + ); } absl::StatusOr> @@ -163,31 +131,13 @@ LiSimpleList::FromJson(const nlohmann::json& json) { absl::StatusOr>> LiOptionalList::GetStrings(const nlohmann::json& json) { - auto strings_it = json.find("strings"); - if (strings_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_strings = strings_it.value(); - - if (json_strings.is_null()) { - return absl::InvalidArgumentError("json_strings is null."); - } - if (!json_strings.is_array()) { - return absl::InvalidArgumentError("json_strings expected to be array."); - } - - std::vector strings; - for (const nlohmann::json& json_strings_element : json_strings) { - if (json_strings_element.is_null()) { - return absl::InvalidArgumentError("json_strings_element is null."); - } - if (!json_strings_element.is_string()) { - return absl::InvalidArgumentError("Expecting json_strings_element.is_string()."); - } - auto strings_element = json_strings_element.get(); - strings.push_back(std::move(strings_element)); - } - return strings; + return GetOptionalField>( + json, + "strings", + List( + JsonToString + ) + ); } absl::StatusOr> @@ -208,57 +158,28 @@ LiOptionalList::FromJson(const nlohmann::json& json) { absl::StatusOr>> LiListOfOptional::GetStrings(const nlohmann::json& json) { - auto strings_it = json.find("strings"); - if (strings_it == json.end()) { - return absl::InvalidArgumentError("`strings` is undefined."); - } - const nlohmann::json& json_strings = strings_it.value(); - - if (json_strings.is_null()) { - return absl::InvalidArgumentError("json_strings is null."); - } - if (!json_strings.is_array()) { - return absl::InvalidArgumentError("json_strings expected to be array."); - } - - std::vector> strings; - for (const nlohmann::json& json_strings_element : json_strings) { - std::optional strings_element; - if (!json_strings_element.is_null()) { - if (!json_strings_element.is_string()) { - return absl::InvalidArgumentError("Expecting json_strings_element.is_string()."); - } - strings_element = json_strings_element.get(); - } - strings.push_back(std::move(strings_element)); - } - return strings; + return GetRequiredField>>( + json, + "strings", + List>( + Nullable( + JsonToString + ) + ) + ); } absl::StatusOr>>> LiListOfOptional::GetOperations(const nlohmann::json& json) { - auto operations_it = json.find("operations"); - if (operations_it == json.end()) { - return absl::InvalidArgumentError("`operations` is undefined."); - } - const nlohmann::json& json_operations = operations_it.value(); - - if (json_operations.is_null()) { - return absl::InvalidArgumentError("json_operations is null."); - } - if (!json_operations.is_array()) { - return absl::InvalidArgumentError("json_operations expected to be array."); - } - - std::vector>> operations; - for (const nlohmann::json& json_operations_element : json_operations) { - std::optional> operations_element; - if (!json_operations_element.is_null()) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, LiClass1::FromJson(json_operations_element)); - } - operations.push_back(std::move(operations_element)); - } - return operations; + return GetRequiredField>>>( + json, + "operations", + List>>( + Nullable>( + LiClass1::FromJson + ) + ) + ); } absl::StatusOr> @@ -281,74 +202,40 @@ LiListOfOptional::FromJson(const nlohmann::json& json) { absl::StatusOr>> LiListOfVariant::GetVariants(const nlohmann::json& json) { - auto variants_it = json.find("variants"); - if (variants_it == json.end()) { - return absl::InvalidArgumentError("`variants` is undefined."); - } - const nlohmann::json& json_variants = variants_it.value(); - - if (json_variants.is_null()) { - return absl::InvalidArgumentError("json_variants is null."); - } - if (!json_variants.is_array()) { - return absl::InvalidArgumentError("json_variants expected to be array."); - } - - std::vector> variants; - for (const nlohmann::json& json_variants_element : json_variants) { - if (json_variants_element.is_null()) { - return absl::InvalidArgumentError("json_variants_element is null."); - } - std::variant variants_element; - if (json_variants_element.is_boolean()) { - variants_element = json_variants_element.get(); - } else if (json_variants_element.is_string()) { - variants_element = json_variants_element.get(); - } else { - auto result = absl::InvalidArgumentError("json_variants_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_variants_element.dump()}); - return result; - } - variants.push_back(std::move(variants_element)); - } - return variants; + return GetRequiredField>>( + json, + "variants", + List>( + Variant( + VariantOption{ + .predicate = IsBool, + .converter = JsonToBool, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ) + ); } absl::StatusOr, std::unique_ptr>>> LiListOfVariant::GetOperations(const nlohmann::json& json) { - auto operations_it = json.find("operations"); - if (operations_it == json.end()) { - return absl::InvalidArgumentError("`operations` is undefined."); - } - const nlohmann::json& json_operations = operations_it.value(); - - if (json_operations.is_null()) { - return absl::InvalidArgumentError("json_operations is null."); - } - if (!json_operations.is_array()) { - return absl::InvalidArgumentError("json_operations expected to be array."); - } - - std::vector, std::unique_ptr>> operations; - for (const nlohmann::json& json_operations_element : json_operations) { - if (json_operations_element.is_null()) { - return absl::InvalidArgumentError("json_operations_element is null."); - } - std::variant, std::unique_ptr> operations_element; - if (IsClass1(json_operations_element)) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, LiClass1::FromJson(json_operations_element)); - } else if (IsClass2(json_operations_element)) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, LiClass2::FromJson(json_operations_element)); - } else { - auto result = absl::InvalidArgumentError("json_operations_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_operations_element.dump()}); - return result; - } - operations.push_back(std::move(operations_element)); - } - return operations; + return GetRequiredField, std::unique_ptr>>>( + json, + "operations", + List, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsClass1, + .converter = LiClass1::FromJson, + }, + VariantOption>{ + .predicate = IsClass2, + .converter = LiClass2::FromJson, + }) + ) + ); } absl::StatusOr> @@ -371,31 +258,15 @@ LiListOfVariant::FromJson(const nlohmann::json& json) { absl::StatusOr>>> LiOptionalListOfOptional::GetVariants(const nlohmann::json& json) { - auto variants_it = json.find("variants"); - if (variants_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_variants = variants_it.value(); - - if (json_variants.is_null()) { - return absl::InvalidArgumentError("json_variants is null."); - } - if (!json_variants.is_array()) { - return absl::InvalidArgumentError("json_variants expected to be array."); - } - - std::vector> variants; - for (const nlohmann::json& json_variants_element : json_variants) { - std::optional variants_element; - if (!json_variants_element.is_null()) { - if (!json_variants_element.is_string()) { - return absl::InvalidArgumentError("Expecting json_variants_element.is_string()."); - } - variants_element = json_variants_element.get(); - } - variants.push_back(std::move(variants_element)); - } - return variants; + return GetOptionalField>>( + json, + "variants", + List>( + Nullable( + JsonToString + ) + ) + ); } absl::StatusOr> @@ -416,38 +287,21 @@ LiOptionalListOfOptional::FromJson(const nlohmann::json& json) { absl::StatusOr>>> LiOptionalListOfVariant::GetVariants(const nlohmann::json& json) { - auto variants_it = json.find("variants"); - if (variants_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_variants = variants_it.value(); - - if (json_variants.is_null()) { - return absl::InvalidArgumentError("json_variants is null."); - } - if (!json_variants.is_array()) { - return absl::InvalidArgumentError("json_variants expected to be array."); - } - - std::vector> variants; - for (const nlohmann::json& json_variants_element : json_variants) { - if (json_variants_element.is_null()) { - return absl::InvalidArgumentError("json_variants_element is null."); - } - std::variant variants_element; - if (json_variants_element.is_boolean()) { - variants_element = json_variants_element.get(); - } else if (json_variants_element.is_string()) { - variants_element = json_variants_element.get(); - } else { - auto result = absl::InvalidArgumentError("json_variants_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_variants_element.dump()}); - return result; - } - variants.push_back(std::move(variants_element)); - } - return variants; + return GetOptionalField>>( + json, + "variants", + List>( + Variant( + VariantOption{ + .predicate = IsBool, + .converter = JsonToBool, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ) + ); } absl::StatusOr> @@ -468,72 +322,44 @@ LiOptionalListOfVariant::FromJson(const nlohmann::json& json) { absl::StatusOr>>> LiListOfOptionalVariant::GetVariants(const nlohmann::json& json) { - auto variants_it = json.find("variants"); - if (variants_it == json.end()) { - return absl::InvalidArgumentError("`variants` is undefined."); - } - const nlohmann::json& json_variants = variants_it.value(); - - if (json_variants.is_null()) { - return absl::InvalidArgumentError("json_variants is null."); - } - if (!json_variants.is_array()) { - return absl::InvalidArgumentError("json_variants expected to be array."); - } - - std::vector>> variants; - for (const nlohmann::json& json_variants_element : json_variants) { - std::optional> variants_element; - if (!json_variants_element.is_null()) { - if (json_variants_element.is_boolean()) { - variants_element = json_variants_element.get(); - } else if (json_variants_element.is_string()) { - variants_element = json_variants_element.get(); - } else { - auto result = absl::InvalidArgumentError("json_variants_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_variants_element.dump()}); - return result; - } - } - variants.push_back(std::move(variants_element)); - } - return variants; + return GetRequiredField>>>( + json, + "variants", + List>>( + Nullable>( + Variant( + VariantOption{ + .predicate = IsBool, + .converter = JsonToBool, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ) + ) + ); } absl::StatusOr, std::unique_ptr>>>> LiListOfOptionalVariant::GetOperations(const nlohmann::json& json) { - auto operations_it = json.find("operations"); - if (operations_it == json.end()) { - return absl::InvalidArgumentError("`operations` is undefined."); - } - const nlohmann::json& json_operations = operations_it.value(); - - if (json_operations.is_null()) { - return absl::InvalidArgumentError("json_operations is null."); - } - if (!json_operations.is_array()) { - return absl::InvalidArgumentError("json_operations expected to be array."); - } - - std::vector, std::unique_ptr>>> operations; - for (const nlohmann::json& json_operations_element : json_operations) { - std::optional, std::unique_ptr>> operations_element; - if (!json_operations_element.is_null()) { - if (IsClass1(json_operations_element)) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, LiClass1::FromJson(json_operations_element)); - } else if (IsClass2(json_operations_element)) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, LiClass2::FromJson(json_operations_element)); - } else { - auto result = absl::InvalidArgumentError("json_operations_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_operations_element.dump()}); - return result; - } - } - operations.push_back(std::move(operations_element)); - } - return operations; + return GetRequiredField, std::unique_ptr>>>>( + json, + "operations", + List, std::unique_ptr>>>( + Nullable, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsClass1, + .converter = LiClass1::FromJson, + }, + VariantOption>{ + .predicate = IsClass2, + .converter = LiClass2::FromJson, + }) + ) + ) + ); } absl::StatusOr> @@ -556,37 +382,23 @@ LiListOfOptionalVariant::FromJson(const nlohmann::json& json) { absl::StatusOr>>>> LiOptionalListOfOptionalVariant::GetVariants(const nlohmann::json& json) { - auto variants_it = json.find("variants"); - if (variants_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_variants = variants_it.value(); - - if (json_variants.is_null()) { - return absl::InvalidArgumentError("json_variants is null."); - } - if (!json_variants.is_array()) { - return absl::InvalidArgumentError("json_variants expected to be array."); - } - - std::vector>> variants; - for (const nlohmann::json& json_variants_element : json_variants) { - std::optional> variants_element; - if (!json_variants_element.is_null()) { - if (json_variants_element.is_boolean()) { - variants_element = json_variants_element.get(); - } else if (json_variants_element.is_string()) { - variants_element = json_variants_element.get(); - } else { - auto result = absl::InvalidArgumentError("json_variants_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_variants_element.dump()}); - return result; - } - } - variants.push_back(std::move(variants_element)); - } - return variants; + return GetOptionalField>>>( + json, + "variants", + List>>( + Nullable>( + Variant( + VariantOption{ + .predicate = IsBool, + .converter = JsonToBool, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ) + ) + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/list/conversion/BUILD b/maldoca/astgen/test/list/conversion/BUILD index 9a4e1a9..065b692 100644 --- a/maldoca/astgen/test/list/conversion/BUILD +++ b/maldoca/astgen/test/list/conversion/BUILD @@ -46,6 +46,7 @@ cc_library( srcs = ["liir_to_ast.generated.cc"], hdrs = ["liir_to_ast.h"], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/astgen/test/list:ast", "//maldoca/astgen/test/list:ir", "//maldoca/base:status", @@ -59,7 +60,6 @@ cc_library( "@abseil-cpp//absl/types:variant", "@llvm-project//llvm:Support", "@llvm-project//mlir:IR", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/list/conversion/ast_to_liir.generated.cc b/maldoca/astgen/test/list/conversion/ast_to_liir.generated.cc index db647d9..922e048 100644 --- a/maldoca/astgen/test/list/conversion/ast_to_liir.generated.cc +++ b/maldoca/astgen/test/list/conversion/ast_to_liir.generated.cc @@ -45,76 +45,76 @@ namespace maldoca { -LiirClass1Op AstToLiir::VisitClass1(const LiClass1 *node) { - return CreateExpr(node); +LiirClass1Op AstToLiir::VisitClass1(mlir::OpBuilder &builder, const LiClass1 *node) { + return CreateExpr(builder, node); } -LiirClass2Op AstToLiir::VisitClass2(const LiClass2 *node) { - return CreateExpr(node); +LiirClass2Op AstToLiir::VisitClass2(mlir::OpBuilder &builder, const LiClass2 *node) { + return CreateExpr(builder, node); } -LiirSimpleListOp AstToLiir::VisitSimpleList(const LiSimpleList *node) { +LiirSimpleListOp AstToLiir::VisitSimpleList(mlir::OpBuilder &builder, const LiSimpleList *node) { std::vector mlir_strings_data; for (const auto &element : *node->strings()) { - mlir::StringAttr mlir_element = builder_.getStringAttr(element); + mlir::StringAttr mlir_element = builder.getStringAttr(element); mlir_strings_data.push_back(std::move(mlir_element)); } - auto mlir_strings = builder_.getArrayAttr(mlir_strings_data); + auto mlir_strings = builder.getArrayAttr(mlir_strings_data); std::vector mlir_operations; for (const auto &element : *node->operations()) { - mlir::Value mlir_element = VisitClass1(element.get()); + mlir::Value mlir_element = VisitClass1(builder, element.get()); mlir_operations.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_strings, mlir_operations); + return CreateExpr(builder, node, mlir_strings, mlir_operations); } -LiirOptionalListOp AstToLiir::VisitOptionalList(const LiOptionalList *node) { +LiirOptionalListOp AstToLiir::VisitOptionalList(mlir::OpBuilder &builder, const LiOptionalList *node) { mlir::ArrayAttr mlir_strings; if (node->strings().has_value()) { std::vector mlir_strings_data; for (const auto &element : *node->strings().value()) { - mlir::StringAttr mlir_element = builder_.getStringAttr(element); + mlir::StringAttr mlir_element = builder.getStringAttr(element); mlir_strings_data.push_back(std::move(mlir_element)); } - mlir_strings = builder_.getArrayAttr(mlir_strings_data); + mlir_strings = builder.getArrayAttr(mlir_strings_data); } - return CreateExpr(node, mlir_strings); + return CreateExpr(builder, node, mlir_strings); } -LiirListOfOptionalOp AstToLiir::VisitListOfOptional(const LiListOfOptional *node) { +LiirListOfOptionalOp AstToLiir::VisitListOfOptional(mlir::OpBuilder &builder, const LiListOfOptional *node) { std::vector mlir_strings_data; for (const auto &element : *node->strings()) { mlir::StringAttr mlir_element; if (element.has_value()) { - mlir_element = builder_.getStringAttr(element.value()); + mlir_element = builder.getStringAttr(element.value()); } mlir_strings_data.push_back(std::move(mlir_element)); } - auto mlir_strings = builder_.getArrayAttr(mlir_strings_data); + auto mlir_strings = builder.getArrayAttr(mlir_strings_data); std::vector mlir_operations; for (const auto &element : *node->operations()) { mlir::Value mlir_element; if (element.has_value()) { - mlir_element = VisitClass1(element.value().get()); + mlir_element = VisitClass1(builder, element.value().get()); } else { - mlir_element = CreateExpr(node); + mlir_element = CreateExpr(builder, node); } mlir_operations.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_strings, mlir_operations); + return CreateExpr(builder, node, mlir_strings, mlir_operations); } -LiirListOfVariantOp AstToLiir::VisitListOfVariant(const LiListOfVariant *node) { +LiirListOfVariantOp AstToLiir::VisitListOfVariant(mlir::OpBuilder &builder, const LiListOfVariant *node) { std::vector mlir_variants_data; for (const auto &element : *node->variants()) { mlir::Attribute mlir_element; switch (element.index()) { case 0: { - mlir_element = builder_.getBoolAttr(std::get<0>(element)); + mlir_element = builder.getBoolAttr(std::get<0>(element)); break; } case 1: { - mlir_element = builder_.getStringAttr(std::get<1>(element)); + mlir_element = builder.getStringAttr(std::get<1>(element)); break; } default: @@ -122,17 +122,17 @@ LiirListOfVariantOp AstToLiir::VisitListOfVariant(const LiListOfVariant *node) { } mlir_variants_data.push_back(std::move(mlir_element)); } - auto mlir_variants = builder_.getArrayAttr(mlir_variants_data); + auto mlir_variants = builder.getArrayAttr(mlir_variants_data); std::vector mlir_operations; for (const auto &element : *node->operations()) { mlir::Value mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitClass1(std::get<0>(element).get()); + mlir_element = VisitClass1(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitClass2(std::get<1>(element).get()); + mlir_element = VisitClass2(builder, std::get<1>(element).get()); break; } default: @@ -140,26 +140,26 @@ LiirListOfVariantOp AstToLiir::VisitListOfVariant(const LiListOfVariant *node) { } mlir_operations.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_variants, mlir_operations); + return CreateExpr(builder, node, mlir_variants, mlir_operations); } -LiirOptionalListOfOptionalOp AstToLiir::VisitOptionalListOfOptional(const LiOptionalListOfOptional *node) { +LiirOptionalListOfOptionalOp AstToLiir::VisitOptionalListOfOptional(mlir::OpBuilder &builder, const LiOptionalListOfOptional *node) { mlir::ArrayAttr mlir_variants; if (node->variants().has_value()) { std::vector mlir_variants_data; for (const auto &element : *node->variants().value()) { mlir::StringAttr mlir_element; if (element.has_value()) { - mlir_element = builder_.getStringAttr(element.value()); + mlir_element = builder.getStringAttr(element.value()); } mlir_variants_data.push_back(std::move(mlir_element)); } - mlir_variants = builder_.getArrayAttr(mlir_variants_data); + mlir_variants = builder.getArrayAttr(mlir_variants_data); } - return CreateExpr(node, mlir_variants); + return CreateExpr(builder, node, mlir_variants); } -LiirOptionalListOfVariantOp AstToLiir::VisitOptionalListOfVariant(const LiOptionalListOfVariant *node) { +LiirOptionalListOfVariantOp AstToLiir::VisitOptionalListOfVariant(mlir::OpBuilder &builder, const LiOptionalListOfVariant *node) { mlir::ArrayAttr mlir_variants; if (node->variants().has_value()) { std::vector mlir_variants_data; @@ -167,11 +167,11 @@ LiirOptionalListOfVariantOp AstToLiir::VisitOptionalListOfVariant(const LiOption mlir::Attribute mlir_element; switch (element.index()) { case 0: { - mlir_element = builder_.getBoolAttr(std::get<0>(element)); + mlir_element = builder.getBoolAttr(std::get<0>(element)); break; } case 1: { - mlir_element = builder_.getStringAttr(std::get<1>(element)); + mlir_element = builder.getStringAttr(std::get<1>(element)); break; } default: @@ -179,23 +179,23 @@ LiirOptionalListOfVariantOp AstToLiir::VisitOptionalListOfVariant(const LiOption } mlir_variants_data.push_back(std::move(mlir_element)); } - mlir_variants = builder_.getArrayAttr(mlir_variants_data); + mlir_variants = builder.getArrayAttr(mlir_variants_data); } - return CreateExpr(node, mlir_variants); + return CreateExpr(builder, node, mlir_variants); } -LiirListOfOptionalVariantOp AstToLiir::VisitListOfOptionalVariant(const LiListOfOptionalVariant *node) { +LiirListOfOptionalVariantOp AstToLiir::VisitListOfOptionalVariant(mlir::OpBuilder &builder, const LiListOfOptionalVariant *node) { std::vector mlir_variants_data; for (const auto &element : *node->variants()) { mlir::Attribute mlir_element; if (element.has_value()) { switch (element.value().index()) { case 0: { - mlir_element = builder_.getBoolAttr(std::get<0>(element.value())); + mlir_element = builder.getBoolAttr(std::get<0>(element.value())); break; } case 1: { - mlir_element = builder_.getStringAttr(std::get<1>(element.value())); + mlir_element = builder.getStringAttr(std::get<1>(element.value())); break; } default: @@ -204,32 +204,32 @@ LiirListOfOptionalVariantOp AstToLiir::VisitListOfOptionalVariant(const LiListOf } mlir_variants_data.push_back(std::move(mlir_element)); } - auto mlir_variants = builder_.getArrayAttr(mlir_variants_data); + auto mlir_variants = builder.getArrayAttr(mlir_variants_data); std::vector mlir_operations; for (const auto &element : *node->operations()) { mlir::Value mlir_element; if (element.has_value()) { switch (element.value().index()) { case 0: { - mlir_element = VisitClass1(std::get<0>(element.value()).get()); + mlir_element = VisitClass1(builder, std::get<0>(element.value()).get()); break; } case 1: { - mlir_element = VisitClass2(std::get<1>(element.value()).get()); + mlir_element = VisitClass2(builder, std::get<1>(element.value()).get()); break; } default: LOG(FATAL) << "Unreachable code."; } } else { - mlir_element = CreateExpr(node); + mlir_element = CreateExpr(builder, node); } mlir_operations.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_variants, mlir_operations); + return CreateExpr(builder, node, mlir_variants, mlir_operations); } -LiirOptionalListOfOptionalVariantOp AstToLiir::VisitOptionalListOfOptionalVariant(const LiOptionalListOfOptionalVariant *node) { +LiirOptionalListOfOptionalVariantOp AstToLiir::VisitOptionalListOfOptionalVariant(mlir::OpBuilder &builder, const LiOptionalListOfOptionalVariant *node) { mlir::ArrayAttr mlir_variants; if (node->variants().has_value()) { std::vector mlir_variants_data; @@ -238,11 +238,11 @@ LiirOptionalListOfOptionalVariantOp AstToLiir::VisitOptionalListOfOptionalVarian if (element.has_value()) { switch (element.value().index()) { case 0: { - mlir_element = builder_.getBoolAttr(std::get<0>(element.value())); + mlir_element = builder.getBoolAttr(std::get<0>(element.value())); break; } case 1: { - mlir_element = builder_.getStringAttr(std::get<1>(element.value())); + mlir_element = builder.getStringAttr(std::get<1>(element.value())); break; } default: @@ -251,9 +251,9 @@ LiirOptionalListOfOptionalVariantOp AstToLiir::VisitOptionalListOfOptionalVarian } mlir_variants_data.push_back(std::move(mlir_element)); } - mlir_variants = builder_.getArrayAttr(mlir_variants_data); + mlir_variants = builder.getArrayAttr(mlir_variants_data); } - return CreateExpr(node, mlir_variants); + return CreateExpr(builder, node, mlir_variants); } // clang-format on diff --git a/maldoca/astgen/test/list/conversion/ast_to_liir.h b/maldoca/astgen/test/list/conversion/ast_to_liir.h index 570016d..8d81d81 100644 --- a/maldoca/astgen/test/list/conversion/ast_to_liir.h +++ b/maldoca/astgen/test/list/conversion/ast_to_liir.h @@ -23,40 +23,43 @@ namespace maldoca { class AstToLiir { public: - explicit AstToLiir(mlir::OpBuilder &builder) : builder_(builder) {} + static LiirClass1Op VisitClass1(mlir::OpBuilder& builder, + const LiClass1* node); - LiirClass1Op VisitClass1(const LiClass1 *node); + static LiirClass2Op VisitClass2(mlir::OpBuilder& builder, + const LiClass2* node); - LiirClass2Op VisitClass2(const LiClass2 *node); + static LiirSimpleListOp VisitSimpleList(mlir::OpBuilder& builder, + const LiSimpleList* node); - LiirSimpleListOp VisitSimpleList(const LiSimpleList *node); + static LiirOptionalListOp VisitOptionalList(mlir::OpBuilder& builder, + const LiOptionalList* node); - LiirOptionalListOp VisitOptionalList(const LiOptionalList *node); + static LiirListOfOptionalOp VisitListOfOptional(mlir::OpBuilder& builder, + const LiListOfOptional* node); - LiirListOfOptionalOp VisitListOfOptional(const LiListOfOptional *node); + static LiirListOfVariantOp VisitListOfVariant(mlir::OpBuilder& builder, + const LiListOfVariant* node); - LiirListOfVariantOp VisitListOfVariant(const LiListOfVariant *node); + static LiirOptionalListOfOptionalOp VisitOptionalListOfOptional( + mlir::OpBuilder& builder, const LiOptionalListOfOptional* node); - LiirOptionalListOfOptionalOp VisitOptionalListOfOptional( - const LiOptionalListOfOptional *node); + static LiirOptionalListOfVariantOp VisitOptionalListOfVariant( + mlir::OpBuilder& builder, const LiOptionalListOfVariant* node); - LiirOptionalListOfVariantOp VisitOptionalListOfVariant( - const LiOptionalListOfVariant *node); + static LiirListOfOptionalVariantOp VisitListOfOptionalVariant( + mlir::OpBuilder& builder, const LiListOfOptionalVariant* node); - LiirListOfOptionalVariantOp VisitListOfOptionalVariant( - const LiListOfOptionalVariant *node); - - LiirOptionalListOfOptionalVariantOp VisitOptionalListOfOptionalVariant( - const LiOptionalListOfOptionalVariant *node); + static LiirOptionalListOfOptionalVariantOp VisitOptionalListOfOptionalVariant( + mlir::OpBuilder& builder, const LiOptionalListOfOptionalVariant* node); private: template - Op CreateExpr(const Node *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + static Op CreateExpr(mlir::OpBuilder& builder, const Node* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/list/conversion/conversion_test.cc b/maldoca/astgen/test/list/conversion/conversion_test.cc index 073c790..bd20792 100644 --- a/maldoca/astgen/test/list/conversion/conversion_test.cc +++ b/maldoca/astgen/test/list/conversion/conversion_test.cc @@ -33,10 +33,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLiir::VisitOptionalList, + .ast_to_ir_visit = AstToLiir::VisitOptionalList, .ir_to_ast_visit = &LiirToAst::VisitOptionalList, .expected_ir_dump = kExpectedIr, }); @@ -58,10 +57,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLiir::VisitOptionalList, + .ast_to_ir_visit = AstToLiir::VisitOptionalList, .ir_to_ast_visit = &LiirToAst::VisitOptionalList, .expected_ir_dump = kExpectedIr, }); @@ -87,10 +85,10 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLiir::VisitListOfVariant, + .ast_to_ir_visit = AstToLiir::VisitListOfVariant, .ir_to_ast_visit = &LiirToAst::VisitListOfVariant, .expected_ir_dump = kExpectedIr, }); @@ -115,9 +113,9 @@ TEST(ConversionTest, DISABLED_ListOfOptional) { )"; TestIrConversion({ + AstToLiir>({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToLiir::VisitListOfOptional, + .ast_to_ir_visit = AstToLiir::VisitListOfOptional, .ir_to_ast_visit = &LiirToAst::VisitListOfOptional, .expected_ir_dump = kExpectedIr, }); diff --git a/maldoca/astgen/test/list/conversion/liir_to_ast.generated.cc b/maldoca/astgen/test/list/conversion/liir_to_ast.generated.cc index 9490a9d..e79bfe4 100644 --- a/maldoca/astgen/test/list/conversion/liir_to_ast.generated.cc +++ b/maldoca/astgen/test/list/conversion/liir_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/astgen/test/list/ast.generated.h" #include "maldoca/astgen/test/list/ir.h" @@ -68,26 +69,24 @@ LiirToAst::VisitClass2(LiirClass2Op op) { absl::StatusOr> LiirToAst::VisitSimpleList(LiirSimpleListOp op) { - std::vector strings; - for (mlir::Attribute mlir_strings_element_unchecked : op.getStringsAttr().getValue()) { - auto strings_element_attr = llvm::dyn_cast(mlir_strings_element_unchecked); - if (strings_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - std::string strings_element = strings_element_attr.str(); - strings.push_back(std::move(strings_element)); - } - std::vector> operations; - for (mlir::Value mlir_operations_element_unchecked : op.getOperations()) { - auto operations_element_op = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp()); - if (operations_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected LiirClass1Op, got ", - mlir_operations_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr operations_element, VisitClass1(operations_element_op)); - operations.push_back(std::move(operations_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto strings, + Convert( + op.getStringsAttr(), + List( + ToString() + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto operations, + Convert( + op.getOperations(), + List( + ToOpConverter(VisitClass1) + ) + ) + ); return Create( op, std::move(strings), @@ -96,19 +95,17 @@ LiirToAst::VisitSimpleList(LiirSimpleListOp op) { absl::StatusOr> LiirToAst::VisitOptionalList(LiirOptionalListOp op) { - std::optional> strings; - if (op.getStringsAttr() != nullptr) { - std::vector strings_value; - for (mlir::Attribute mlir_strings_element_unchecked : op.getStringsAttr().getValue()) { - auto strings_element_attr = llvm::dyn_cast(mlir_strings_element_unchecked); - if (strings_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - std::string strings_element = strings_element_attr.str(); - strings_value.push_back(std::move(strings_element)); - } - strings = std::move(strings_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto strings, + Convert( + op.getStringsAttr(), + Nullable( + List( + ToString() + ) + ) + ) + ); return Create( op, std::move(strings)); @@ -116,32 +113,28 @@ LiirToAst::VisitOptionalList(LiirOptionalListOp op) { absl::StatusOr> LiirToAst::VisitListOfOptional(LiirListOfOptionalOp op) { - std::vector> strings; - for (mlir::Attribute mlir_strings_element_unchecked : op.getStringsAttr().getValue()) { - std::optional strings_element; - if (mlir_strings_element_unchecked != nullptr) { - auto strings_element_attr = llvm::dyn_cast(mlir_strings_element_unchecked); - if (strings_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - strings_element = strings_element_attr.str(); - } - strings.push_back(std::move(strings_element)); - } - std::vector>> operations; - for (mlir::Value mlir_operations_element_unchecked : op.getOperations()) { - std::optional> operations_element; - if (!llvm::isa(mlir_operations_element_unchecked.getDefiningOp())) { - auto operations_element_op = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp()); - if (operations_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected LiirClass1Op, got ", - mlir_operations_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(operations_element, VisitClass1(operations_element_op)); - } - operations.push_back(std::move(operations_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto strings, + Convert( + op.getStringsAttr(), + List( + Nullable( + ToString() + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto operations, + Convert( + op.getOperations(), + List( + Nullable( + ToOpConverter(VisitClass1) + ) + ) + ) + ); return Create( op, std::move(strings), @@ -150,30 +143,30 @@ LiirToAst::VisitListOfOptional(LiirListOfOptionalOp op) { absl::StatusOr> LiirToAst::VisitListOfVariant(LiirListOfVariantOp op) { - std::vector> variants; - for (mlir::Attribute mlir_variants_element_unchecked : op.getVariantsAttr().getValue()) { - std::variant variants_element; - if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.getValue(); - } else if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.str(); - } else { - return absl::InvalidArgumentError("mlir_variants_element_unchecked has invalid type."); - } - variants.push_back(std::move(variants_element)); - } - std::vector, std::unique_ptr>> operations; - for (mlir::Value mlir_operations_element_unchecked : op.getOperations()) { - std::variant, std::unique_ptr> operations_element; - if (auto mlir_operations_element = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, VisitClass1(mlir_operations_element)); - } else if (auto mlir_operations_element = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, VisitClass2(mlir_operations_element)); - } else { - return absl::InvalidArgumentError("mlir_operations_element_unchecked.getDefiningOp() has invalid type."); - } - operations.push_back(std::move(operations_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto variants, + Convert( + op.getVariantsAttr(), + List( + AttrVariant( + ToBool(), + ToString() + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto operations, + Convert( + op.getOperations(), + List( + OpVariant( + ToOpConverter(VisitClass1), + ToOpConverter(VisitClass2) + ) + ) + ) + ); return Create( op, std::move(variants), @@ -182,22 +175,19 @@ LiirToAst::VisitListOfVariant(LiirListOfVariantOp op) { absl::StatusOr> LiirToAst::VisitOptionalListOfOptional(LiirOptionalListOfOptionalOp op) { - std::optional>> variants; - if (op.getVariantsAttr() != nullptr) { - std::vector> variants_value; - for (mlir::Attribute mlir_variants_element_unchecked : op.getVariantsAttr().getValue()) { - std::optional variants_element; - if (mlir_variants_element_unchecked != nullptr) { - auto variants_element_attr = llvm::dyn_cast(mlir_variants_element_unchecked); - if (variants_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - variants_element = variants_element_attr.str(); - } - variants_value.push_back(std::move(variants_element)); - } - variants = std::move(variants_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto variants, + Convert( + op.getVariantsAttr(), + Nullable( + List( + Nullable( + ToString() + ) + ) + ) + ) + ); return Create( op, std::move(variants)); @@ -205,22 +195,20 @@ LiirToAst::VisitOptionalListOfOptional(LiirOptionalListOfOptionalOp op) { absl::StatusOr> LiirToAst::VisitOptionalListOfVariant(LiirOptionalListOfVariantOp op) { - std::optional>> variants; - if (op.getVariantsAttr() != nullptr) { - std::vector> variants_value; - for (mlir::Attribute mlir_variants_element_unchecked : op.getVariantsAttr().getValue()) { - std::variant variants_element; - if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.getValue(); - } else if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.str(); - } else { - return absl::InvalidArgumentError("mlir_variants_element_unchecked has invalid type."); - } - variants_value.push_back(std::move(variants_element)); - } - variants = std::move(variants_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto variants, + Convert( + op.getVariantsAttr(), + Nullable( + List( + AttrVariant( + ToBool(), + ToString() + ) + ) + ) + ) + ); return Create( op, std::move(variants)); @@ -228,34 +216,34 @@ LiirToAst::VisitOptionalListOfVariant(LiirOptionalListOfVariantOp op) { absl::StatusOr> LiirToAst::VisitListOfOptionalVariant(LiirListOfOptionalVariantOp op) { - std::vector>> variants; - for (mlir::Attribute mlir_variants_element_unchecked : op.getVariantsAttr().getValue()) { - std::optional> variants_element; - if (mlir_variants_element_unchecked != nullptr) { - if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.getValue(); - } else if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.str(); - } else { - return absl::InvalidArgumentError("mlir_variants_element_unchecked has invalid type."); - } - } - variants.push_back(std::move(variants_element)); - } - std::vector, std::unique_ptr>>> operations; - for (mlir::Value mlir_operations_element_unchecked : op.getOperations()) { - std::optional, std::unique_ptr>> operations_element; - if (!llvm::isa(mlir_operations_element_unchecked.getDefiningOp())) { - if (auto mlir_operations_element = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, VisitClass1(mlir_operations_element)); - } else if (auto mlir_operations_element = llvm::dyn_cast(mlir_operations_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(operations_element, VisitClass2(mlir_operations_element)); - } else { - return absl::InvalidArgumentError("mlir_operations_element_unchecked.getDefiningOp() has invalid type."); - } - } - operations.push_back(std::move(operations_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto variants, + Convert( + op.getVariantsAttr(), + List( + Nullable( + AttrVariant( + ToBool(), + ToString() + ) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto operations, + Convert( + op.getOperations(), + List( + Nullable( + OpVariant( + ToOpConverter(VisitClass1), + ToOpConverter(VisitClass2) + ) + ) + ) + ) + ); return Create( op, std::move(variants), @@ -264,24 +252,22 @@ LiirToAst::VisitListOfOptionalVariant(LiirListOfOptionalVariantOp op) { absl::StatusOr> LiirToAst::VisitOptionalListOfOptionalVariant(LiirOptionalListOfOptionalVariantOp op) { - std::optional>>> variants; - if (op.getVariantsAttr() != nullptr) { - std::vector>> variants_value; - for (mlir::Attribute mlir_variants_element_unchecked : op.getVariantsAttr().getValue()) { - std::optional> variants_element; - if (mlir_variants_element_unchecked != nullptr) { - if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.getValue(); - } else if (auto mlir_variants_element = llvm::dyn_cast(mlir_variants_element_unchecked)) { - variants_element = mlir_variants_element.str(); - } else { - return absl::InvalidArgumentError("mlir_variants_element_unchecked has invalid type."); - } - } - variants_value.push_back(std::move(variants_element)); - } - variants = std::move(variants_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto variants, + Convert( + op.getVariantsAttr(), + Nullable( + List( + Nullable( + AttrVariant( + ToBool(), + ToString() + ) + ) + ) + ) + ) + ); return Create( op, std::move(variants)); diff --git a/maldoca/astgen/test/list/conversion/liir_to_ast.h b/maldoca/astgen/test/list/conversion/liir_to_ast.h index b7a538a..570fa1b 100644 --- a/maldoca/astgen/test/list/conversion/liir_to_ast.h +++ b/maldoca/astgen/test/list/conversion/liir_to_ast.h @@ -26,37 +26,37 @@ namespace maldoca { class LiirToAst { public: - absl::StatusOr> VisitClass1(LiirClass1Op op); + static absl::StatusOr> VisitClass1(LiirClass1Op op); - absl::StatusOr> VisitClass2(LiirClass2Op op); + static absl::StatusOr> VisitClass2(LiirClass2Op op); - absl::StatusOr> VisitSimpleList( + static absl::StatusOr> VisitSimpleList( LiirSimpleListOp op); - absl::StatusOr> VisitOptionalList( + static absl::StatusOr> VisitOptionalList( LiirOptionalListOp op); - absl::StatusOr> VisitListOfOptional( + static absl::StatusOr> VisitListOfOptional( LiirListOfOptionalOp op); - absl::StatusOr> VisitListOfVariant( + static absl::StatusOr> VisitListOfVariant( LiirListOfVariantOp op); - absl::StatusOr> + static absl::StatusOr> VisitOptionalListOfOptional(LiirOptionalListOfOptionalOp op); - absl::StatusOr> + static absl::StatusOr> VisitOptionalListOfVariant(LiirOptionalListOfVariantOp op); - absl::StatusOr> + static absl::StatusOr> VisitListOfOptionalVariant(LiirListOfOptionalVariantOp op); - absl::StatusOr> + static absl::StatusOr> VisitOptionalListOfOptionalVariant(LiirOptionalListOfOptionalVariantOp op); private: template - std::unique_ptr Create(mlir::Operation *op, Args &&...args) { + static std::unique_ptr Create(mlir::Operation *op, Args &&...args) { return absl::make_unique(std::forward(args)...); } }; diff --git a/maldoca/astgen/test/multiple_inheritance/BUILD b/maldoca/astgen/test/multiple_inheritance/BUILD index a9e7cf8..94e2c6f 100644 --- a/maldoca/astgen/test/multiple_inheritance/BUILD +++ b/maldoca/astgen/test/multiple_inheritance/BUILD @@ -45,6 +45,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/astgen/test/multiple_inheritance/ast_from_json.generated.cc b/maldoca/astgen/test/multiple_inheritance/ast_from_json.generated.cc index e4edfa9..bb860b8 100644 --- a/maldoca/astgen/test/multiple_inheritance/ast_from_json.generated.cc +++ b/maldoca/astgen/test/multiple_inheritance/ast_from_json.generated.cc @@ -35,62 +35,32 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // MSourceLocation // ============================================================================= absl::StatusOr MSourceLocation::GetStart(const nlohmann::json& json) { - auto start_it = json.find("start"); - if (start_it == json.end()) { - return absl::InvalidArgumentError("`start` is undefined."); - } - const nlohmann::json& json_start = start_it.value(); - - if (json_start.is_null()) { - return absl::InvalidArgumentError("json_start is null."); - } - if (!json_start.is_number()) { - return absl::InvalidArgumentError("Expecting json_start.is_number()."); - } - return json_start.get(); + return GetRequiredField( + json, + "start", + JsonToDouble + ); } absl::StatusOr MSourceLocation::GetEnd(const nlohmann::json& json) { - auto end_it = json.find("end"); - if (end_it == json.end()) { - return absl::InvalidArgumentError("`end` is undefined."); - } - const nlohmann::json& json_end = end_it.value(); - - if (json_end.is_null()) { - return absl::InvalidArgumentError("json_end is null."); - } - if (!json_end.is_number()) { - return absl::InvalidArgumentError("Expecting json_end.is_number()."); - } - return json_end.get(); + return GetRequiredField( + json, + "end", + JsonToDouble + ); } absl::StatusOr> @@ -113,16 +83,11 @@ MSourceLocation::FromJson(const nlohmann::json& json) { absl::StatusOr> MNode::GetLoc(const nlohmann::json& json) { - auto loc_it = json.find("loc"); - if (loc_it == json.end()) { - return absl::InvalidArgumentError("`loc` is undefined."); - } - const nlohmann::json& json_loc = loc_it.value(); - - if (json_loc.is_null()) { - return absl::InvalidArgumentError("json_loc is null."); - } - return MSourceLocation::FromJson(json_loc); + return GetRequiredField>( + json, + "loc", + MSourceLocation::FromJson + ); } absl::StatusOr> @@ -149,19 +114,11 @@ MNode::FromJson(const nlohmann::json& json) { absl::StatusOr MFunction::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return absl::InvalidArgumentError("json_id is null."); - } - if (!json_id.is_string()) { - return absl::InvalidArgumentError("Expecting json_id.is_string()."); - } - return json_id.get(); + return GetRequiredField( + json, + "id", + JsonToString + ); } absl::StatusOr> @@ -184,19 +141,11 @@ MFunction::FromJson(const nlohmann::json& json) { absl::StatusOr MObjectMember::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/region/BUILD b/maldoca/astgen/test/region/BUILD index 3551e67..7b74956 100644 --- a/maldoca/astgen/test/region/BUILD +++ b/maldoca/astgen/test/region/BUILD @@ -54,6 +54,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/astgen/test/region/ast_from_json.generated.cc b/maldoca/astgen/test/region/ast_from_json.generated.cc index f29c8b3..69105fd 100644 --- a/maldoca/astgen/test/region/ast_from_json.generated.cc +++ b/maldoca/astgen/test/region/ast_from_json.generated.cc @@ -35,6 +35,7 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" @@ -61,16 +62,11 @@ RExpr::FromJson(const nlohmann::json& json) { absl::StatusOr> RStmt::GetExpr(const nlohmann::json& json) { - auto expr_it = json.find("expr"); - if (expr_it == json.end()) { - return absl::InvalidArgumentError("`expr` is undefined."); - } - const nlohmann::json& json_expr = expr_it.value(); - - if (json_expr.is_null()) { - return absl::InvalidArgumentError("json_expr is null."); - } - return RExpr::FromJson(json_expr); + return GetRequiredField>( + json, + "expr", + RExpr::FromJson + ); } absl::StatusOr> @@ -91,110 +87,60 @@ RStmt::FromJson(const nlohmann::json& json) { absl::StatusOr> RNode::GetExpr(const nlohmann::json& json) { - auto expr_it = json.find("expr"); - if (expr_it == json.end()) { - return absl::InvalidArgumentError("`expr` is undefined."); - } - const nlohmann::json& json_expr = expr_it.value(); - - if (json_expr.is_null()) { - return absl::InvalidArgumentError("json_expr is null."); - } - return RExpr::FromJson(json_expr); + return GetRequiredField>( + json, + "expr", + RExpr::FromJson + ); } absl::StatusOr>> RNode::GetOptionalExpr(const nlohmann::json& json) { - auto optional_expr_it = json.find("optionalExpr"); - if (optional_expr_it == json.end()) { - return absl::InvalidArgumentError("`optionalExpr` is undefined."); - } - const nlohmann::json& json_optional_expr = optional_expr_it.value(); - - if (json_optional_expr.is_null()) { - return std::nullopt; - } - return RExpr::FromJson(json_optional_expr); + return GetNullableField>( + json, + "optionalExpr", + RExpr::FromJson + ); } absl::StatusOr>> RNode::GetExprs(const nlohmann::json& json) { - auto exprs_it = json.find("exprs"); - if (exprs_it == json.end()) { - return absl::InvalidArgumentError("`exprs` is undefined."); - } - const nlohmann::json& json_exprs = exprs_it.value(); - - if (json_exprs.is_null()) { - return absl::InvalidArgumentError("json_exprs is null."); - } - if (!json_exprs.is_array()) { - return absl::InvalidArgumentError("json_exprs expected to be array."); - } - - std::vector> exprs; - for (const nlohmann::json& json_exprs_element : json_exprs) { - if (json_exprs_element.is_null()) { - return absl::InvalidArgumentError("json_exprs_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto exprs_element, RExpr::FromJson(json_exprs_element)); - exprs.push_back(std::move(exprs_element)); - } - return exprs; + return GetRequiredField>>( + json, + "exprs", + List>( + RExpr::FromJson + ) + ); } absl::StatusOr> RNode::GetStmt(const nlohmann::json& json) { - auto stmt_it = json.find("stmt"); - if (stmt_it == json.end()) { - return absl::InvalidArgumentError("`stmt` is undefined."); - } - const nlohmann::json& json_stmt = stmt_it.value(); - - if (json_stmt.is_null()) { - return absl::InvalidArgumentError("json_stmt is null."); - } - return RStmt::FromJson(json_stmt); + return GetRequiredField>( + json, + "stmt", + RStmt::FromJson + ); } absl::StatusOr>> RNode::GetOptionalStmt(const nlohmann::json& json) { - auto optional_stmt_it = json.find("optionalStmt"); - if (optional_stmt_it == json.end()) { - return absl::InvalidArgumentError("`optionalStmt` is undefined."); - } - const nlohmann::json& json_optional_stmt = optional_stmt_it.value(); - - if (json_optional_stmt.is_null()) { - return std::nullopt; - } - return RStmt::FromJson(json_optional_stmt); + return GetNullableField>( + json, + "optionalStmt", + RStmt::FromJson + ); } absl::StatusOr>> RNode::GetStmts(const nlohmann::json& json) { - auto stmts_it = json.find("stmts"); - if (stmts_it == json.end()) { - return absl::InvalidArgumentError("`stmts` is undefined."); - } - const nlohmann::json& json_stmts = stmts_it.value(); - - if (json_stmts.is_null()) { - return absl::InvalidArgumentError("json_stmts is null."); - } - if (!json_stmts.is_array()) { - return absl::InvalidArgumentError("json_stmts expected to be array."); - } - - std::vector> stmts; - for (const nlohmann::json& json_stmts_element : json_stmts) { - if (json_stmts_element.is_null()) { - return absl::InvalidArgumentError("json_stmts_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto stmts_element, RStmt::FromJson(json_stmts_element)); - stmts.push_back(std::move(stmts_element)); - } - return stmts; + return GetRequiredField>>( + json, + "stmts", + List>( + RStmt::FromJson + ) + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/region/conversion/BUILD b/maldoca/astgen/test/region/conversion/BUILD index b978eb6..81d71ca 100644 --- a/maldoca/astgen/test/region/conversion/BUILD +++ b/maldoca/astgen/test/region/conversion/BUILD @@ -46,6 +46,7 @@ cc_library( srcs = ["rir_to_ast.generated.cc"], hdrs = ["rir_to_ast.h"], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/astgen/test/region:ast", "//maldoca/astgen/test/region:ir", "//maldoca/base:status", diff --git a/maldoca/astgen/test/region/conversion/ast_to_rir.generated.cc b/maldoca/astgen/test/region/conversion/ast_to_rir.generated.cc index 0b6cf56..97cd141 100644 --- a/maldoca/astgen/test/region/conversion/ast_to_rir.generated.cc +++ b/maldoca/astgen/test/region/conversion/ast_to_rir.generated.cc @@ -45,52 +45,52 @@ namespace maldoca { -RirExprOp AstToRir::VisitExpr(const RExpr *node) { - return CreateExpr(node); +RirExprOp AstToRir::VisitExpr(mlir::OpBuilder &builder, const RExpr *node) { + return CreateExpr(builder, node); } -RirStmtOp AstToRir::VisitStmt(const RStmt *node) { - mlir::Value mlir_expr = VisitExpr(node->expr()); - return CreateStmt(node, mlir_expr); +RirStmtOp AstToRir::VisitStmt(mlir::OpBuilder &builder, const RStmt *node) { + mlir::Value mlir_expr = VisitExpr(builder, node->expr()); + return CreateStmt(builder, node, mlir_expr); } -RirNodeOp AstToRir::VisitNode(const RNode *node) { - auto op = CreateExpr(node); +RirNodeOp AstToRir::VisitNode(mlir::OpBuilder &builder, const RNode *node) { + auto op = CreateExpr(builder, node); mlir::Region &mlir_expr_region = op.getExpr(); - AppendNewBlockAndPopulate(mlir_expr_region, [&] { - mlir::Value mlir_expr = VisitExpr(node->expr()); - CreateStmt(node, mlir_expr); + AppendNewBlockAndPopulate(builder, mlir_expr_region, [&] { + mlir::Value mlir_expr = VisitExpr(builder, node->expr()); + CreateStmt(builder, nullptr, mlir_expr); }); if (node->optional_expr().has_value()) { mlir::Region &mlir_optional_expr_region = op.getOptionalExpr(); - AppendNewBlockAndPopulate(mlir_optional_expr_region, [&] { - mlir::Value mlir_optional_expr = VisitExpr(node->optional_expr().value()); - CreateStmt(node, mlir_optional_expr); + AppendNewBlockAndPopulate(builder, mlir_optional_expr_region, [&] { + mlir::Value mlir_optional_expr = VisitExpr(builder, node->optional_expr().value()); + CreateStmt(builder, nullptr, mlir_optional_expr); }); } mlir::Region &mlir_exprs_region = op.getExprs(); - AppendNewBlockAndPopulate(mlir_exprs_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_exprs_region, [&] { std::vector mlir_exprs; for (const auto &element : *node->exprs()) { - mlir::Value mlir_element = VisitExpr(element.get()); + mlir::Value mlir_element = VisitExpr(builder, element.get()); mlir_exprs.push_back(std::move(mlir_element)); } - CreateStmt(node, mlir_exprs); + CreateStmt(builder, nullptr, mlir_exprs); }); mlir::Region &mlir_stmt_region = op.getStmt(); - AppendNewBlockAndPopulate(mlir_stmt_region, [&] { - VisitStmt(node->stmt()); + AppendNewBlockAndPopulate(builder, mlir_stmt_region, [&] { + VisitStmt(builder, node->stmt()); }); if (node->optional_stmt().has_value()) { mlir::Region &mlir_optional_stmt_region = op.getOptionalStmt(); - AppendNewBlockAndPopulate(mlir_optional_stmt_region, [&] { - VisitStmt(node->optional_stmt().value()); + AppendNewBlockAndPopulate(builder, mlir_optional_stmt_region, [&] { + VisitStmt(builder, node->optional_stmt().value()); }); } mlir::Region &mlir_stmts_region = op.getStmts(); - AppendNewBlockAndPopulate(mlir_stmts_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_stmts_region, [&] { for (const auto &element : *node->stmts()) { - VisitStmt(element.get()); + VisitStmt(builder, element.get()); } }); return op; diff --git a/maldoca/astgen/test/region/conversion/ast_to_rir.h b/maldoca/astgen/test/region/conversion/ast_to_rir.h index 38733fa..ef35983 100644 --- a/maldoca/astgen/test/region/conversion/ast_to_rir.h +++ b/maldoca/astgen/test/region/conversion/ast_to_rir.h @@ -18,9 +18,9 @@ #include #include +#include "mlir/IR/Block.h" #include "mlir/IR/Builders.h" #include "mlir/IR/Region.h" -#include "mlir/IR/Block.h" #include "maldoca/astgen/test/region/ast.generated.h" #include "maldoca/astgen/test/region/ir.h" @@ -28,41 +28,40 @@ namespace maldoca { class AstToRir { public: - explicit AstToRir(mlir::OpBuilder &builder) : builder_(builder) {} + static RirExprOp VisitExpr(mlir::OpBuilder& builder, const RExpr* node); - RirExprOp VisitExpr(const RExpr *node); + static RirStmtOp VisitStmt(mlir::OpBuilder& builder, const RStmt* node); - RirStmtOp VisitStmt(const RStmt *node); - - RirNodeOp VisitNode(const RNode *node); + static RirNodeOp VisitNode(mlir::OpBuilder& builder, const RNode* node); private: - template - Op CreateExpr(const RNode *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + template + static Op CreateExpr(mlir::OpBuilder& builder, const void* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } - template - Op CreateStmt(const RNode *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), mlir::TypeRange(), - std::forward(args)...); + template + static Op CreateStmt(mlir::OpBuilder& builder, const void* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), mlir::TypeRange(), + std::forward(args)...); } - void AppendNewBlockAndPopulate(mlir::Region ®ion, - std::function populate) { + static void AppendNewBlockAndPopulate(mlir::OpBuilder& builder, + mlir::Region& region, + std::function populate) { // Save insertion point. // Will revert at the end. - mlir::OpBuilder::InsertionGuard insertion_guard(builder_); + mlir::OpBuilder::InsertionGuard insertion_guard(builder); // Insert new block and point builder to it. - mlir::Block &block = region.emplaceBlock(); - builder_.setInsertionPointToStart(&block); + mlir::Block& block = region.emplaceBlock(); + builder.setInsertionPointToStart(&block); populate(); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/region/conversion/conversion_test.cc b/maldoca/astgen/test/region/conversion/conversion_test.cc index 8835ada..8055dbe 100644 --- a/maldoca/astgen/test/region/conversion/conversion_test.cc +++ b/maldoca/astgen/test/region/conversion/conversion_test.cc @@ -79,9 +79,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToRir::VisitNode, + .ast_to_ir_visit = AstToRir::VisitNode, .ir_to_ast_visit = &RirToAst::VisitNode, .expected_ir_dump = kExpectedIr, }); diff --git a/maldoca/astgen/test/region/conversion/rir_to_ast.generated.cc b/maldoca/astgen/test/region/conversion/rir_to_ast.generated.cc index 007e80f..ee3d6cb 100644 --- a/maldoca/astgen/test/region/conversion/rir_to_ast.generated.cc +++ b/maldoca/astgen/test/region/conversion/rir_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/astgen/test/region/ast.generated.h" #include "maldoca/astgen/test/region/ir.h" @@ -62,13 +63,13 @@ RirToAst::VisitExpr(RirExprOp op) { absl::StatusOr> RirToAst::VisitStmt(RirStmtOp op) { - auto expr_op = llvm::dyn_cast(op.getExpr().getDefiningOp()); - if (expr_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirExprOp, got ", - op.getExpr().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr expr, VisitExpr(expr_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto expr, + Convert( + op.getExpr(), + ToOpConverter(VisitExpr) + ) + ); return Create( op, std::move(expr)); @@ -76,66 +77,68 @@ RirToAst::VisitStmt(RirStmtOp op) { absl::StatusOr> RirToAst::VisitNode(RirNodeOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_expr_value, GetExprRegionValue(op.getExpr())); - auto expr_op = llvm::dyn_cast(mlir_expr_value.getDefiningOp()); - if (expr_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirExprOp, got ", - mlir_expr_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr expr, VisitExpr(expr_op)); - std::optional> optional_expr; - if (!op.getOptionalExpr().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_optional_expr_value, GetExprRegionValue(op.getOptionalExpr())); - auto optional_expr_op = llvm::dyn_cast(mlir_optional_expr_value.getDefiningOp()); - if (optional_expr_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirExprOp, got ", - mlir_optional_expr_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(optional_expr, VisitExpr(optional_expr_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_exprs_values, GetExprsRegionValues(op.getExprs())); - std::vector> exprs; - for (mlir::Value mlir_exprs_element_unchecked : mlir_exprs_values) { - auto exprs_element_op = llvm::dyn_cast(mlir_exprs_element_unchecked.getDefiningOp()); - if (exprs_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirExprOp, got ", - mlir_exprs_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr exprs_element, VisitExpr(exprs_element_op)); - exprs.push_back(std::move(exprs_element)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_stmt_operation, GetStmtRegionOperation(op.getStmt())); - auto stmt_op = llvm::dyn_cast(mlir_stmt_operation); - if (stmt_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirStmtOp, got ", - mlir_stmt_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr stmt, VisitStmt(stmt_op)); - std::optional> optional_stmt; - if (!op.getOptionalStmt().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_optional_stmt_operation, GetStmtRegionOperation(op.getOptionalStmt())); - auto optional_stmt_op = llvm::dyn_cast(mlir_optional_stmt_operation); - if (optional_stmt_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected RirStmtOp, got ", - mlir_optional_stmt_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(optional_stmt, VisitStmt(optional_stmt_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_stmts_block, GetStmtsRegionBlock(op.getStmts())); - std::vector> stmts; - for (mlir::Operation& mlir_stmts_element_unchecked : *mlir_stmts_block) { - auto stmts_element_op = llvm::dyn_cast(mlir_stmts_element_unchecked); - if (stmts_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr stmts_element, VisitStmt(stmts_element_op)); - stmts.push_back(std::move(stmts_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto expr, + Convert( + op.getExpr(), + ExprRegion( + ToOpConverter(VisitExpr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto optional_expr, + Convert( + op.getOptionalExpr(), + Nullable( + ExprRegion( + ToOpConverter(VisitExpr) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto exprs, + Convert( + op.getExprs(), + ExprsRegion( + List( + ToOpConverter(VisitExpr) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto stmt, + Convert( + op.getStmt(), + StmtRegion( + ToOpConverter(VisitStmt) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto optional_stmt, + Convert( + op.getOptionalStmt(), + Nullable( + StmtRegion( + ToOpConverter(VisitStmt) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto stmts, + Convert( + op.getStmts(), + StmtsRegion( + List( + ToOpConverter(VisitStmt) + ) + ) + ) + ); return Create( op, std::move(expr), diff --git a/maldoca/astgen/test/region/conversion/rir_to_ast.h b/maldoca/astgen/test/region/conversion/rir_to_ast.h index c225479..49aaffb 100644 --- a/maldoca/astgen/test/region/conversion/rir_to_ast.h +++ b/maldoca/astgen/test/region/conversion/rir_to_ast.h @@ -18,12 +18,7 @@ #include #include -#include "llvm/Support/Casting.h" #include "mlir/IR/Operation.h" -#include "mlir/IR/Region.h" -#include "mlir/IR/Value.h" -#include "mlir/IR/ValueRange.h" -#include "absl/status/status.h" #include "absl/status/statusor.h" #include "maldoca/astgen/test/region/ast.generated.h" #include "maldoca/astgen/test/region/ir.h" @@ -32,73 +27,17 @@ namespace maldoca { class RirToAst { public: - absl::StatusOr> VisitExpr(RirExprOp op); + static absl::StatusOr> VisitExpr(RirExprOp op); - absl::StatusOr> VisitStmt(RirStmtOp op); + static absl::StatusOr> VisitStmt(RirStmtOp op); - absl::StatusOr> VisitNode(RirNodeOp op); + static absl::StatusOr> VisitNode(RirNodeOp op); private: template - std::unique_ptr Create(mlir::Operation *op, Args &&...args) { + static std::unique_ptr Create(mlir::Operation* op, Args&&... args) { return absl::make_unique(std::forward(args)...); } - - absl::StatusOr GetExprRegionValue(mlir::Region ®ion) { - if (!region.hasOneBlock()) { - return absl::InvalidArgumentError( - "Region should have exactly one block."); - } - mlir::Block &block = region.front(); - if (block.empty()) { - return absl::InvalidArgumentError("Block cannot be empty."); - } - auto expr_region_end = llvm::dyn_cast(block.back()); - if (expr_region_end == nullptr) { - return absl::InvalidArgumentError( - "Block should end with RirExprRegionEndOp."); - } - return expr_region_end.getArgument(); - } - - absl::StatusOr GetExprsRegionValues(mlir::Region ®ion) { - if (!region.hasOneBlock()) { - return absl::InvalidArgumentError( - "Region should have exactly one block."); - } - mlir::Block &block = region.front(); - if (block.empty()) { - return absl::InvalidArgumentError("Block cannot be empty."); - } - auto exprs_region_end = llvm::dyn_cast(block.back()); - if (exprs_region_end == nullptr) { - return absl::InvalidArgumentError( - "Block should end with RirExprsRegionEndOp."); - } - return exprs_region_end.getArguments(); - } - - absl::StatusOr GetStmtRegionOperation( - mlir::Region ®ion) { - if (!region.hasOneBlock()) { - return absl::InvalidArgumentError( - "Region should have exactly one block."); - } - mlir::Block &block = region.front(); - if (block.empty()) { - return absl::InvalidArgumentError("Block cannot be empty."); - } - return &block.back(); - } - - absl::StatusOr GetStmtsRegionBlock(mlir::Region ®ion) { - if (!region.hasOneBlock()) { - return absl::InvalidArgumentError( - "Region should have exactly one block."); - } - mlir::Block &block = region.front(); - return █ - } }; } // namespace maldoca diff --git a/maldoca/astgen/test/typed_lambda/BUILD b/maldoca/astgen/test/typed_lambda/BUILD index 325c332..9c29b3d 100644 --- a/maldoca/astgen/test/typed_lambda/BUILD +++ b/maldoca/astgen/test/typed_lambda/BUILD @@ -45,6 +45,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/astgen/test/typed_lambda/ast_from_json.generated.cc b/maldoca/astgen/test/typed_lambda/ast_from_json.generated.cc index c0f827f..3b34515 100644 --- a/maldoca/astgen/test/typed_lambda/ast_from_json.generated.cc +++ b/maldoca/astgen/test/typed_lambda/ast_from_json.generated.cc @@ -35,26 +35,12 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // TlNode // ============================================================================= @@ -137,29 +123,27 @@ TlType::FromJson(const nlohmann::json& json) { absl::StatusOr> TlLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (json_value.is_boolean()) { - return json_value.get(); - } else if (json_value.is_number_integer()) { - return json_value.get(); - } else if (json_value.is_number()) { - return json_value.get(); - } else if (json_value.is_string()) { - return json_value.get(); - } else { - auto result = absl::InvalidArgumentError("json_value has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_value.dump()}); - return result; - } + return GetRequiredField>( + json, + "value", + Variant( + VariantOption{ + .predicate = IsBool, + .converter = JsonToBool, + }, + VariantOption{ + .predicate = IsInt64, + .converter = JsonToInt64, + }, + VariantOption{ + .predicate = IsDouble, + .converter = JsonToDouble, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ); } absl::StatusOr> @@ -180,19 +164,11 @@ TlLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr TlVariable::GetIdentifier(const nlohmann::json& json) { - auto identifier_it = json.find("identifier"); - if (identifier_it == json.end()) { - return absl::InvalidArgumentError("`identifier` is undefined."); - } - const nlohmann::json& json_identifier = identifier_it.value(); - - if (json_identifier.is_null()) { - return absl::InvalidArgumentError("json_identifier is null."); - } - if (!json_identifier.is_string()) { - return absl::InvalidArgumentError("Expecting json_identifier.is_string()."); - } - return json_identifier.get(); + return GetRequiredField( + json, + "identifier", + JsonToString + ); } absl::StatusOr> @@ -213,44 +189,29 @@ TlVariable::FromJson(const nlohmann::json& json) { absl::StatusOr> TlFunctionDefinition::GetParameter(const nlohmann::json& json) { - auto parameter_it = json.find("parameter"); - if (parameter_it == json.end()) { - return absl::InvalidArgumentError("`parameter` is undefined."); - } - const nlohmann::json& json_parameter = parameter_it.value(); - - if (json_parameter.is_null()) { - return absl::InvalidArgumentError("json_parameter is null."); - } - return TlVariable::FromJson(json_parameter); + return GetRequiredField>( + json, + "parameter", + TlVariable::FromJson + ); } absl::StatusOr> TlFunctionDefinition::GetParameterType(const nlohmann::json& json) { - auto parameter_type_it = json.find("parameterType"); - if (parameter_type_it == json.end()) { - return absl::InvalidArgumentError("`parameterType` is undefined."); - } - const nlohmann::json& json_parameter_type = parameter_type_it.value(); - - if (json_parameter_type.is_null()) { - return absl::InvalidArgumentError("json_parameter_type is null."); - } - return TlType::FromJson(json_parameter_type); + return GetRequiredField>( + json, + "parameterType", + TlType::FromJson + ); } absl::StatusOr> TlFunctionDefinition::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return TlExpression::FromJson(json_body); + return GetRequiredField>( + json, + "body", + TlExpression::FromJson + ); } absl::StatusOr> @@ -275,30 +236,20 @@ TlFunctionDefinition::FromJson(const nlohmann::json& json) { absl::StatusOr> TlFunctionCall::GetCaller(const nlohmann::json& json) { - auto caller_it = json.find("caller"); - if (caller_it == json.end()) { - return absl::InvalidArgumentError("`caller` is undefined."); - } - const nlohmann::json& json_caller = caller_it.value(); - - if (json_caller.is_null()) { - return absl::InvalidArgumentError("json_caller is null."); - } - return TlExpression::FromJson(json_caller); + return GetRequiredField>( + json, + "caller", + TlExpression::FromJson + ); } absl::StatusOr> TlFunctionCall::GetCallee(const nlohmann::json& json) { - auto callee_it = json.find("callee"); - if (callee_it == json.end()) { - return absl::InvalidArgumentError("`callee` is undefined."); - } - const nlohmann::json& json_callee = callee_it.value(); - - if (json_callee.is_null()) { - return absl::InvalidArgumentError("json_callee is null."); - } - return TlExpression::FromJson(json_callee); + return GetRequiredField>( + json, + "callee", + TlExpression::FromJson + ); } absl::StatusOr> @@ -336,30 +287,20 @@ TlLiteralType::FromJson(const nlohmann::json& json) { absl::StatusOr> TlFunctionType::GetParameterType(const nlohmann::json& json) { - auto parameter_type_it = json.find("parameterType"); - if (parameter_type_it == json.end()) { - return absl::InvalidArgumentError("`parameterType` is undefined."); - } - const nlohmann::json& json_parameter_type = parameter_type_it.value(); - - if (json_parameter_type.is_null()) { - return absl::InvalidArgumentError("json_parameter_type is null."); - } - return TlType::FromJson(json_parameter_type); + return GetRequiredField>( + json, + "parameterType", + TlType::FromJson + ); } absl::StatusOr> TlFunctionType::GetBodyType(const nlohmann::json& json) { - auto body_type_it = json.find("bodyType"); - if (body_type_it == json.end()) { - return absl::InvalidArgumentError("`bodyType` is undefined."); - } - const nlohmann::json& json_body_type = body_type_it.value(); - - if (json_body_type.is_null()) { - return absl::InvalidArgumentError("json_body_type is null."); - } - return TlType::FromJson(json_body_type); + return GetRequiredField>( + json, + "bodyType", + TlType::FromJson + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/union/BUILD b/maldoca/astgen/test/union/BUILD index bfdedab..1c3d51d 100644 --- a/maldoca/astgen/test/union/BUILD +++ b/maldoca/astgen/test/union/BUILD @@ -47,6 +47,7 @@ cc_library( "ast.generated.h", ], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/astgen/test/union/ast_from_json.generated.cc b/maldoca/astgen/test/union/ast_from_json.generated.cc index 6b70915..f532eef 100644 --- a/maldoca/astgen/test/union/ast_from_json.generated.cc +++ b/maldoca/astgen/test/union/ast_from_json.generated.cc @@ -35,26 +35,12 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // EUnionType // ============================================================================= @@ -81,33 +67,20 @@ EUnionType::FromJson(const nlohmann::json& json) { absl::StatusOr ENode::GetName(const nlohmann::json& json) { - auto name_it = json.find("name"); - if (name_it == json.end()) { - return absl::InvalidArgumentError("`name` is undefined."); - } - const nlohmann::json& json_name = name_it.value(); - - if (json_name.is_null()) { - return absl::InvalidArgumentError("json_name is null."); - } - if (!json_name.is_string()) { - return absl::InvalidArgumentError("Expecting json_name.is_string()."); - } - return json_name.get(); + return GetRequiredField( + json, + "name", + JsonToString + ); } absl::StatusOr> ENode::GetContent(const nlohmann::json& json) { - auto content_it = json.find("content"); - if (content_it == json.end()) { - return absl::InvalidArgumentError("`content` is undefined."); - } - const nlohmann::json& json_content = content_it.value(); - - if (json_content.is_null()) { - return absl::InvalidArgumentError("json_content is null."); - } - return EUnionType::FromJson(json_content); + return GetRequiredField>( + json, + "content", + EUnionType::FromJson + ); } absl::StatusOr> @@ -130,19 +103,11 @@ ENode::FromJson(const nlohmann::json& json) { absl::StatusOr ESubNodeA::GetValueA(const nlohmann::json& json) { - auto value_a_it = json.find("valueA"); - if (value_a_it == json.end()) { - return absl::InvalidArgumentError("`valueA` is undefined."); - } - const nlohmann::json& json_value_a = value_a_it.value(); - - if (json_value_a.is_null()) { - return absl::InvalidArgumentError("json_value_a is null."); - } - if (!json_value_a.is_string()) { - return absl::InvalidArgumentError("Expecting json_value_a.is_string()."); - } - return json_value_a.get(); + return GetRequiredField( + json, + "valueA", + JsonToString + ); } absl::StatusOr> @@ -163,19 +128,11 @@ ESubNodeA::FromJson(const nlohmann::json& json) { absl::StatusOr ESubNodeB::GetValueB(const nlohmann::json& json) { - auto value_b_it = json.find("valueB"); - if (value_b_it == json.end()) { - return absl::InvalidArgumentError("`valueB` is undefined."); - } - const nlohmann::json& json_value_b = value_b_it.value(); - - if (json_value_b.is_null()) { - return absl::InvalidArgumentError("json_value_b is null."); - } - if (!json_value_b.is_string()) { - return absl::InvalidArgumentError("Expecting json_value_b.is_string()."); - } - return json_value_b.get(); + return GetRequiredField( + json, + "valueB", + JsonToString + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/variant/BUILD b/maldoca/astgen/test/variant/BUILD index 28ecad4..74b9314 100644 --- a/maldoca/astgen/test/variant/BUILD +++ b/maldoca/astgen/test/variant/BUILD @@ -54,6 +54,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", @@ -197,12 +198,7 @@ cc_library( ":vir_ops_generated_inc_gen", ":vir_types_inc_gen", "@llvm-project//llvm:Support", - "@llvm-project//mlir:Analysis", - "@llvm-project//mlir:ControlFlowInterfaces", "@llvm-project//mlir:IR", "@llvm-project//mlir:InferTypeOpInterface", - "@llvm-project//mlir:Parser", - "@llvm-project//mlir:SideEffectInterfaces", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/variant/ast_from_json.generated.cc b/maldoca/astgen/test/variant/ast_from_json.generated.cc index d98260d..c8dbf45 100644 --- a/maldoca/astgen/test/variant/ast_from_json.generated.cc +++ b/maldoca/astgen/test/variant/ast_from_json.generated.cc @@ -35,26 +35,12 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // VBaseClass // ============================================================================= @@ -143,140 +129,104 @@ VDerivedClass2::FromJson(const nlohmann::json& json) { absl::StatusOr> VNode::GetSimpleVariantBuiltin(const nlohmann::json& json) { - auto simple_variant_builtin_it = json.find("simpleVariantBuiltin"); - if (simple_variant_builtin_it == json.end()) { - return absl::InvalidArgumentError("`simpleVariantBuiltin` is undefined."); - } - const nlohmann::json& json_simple_variant_builtin = simple_variant_builtin_it.value(); - - if (json_simple_variant_builtin.is_null()) { - return absl::InvalidArgumentError("json_simple_variant_builtin is null."); - } - if (json_simple_variant_builtin.is_number()) { - return json_simple_variant_builtin.get(); - } else if (json_simple_variant_builtin.is_string()) { - return json_simple_variant_builtin.get(); - } else { - auto result = absl::InvalidArgumentError("json_simple_variant_builtin has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_simple_variant_builtin.dump()}); - return result; - } + return GetRequiredField>( + json, + "simpleVariantBuiltin", + Variant( + VariantOption{ + .predicate = IsDouble, + .converter = JsonToDouble, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ); } absl::StatusOr>> VNode::GetNullableVariantBuiltin(const nlohmann::json& json) { - auto nullable_variant_builtin_it = json.find("nullableVariantBuiltin"); - if (nullable_variant_builtin_it == json.end()) { - return absl::InvalidArgumentError("`nullableVariantBuiltin` is undefined."); - } - const nlohmann::json& json_nullable_variant_builtin = nullable_variant_builtin_it.value(); - - if (json_nullable_variant_builtin.is_null()) { - return std::nullopt; - } - if (json_nullable_variant_builtin.is_number()) { - return json_nullable_variant_builtin.get(); - } else if (json_nullable_variant_builtin.is_string()) { - return json_nullable_variant_builtin.get(); - } else { - auto result = absl::InvalidArgumentError("json_nullable_variant_builtin has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_nullable_variant_builtin.dump()}); - return result; - } + return GetNullableField>( + json, + "nullableVariantBuiltin", + Variant( + VariantOption{ + .predicate = IsDouble, + .converter = JsonToDouble, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ); } absl::StatusOr>> VNode::GetOptionalVariantBuiltin(const nlohmann::json& json) { - auto optional_variant_builtin_it = json.find("optionalVariantBuiltin"); - if (optional_variant_builtin_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_optional_variant_builtin = optional_variant_builtin_it.value(); - - if (json_optional_variant_builtin.is_null()) { - return absl::InvalidArgumentError("json_optional_variant_builtin is null."); - } - if (json_optional_variant_builtin.is_number()) { - return json_optional_variant_builtin.get(); - } else if (json_optional_variant_builtin.is_string()) { - return json_optional_variant_builtin.get(); - } else { - auto result = absl::InvalidArgumentError("json_optional_variant_builtin has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_optional_variant_builtin.dump()}); - return result; - } + return GetOptionalField>( + json, + "optionalVariantBuiltin", + Variant( + VariantOption{ + .predicate = IsDouble, + .converter = JsonToDouble, + }, + VariantOption{ + .predicate = IsString, + .converter = JsonToString, + }) + ); } absl::StatusOr, std::unique_ptr>> VNode::GetSimpleVariantClass(const nlohmann::json& json) { - auto simple_variant_class_it = json.find("simpleVariantClass"); - if (simple_variant_class_it == json.end()) { - return absl::InvalidArgumentError("`simpleVariantClass` is undefined."); - } - const nlohmann::json& json_simple_variant_class = simple_variant_class_it.value(); - - if (json_simple_variant_class.is_null()) { - return absl::InvalidArgumentError("json_simple_variant_class is null."); - } - if (IsDerivedClass1(json_simple_variant_class)) { - return VDerivedClass1::FromJson(json_simple_variant_class); - } else if (IsDerivedClass2(json_simple_variant_class)) { - return VDerivedClass2::FromJson(json_simple_variant_class); - } else { - auto result = absl::InvalidArgumentError("json_simple_variant_class has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_simple_variant_class.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "simpleVariantClass", + Variant( + VariantOption>{ + .predicate = IsDerivedClass1, + .converter = VDerivedClass1::FromJson, + }, + VariantOption>{ + .predicate = IsDerivedClass2, + .converter = VDerivedClass2::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>>> VNode::GetNullableVariantClass(const nlohmann::json& json) { - auto nullable_variant_class_it = json.find("nullableVariantClass"); - if (nullable_variant_class_it == json.end()) { - return absl::InvalidArgumentError("`nullableVariantClass` is undefined."); - } - const nlohmann::json& json_nullable_variant_class = nullable_variant_class_it.value(); - - if (json_nullable_variant_class.is_null()) { - return std::nullopt; - } - if (IsDerivedClass1(json_nullable_variant_class)) { - return VDerivedClass1::FromJson(json_nullable_variant_class); - } else if (IsDerivedClass2(json_nullable_variant_class)) { - return VDerivedClass2::FromJson(json_nullable_variant_class); - } else { - auto result = absl::InvalidArgumentError("json_nullable_variant_class has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_nullable_variant_class.dump()}); - return result; - } + return GetNullableField, std::unique_ptr>>( + json, + "nullableVariantClass", + Variant( + VariantOption>{ + .predicate = IsDerivedClass1, + .converter = VDerivedClass1::FromJson, + }, + VariantOption>{ + .predicate = IsDerivedClass2, + .converter = VDerivedClass2::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>>> VNode::GetOptionalVariantClass(const nlohmann::json& json) { - auto optional_variant_class_it = json.find("optionalVariantClass"); - if (optional_variant_class_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_optional_variant_class = optional_variant_class_it.value(); - - if (json_optional_variant_class.is_null()) { - return absl::InvalidArgumentError("json_optional_variant_class is null."); - } - if (IsDerivedClass1(json_optional_variant_class)) { - return VDerivedClass1::FromJson(json_optional_variant_class); - } else if (IsDerivedClass2(json_optional_variant_class)) { - return VDerivedClass2::FromJson(json_optional_variant_class); - } else { - auto result = absl::InvalidArgumentError("json_optional_variant_class has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_optional_variant_class.dump()}); - return result; - } + return GetOptionalField, std::unique_ptr>>( + json, + "optionalVariantClass", + Variant( + VariantOption>{ + .predicate = IsDerivedClass1, + .converter = VDerivedClass1::FromJson, + }, + VariantOption>{ + .predicate = IsDerivedClass2, + .converter = VDerivedClass2::FromJson, + }) + ); } absl::StatusOr> diff --git a/maldoca/astgen/test/variant/conversion/BUILD b/maldoca/astgen/test/variant/conversion/BUILD index 234f91a..be9032c 100644 --- a/maldoca/astgen/test/variant/conversion/BUILD +++ b/maldoca/astgen/test/variant/conversion/BUILD @@ -46,6 +46,7 @@ cc_library( srcs = ["vir_to_ast.generated.cc"], hdrs = ["vir_to_ast.h"], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/astgen/test/variant:ast", "//maldoca/astgen/test/variant:ir", "//maldoca/base:status", @@ -59,7 +60,6 @@ cc_library( "@abseil-cpp//absl/types:variant", "@llvm-project//llvm:Support", "@llvm-project//mlir:IR", - "@llvm-project//mlir:Support", ], ) diff --git a/maldoca/astgen/test/variant/conversion/ast_to_vir.generated.cc b/maldoca/astgen/test/variant/conversion/ast_to_vir.generated.cc index 5d78c9d..5ca1fd9 100644 --- a/maldoca/astgen/test/variant/conversion/ast_to_vir.generated.cc +++ b/maldoca/astgen/test/variant/conversion/ast_to_vir.generated.cc @@ -45,33 +45,33 @@ namespace maldoca { -VirBaseClassOpInterface AstToVir::VisitBaseClass(const VBaseClass *node) { +VirBaseClassOpInterface AstToVir::VisitBaseClass(mlir::OpBuilder &builder, const VBaseClass *node) { if (auto *derived_class1 = dynamic_cast(node)) { - return VisitDerivedClass1(derived_class1); + return VisitDerivedClass1(builder, derived_class1); } if (auto *derived_class2 = dynamic_cast(node)) { - return VisitDerivedClass2(derived_class2); + return VisitDerivedClass2(builder, derived_class2); } LOG(FATAL) << "Unreachable code."; } -VirDerivedClass1Op AstToVir::VisitDerivedClass1(const VDerivedClass1 *node) { - return CreateExpr(node); +VirDerivedClass1Op AstToVir::VisitDerivedClass1(mlir::OpBuilder &builder, const VDerivedClass1 *node) { + return CreateExpr(builder, node); } -VirDerivedClass2Op AstToVir::VisitDerivedClass2(const VDerivedClass2 *node) { - return CreateExpr(node); +VirDerivedClass2Op AstToVir::VisitDerivedClass2(mlir::OpBuilder &builder, const VDerivedClass2 *node) { + return CreateExpr(builder, node); } -VirNodeOp AstToVir::VisitNode(const VNode *node) { +VirNodeOp AstToVir::VisitNode(mlir::OpBuilder &builder, const VNode *node) { mlir::Attribute mlir_simple_variant_builtin; switch (node->simple_variant_builtin().index()) { case 0: { - mlir_simple_variant_builtin = builder_.getF64FloatAttr(std::get<0>(node->simple_variant_builtin())); + mlir_simple_variant_builtin = builder.getF64FloatAttr(std::get<0>(node->simple_variant_builtin())); break; } case 1: { - mlir_simple_variant_builtin = builder_.getStringAttr(std::get<1>(node->simple_variant_builtin())); + mlir_simple_variant_builtin = builder.getStringAttr(std::get<1>(node->simple_variant_builtin())); break; } default: @@ -81,11 +81,11 @@ VirNodeOp AstToVir::VisitNode(const VNode *node) { if (node->nullable_variant_builtin().has_value()) { switch (node->nullable_variant_builtin().value().index()) { case 0: { - mlir_nullable_variant_builtin = builder_.getF64FloatAttr(std::get<0>(node->nullable_variant_builtin().value())); + mlir_nullable_variant_builtin = builder.getF64FloatAttr(std::get<0>(node->nullable_variant_builtin().value())); break; } case 1: { - mlir_nullable_variant_builtin = builder_.getStringAttr(std::get<1>(node->nullable_variant_builtin().value())); + mlir_nullable_variant_builtin = builder.getStringAttr(std::get<1>(node->nullable_variant_builtin().value())); break; } default: @@ -96,11 +96,11 @@ VirNodeOp AstToVir::VisitNode(const VNode *node) { if (node->optional_variant_builtin().has_value()) { switch (node->optional_variant_builtin().value().index()) { case 0: { - mlir_optional_variant_builtin = builder_.getF64FloatAttr(std::get<0>(node->optional_variant_builtin().value())); + mlir_optional_variant_builtin = builder.getF64FloatAttr(std::get<0>(node->optional_variant_builtin().value())); break; } case 1: { - mlir_optional_variant_builtin = builder_.getStringAttr(std::get<1>(node->optional_variant_builtin().value())); + mlir_optional_variant_builtin = builder.getStringAttr(std::get<1>(node->optional_variant_builtin().value())); break; } default: @@ -110,11 +110,11 @@ VirNodeOp AstToVir::VisitNode(const VNode *node) { mlir::Value mlir_simple_variant_class; switch (node->simple_variant_class().index()) { case 0: { - mlir_simple_variant_class = VisitDerivedClass1(std::get<0>(node->simple_variant_class())); + mlir_simple_variant_class = VisitDerivedClass1(builder, std::get<0>(node->simple_variant_class())); break; } case 1: { - mlir_simple_variant_class = VisitDerivedClass2(std::get<1>(node->simple_variant_class())); + mlir_simple_variant_class = VisitDerivedClass2(builder, std::get<1>(node->simple_variant_class())); break; } default: @@ -124,11 +124,11 @@ VirNodeOp AstToVir::VisitNode(const VNode *node) { if (node->nullable_variant_class().has_value()) { switch (node->nullable_variant_class().value().index()) { case 0: { - mlir_nullable_variant_class = VisitDerivedClass1(std::get<0>(node->nullable_variant_class().value())); + mlir_nullable_variant_class = VisitDerivedClass1(builder, std::get<0>(node->nullable_variant_class().value())); break; } case 1: { - mlir_nullable_variant_class = VisitDerivedClass2(std::get<1>(node->nullable_variant_class().value())); + mlir_nullable_variant_class = VisitDerivedClass2(builder, std::get<1>(node->nullable_variant_class().value())); break; } default: @@ -139,18 +139,18 @@ VirNodeOp AstToVir::VisitNode(const VNode *node) { if (node->optional_variant_class().has_value()) { switch (node->optional_variant_class().value().index()) { case 0: { - mlir_optional_variant_class = VisitDerivedClass1(std::get<0>(node->optional_variant_class().value())); + mlir_optional_variant_class = VisitDerivedClass1(builder, std::get<0>(node->optional_variant_class().value())); break; } case 1: { - mlir_optional_variant_class = VisitDerivedClass2(std::get<1>(node->optional_variant_class().value())); + mlir_optional_variant_class = VisitDerivedClass2(builder, std::get<1>(node->optional_variant_class().value())); break; } default: LOG(FATAL) << "Unreachable code."; } } - return CreateExpr(node, mlir_simple_variant_builtin, mlir_nullable_variant_builtin, mlir_optional_variant_builtin, mlir_simple_variant_class, mlir_nullable_variant_class, mlir_optional_variant_class); + return CreateExpr(builder, node, mlir_simple_variant_builtin, mlir_nullable_variant_builtin, mlir_optional_variant_builtin, mlir_simple_variant_class, mlir_nullable_variant_class, mlir_optional_variant_class); } // clang-format on diff --git a/maldoca/astgen/test/variant/conversion/ast_to_vir.h b/maldoca/astgen/test/variant/conversion/ast_to_vir.h index a295bbd..1fff224 100644 --- a/maldoca/astgen/test/variant/conversion/ast_to_vir.h +++ b/maldoca/astgen/test/variant/conversion/ast_to_vir.h @@ -23,24 +23,24 @@ namespace maldoca { class AstToVir { public: - explicit AstToVir(mlir::OpBuilder &builder) : builder_(builder) {} + static VirBaseClassOpInterface VisitBaseClass(mlir::OpBuilder& builder, + const VBaseClass* node); - VirBaseClassOpInterface VisitBaseClass(const VBaseClass *node); + static VirDerivedClass1Op VisitDerivedClass1(mlir::OpBuilder& builder, + const VDerivedClass1* node); - VirDerivedClass1Op VisitDerivedClass1(const VDerivedClass1 *node); + static VirDerivedClass2Op VisitDerivedClass2(mlir::OpBuilder& builder, + const VDerivedClass2* node); - VirDerivedClass2Op VisitDerivedClass2(const VDerivedClass2 *node); - - VirNodeOp VisitNode(const VNode *node); + static VirNodeOp VisitNode(mlir::OpBuilder& builder, const VNode* node); private: template - Op CreateExpr(const VNode *node, Args &&...args) { - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + static Op CreateExpr(mlir::OpBuilder& builder, const VNode* node, + Args&&... args) { + return Op::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/astgen/test/variant/conversion/conversion_test.cc b/maldoca/astgen/test/variant/conversion/conversion_test.cc index 037047b..dc0c281 100644 --- a/maldoca/astgen/test/variant/conversion/conversion_test.cc +++ b/maldoca/astgen/test/variant/conversion/conversion_test.cc @@ -49,9 +49,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToVir::VisitNode, + .ast_to_ir_visit = AstToVir::VisitNode, .ir_to_ast_visit = &VirToAst::VisitNode, .expected_ir_dump = kExpectedIr, }); @@ -84,9 +84,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToVir::VisitNode, + .ast_to_ir_visit = AstToVir::VisitNode, .ir_to_ast_visit = &VirToAst::VisitNode, .expected_ir_dump = kExpectedIr, }); @@ -111,9 +111,9 @@ module { } )"; - TestIrConversion({ + TestIrConversion({ .ast_json_string = kAstJsonString, - .ast_to_ir_visit = &AstToVir::VisitNode, + .ast_to_ir_visit = AstToVir::VisitNode, .ir_to_ast_visit = &VirToAst::VisitNode, .expected_ir_dump = kExpectedIr, }); diff --git a/maldoca/astgen/test/variant/conversion/vir_to_ast.generated.cc b/maldoca/astgen/test/variant/conversion/vir_to_ast.generated.cc index b0cac49..3c06ec4 100644 --- a/maldoca/astgen/test/variant/conversion/vir_to_ast.generated.cc +++ b/maldoca/astgen/test/variant/conversion/vir_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/astgen/test/variant/ast.generated.h" #include "maldoca/astgen/test/variant/ir.h" @@ -83,62 +84,74 @@ VirToAst::VisitDerivedClass2(VirDerivedClass2Op op) { absl::StatusOr> VirToAst::VisitNode(VirNodeOp op) { - std::variant simple_variant_builtin; - if (auto mlir_simple_variant_builtin = llvm::dyn_cast(op.getSimpleVariantBuiltinAttr())) { - simple_variant_builtin = mlir_simple_variant_builtin.getValueAsDouble(); - } else if (auto mlir_simple_variant_builtin = llvm::dyn_cast(op.getSimpleVariantBuiltinAttr())) { - simple_variant_builtin = mlir_simple_variant_builtin.str(); - } else { - return absl::InvalidArgumentError("op.getSimpleVariantBuiltinAttr() has invalid type."); - } - std::optional> nullable_variant_builtin; - if (op.getNullableVariantBuiltinAttr() != nullptr) { - if (auto mlir_nullable_variant_builtin = llvm::dyn_cast(op.getNullableVariantBuiltinAttr())) { - nullable_variant_builtin = mlir_nullable_variant_builtin.getValueAsDouble(); - } else if (auto mlir_nullable_variant_builtin = llvm::dyn_cast(op.getNullableVariantBuiltinAttr())) { - nullable_variant_builtin = mlir_nullable_variant_builtin.str(); - } else { - return absl::InvalidArgumentError("op.getNullableVariantBuiltinAttr() has invalid type."); - } - } - std::optional> optional_variant_builtin; - if (op.getOptionalVariantBuiltinAttr() != nullptr) { - if (auto mlir_optional_variant_builtin = llvm::dyn_cast(op.getOptionalVariantBuiltinAttr())) { - optional_variant_builtin = mlir_optional_variant_builtin.getValueAsDouble(); - } else if (auto mlir_optional_variant_builtin = llvm::dyn_cast(op.getOptionalVariantBuiltinAttr())) { - optional_variant_builtin = mlir_optional_variant_builtin.str(); - } else { - return absl::InvalidArgumentError("op.getOptionalVariantBuiltinAttr() has invalid type."); - } - } - std::variant, std::unique_ptr> simple_variant_class; - if (auto mlir_simple_variant_class = llvm::dyn_cast(op.getSimpleVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(simple_variant_class, VisitDerivedClass1(mlir_simple_variant_class)); - } else if (auto mlir_simple_variant_class = llvm::dyn_cast(op.getSimpleVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(simple_variant_class, VisitDerivedClass2(mlir_simple_variant_class)); - } else { - return absl::InvalidArgumentError("op.getSimpleVariantClass().getDefiningOp() has invalid type."); - } - std::optional, std::unique_ptr>> nullable_variant_class; - if (op.getNullableVariantClass() != nullptr) { - if (auto mlir_nullable_variant_class = llvm::dyn_cast(op.getNullableVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(nullable_variant_class, VisitDerivedClass1(mlir_nullable_variant_class)); - } else if (auto mlir_nullable_variant_class = llvm::dyn_cast(op.getNullableVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(nullable_variant_class, VisitDerivedClass2(mlir_nullable_variant_class)); - } else { - return absl::InvalidArgumentError("op.getNullableVariantClass().getDefiningOp() has invalid type."); - } - } - std::optional, std::unique_ptr>> optional_variant_class; - if (op.getOptionalVariantClass() != nullptr) { - if (auto mlir_optional_variant_class = llvm::dyn_cast(op.getOptionalVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(optional_variant_class, VisitDerivedClass1(mlir_optional_variant_class)); - } else if (auto mlir_optional_variant_class = llvm::dyn_cast(op.getOptionalVariantClass().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(optional_variant_class, VisitDerivedClass2(mlir_optional_variant_class)); - } else { - return absl::InvalidArgumentError("op.getOptionalVariantClass().getDefiningOp() has invalid type."); - } - } + MALDOCA_ASSIGN_OR_RETURN( + auto simple_variant_builtin, + Convert( + op.getSimpleVariantBuiltinAttr(), + AttrVariant( + ToDouble(), + ToString() + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto nullable_variant_builtin, + Convert( + op.getNullableVariantBuiltinAttr(), + Nullable( + AttrVariant( + ToDouble(), + ToString() + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto optional_variant_builtin, + Convert( + op.getOptionalVariantBuiltinAttr(), + Nullable( + AttrVariant( + ToDouble(), + ToString() + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto simple_variant_class, + Convert( + op.getSimpleVariantClass(), + OpVariant( + ToOpConverter(VisitDerivedClass1), + ToOpConverter(VisitDerivedClass2) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto nullable_variant_class, + Convert( + op.getNullableVariantClass(), + Nullable( + OpVariant( + ToOpConverter(VisitDerivedClass1), + ToOpConverter(VisitDerivedClass2) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto optional_variant_class, + Convert( + op.getOptionalVariantClass(), + Nullable( + OpVariant( + ToOpConverter(VisitDerivedClass1), + ToOpConverter(VisitDerivedClass2) + ) + ) + ) + ); return Create( op, std::move(simple_variant_builtin), diff --git a/maldoca/astgen/test/variant/conversion/vir_to_ast.h b/maldoca/astgen/test/variant/conversion/vir_to_ast.h index d98e17a..1a98e5d 100644 --- a/maldoca/astgen/test/variant/conversion/vir_to_ast.h +++ b/maldoca/astgen/test/variant/conversion/vir_to_ast.h @@ -26,20 +26,20 @@ namespace maldoca { class VirToAst { public: - absl::StatusOr> VisitBaseClass( + static absl::StatusOr> VisitBaseClass( VirBaseClassOpInterface op); - absl::StatusOr> VisitDerivedClass1( + static absl::StatusOr> VisitDerivedClass1( VirDerivedClass1Op op); - absl::StatusOr> VisitDerivedClass2( + static absl::StatusOr> VisitDerivedClass2( VirDerivedClass2Op op); - absl::StatusOr> VisitNode(VirNodeOp op); + static absl::StatusOr> VisitNode(VirNodeOp op); private: template - std::unique_ptr Create(mlir::Operation *op, Args &&...args) { + static std::unique_ptr Create(mlir::Operation *op, Args &&...args) { return absl::make_unique(std::forward(args)...); } }; diff --git a/maldoca/astgen/test/variant/vir_dialect.td b/maldoca/astgen/test/variant/vir_dialect.td index 516b479..ae0827a 100644 --- a/maldoca/astgen/test/variant/vir_dialect.td +++ b/maldoca/astgen/test/variant/vir_dialect.td @@ -39,4 +39,6 @@ class Vir_Type traits = [], class Vir_Op traits = []> : Op; +def VirNoneOp : Vir_Op<"none", []> {} + #endif // MALDOCA_ASTGEN_TEST_VARIANT_VIR_DIALECT_TD_ diff --git a/maldoca/astgen/ts_interface_printer.cc b/maldoca/astgen/ts_interface_printer.cc new file mode 100644 index 0000000..41a7b9a --- /dev/null +++ b/maldoca/astgen/ts_interface_printer.cc @@ -0,0 +1,116 @@ +// 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 "maldoca/astgen/ts_interface_printer.h" + +#include + +#include "absl/strings/escaping.h" +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/ast_def.pb.h" +#include "maldoca/astgen/ast_gen_utils.h" +#include "maldoca/astgen/type.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" + +namespace maldoca { + +void TsInterfacePrinter::PrintAst(const AstDef& ast) { + for (const EnumDef& enum_def : ast.enum_defs()) { + PrintEnum(enum_def, ast.lang_name()); + Println(); + } + + for (const auto& name : ast.node_names()) { + const NodeDef& node = *ast.nodes().at(name); + PrintNode(node); + Println(); + } +} + +void TsInterfacePrinter::PrintEnum(const EnumDef& enum_def, + absl::string_view lang_name) { + auto vars = WithVars({ + {"EnumName", enum_def.name().ToPascalCase()}, + }); + + Println("type $EnumName$ ="); + { + auto indent = WithIndent(4); + for (const EnumMemberDef& member : enum_def.members()) { + auto vars = WithVars({ + {"string_value", absl::CEscape(member.string_value())}, + }); + + Println("| \"$string_value$\""); + } + } +} + +void TsInterfacePrinter::PrintNode(const NodeDef& node) { + auto vars = WithVars({ + {"NodeType", node.name()}, + }); + Print("interface $NodeType$"); + + if (!node.parents().empty()) { + Print(" <: "); + + TabPrinter separator_printer{{ + .print_separator = [&] { Print(", "); }, + }}; + for (const NodeDef* parent : node.parents()) { + separator_printer.Print(); + Print(parent->name()); + } + } + + Println(" {"); + { + auto indent = WithIndent(); + for (const FieldDef& field : node.fields()) { + PrintFieldDef(field); + } + } + Println("}"); +} + +void TsInterfacePrinter::PrintFieldDef(const FieldDef& field) { + Print(field.name().ToCamelCase()); + + if (field.optionalness() == OPTIONALNESS_MAYBE_UNDEFINED) { + Print("?"); + } + + Print(": "); + + MaybeNull maybe_null = field.optionalness() == OPTIONALNESS_MAYBE_NULL + ? MaybeNull::kYes + : MaybeNull::kNo; + Print(field.type().JsType(maybe_null)); + + Println(); +} + +std::string PrintTsInterface(const AstDef& ast) { + std::string ts_interface; + { + google::protobuf::io::StringOutputStream os(&ts_interface); + TsInterfacePrinter printer(&os); + printer.PrintAst(ast); + } + return ts_interface; +} + +} // namespace maldoca diff --git a/maldoca/astgen/ts_interface_printer.h b/maldoca/astgen/ts_interface_printer.h new file mode 100644 index 0000000..6419768 --- /dev/null +++ b/maldoca/astgen/ts_interface_printer.h @@ -0,0 +1,75 @@ +// 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. + +#ifndef MALDOCA_ASTGEN_TS_INTERFACE_PRINTER_H_ +#define MALDOCA_ASTGEN_TS_INTERFACE_PRINTER_H_ + +#include + +#include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_def.h" +#include "maldoca/astgen/printer_base.h" +#include "google/protobuf/io/zero_copy_stream.h" + +namespace maldoca { + +// Printer of the TypeScript interface definition for the AST. +// +// Format: +// +// interface ObjectMember <: Node { +// key: Expression; +// computed: boolean; +// decorators?: [ Decorator ]; +// } +class TsInterfacePrinter : AstGenPrinterBase { + public: + explicit TsInterfacePrinter(google::protobuf::io::ZeroCopyOutputStream* os) + : AstGenPrinterBase(os) {} + + // Prints the "ast_ts_interface.generated" file. + // + // See test cases in test/ for examples. + void PrintAst(const AstDef& ast); + + // Prints an enum definition. + // + // See test cases in test/ for examples. + void PrintEnum(const EnumDef& enum_def, absl::string_view lang_name); + + // Prints the class declaration for a node. + // + // See test cases in test/ for examples. + void PrintNode(const NodeDef& node); + + // Prints the definition of a field. + // + // Format: + // : + // ?: + // + // - fieldName: Printed as camelCase. + // - js_type: See `Type::JsType()`. + // + // Example: + // right: Expression + // param?: Pattern + void PrintFieldDef(const FieldDef& field); +}; + +std::string PrintTsInterface(const AstDef& ast); + +} // namespace maldoca + +#endif // MALDOCA_ASTGEN_TS_INTERFACE_PRINTER_H_ diff --git a/maldoca/astgen/type.cc b/maldoca/astgen/type.cc index 704c6ee..ccf5c3f 100644 --- a/maldoca/astgen/type.cc +++ b/maldoca/astgen/type.cc @@ -289,8 +289,7 @@ std::string EnumType::CcType() const { } std::string ClassType::CcType() const { - return absl::StrCat("std::unique_ptr<", - (Symbol(lang_name_) + name()).ToPascalCase(), ">"); + return absl::StrCat("std::unique_ptr<", CcClassName(), ">"); } // ============================================================================= @@ -378,12 +377,11 @@ std::string EnumType::CcGetterType(CcGetterKind getter_kind) const { } std::string ClassType::CcGetterType(CcGetterKind getter_kind) const { - const auto class_name = (Symbol(lang_name_) + name()).ToPascalCase(); switch (getter_kind) { case CcGetterKind::kMutable: - return absl::StrCat(class_name, "*"); + return absl::StrCat(CcClassName(), "*"); case CcGetterKind::kConst: - return absl::StrCat("const ", class_name, "*"); + return absl::StrCat("const ", CcClassName(), "*"); } } diff --git a/maldoca/astgen/type.h b/maldoca/astgen/type.h index d01ef7d..21c31a0 100644 --- a/maldoca/astgen/type.h +++ b/maldoca/astgen/type.h @@ -553,6 +553,10 @@ class ClassType : public ScalarType { std::string JsType() const override; + std::string CcClassName() const { + return (Symbol(lang_name_) + name()).ToPascalCase(); + } + std::string CcType() const override; std::string CcGetterType(CcGetterKind getter_kind) const override; diff --git a/maldoca/base/get_runfiles_dir.cc b/maldoca/base/get_runfiles_dir.cc index 30cb756..42e260e 100644 --- a/maldoca/base/get_runfiles_dir.cc +++ b/maldoca/base/get_runfiles_dir.cc @@ -32,8 +32,6 @@ std::string GetDataDependencyFilepath(absl::string_view path) { return runfiles->Rlocation(JoinPath("com_google_maldoca", path)); } -std::string GetRunfilesDir() { - return GetDataDependencyFilepath(""); -} +std::string GetRunfilesDir() { return GetDataDependencyFilepath(""); } } // namespace maldoca diff --git a/maldoca/base/status_builder.h b/maldoca/base/status_builder.h index b55f806..6358999 100644 --- a/maldoca/base/status_builder.h +++ b/maldoca/base/status_builder.h @@ -266,7 +266,7 @@ class ABSL_MUST_USE_RESULT StatusBuilder { } template auto With(Adaptor&& adaptor) && -> decltype(std::forward(adaptor)( - std::move(*this))) { + std::move(*this))) { return std::forward(adaptor)(std::move(*this)); } diff --git a/maldoca/js/ast/BUILD b/maldoca/js/ast/BUILD index 8d3ab9a..67dd098 100644 --- a/maldoca/js/ast/BUILD +++ b/maldoca/js/ast/BUILD @@ -33,6 +33,7 @@ cc_library( ], hdrs = ["ast.generated.h"], deps = [ + "//maldoca/astgen:ast_from_json_utils", "//maldoca/base:status", "@abseil-cpp//absl/container:flat_hash_map", "@abseil-cpp//absl/container:flat_hash_set", diff --git a/maldoca/js/ast/ast_from_json.generated.cc b/maldoca/js/ast/ast_from_json.generated.cc index 6c95333..3e47fb2 100644 --- a/maldoca/js/ast/ast_from_json.generated.cc +++ b/maldoca/js/ast/ast_from_json.generated.cc @@ -35,62 +35,32 @@ #include "absl/status/statusor.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "maldoca/astgen/ast_from_json_utils.h" #include "maldoca/base/status_macros.h" #include "nlohmann/json.hpp" namespace maldoca { -static absl::StatusOr GetType(const nlohmann::json& json) { - auto type_it = json.find("type"); - if (type_it == json.end()) { - return absl::InvalidArgumentError("`type` is undefined."); - } - const nlohmann::json& json_type = type_it.value(); - if (json_type.is_null()) { - return absl::InvalidArgumentError("json_type is null."); - } - if (!json_type.is_string()) { - return absl::InvalidArgumentError("`json_type` expected to be string."); - } - return json_type.get(); -} - // ============================================================================= // JsPosition // ============================================================================= absl::StatusOr JsPosition::GetLine(const nlohmann::json& json) { - auto line_it = json.find("line"); - if (line_it == json.end()) { - return absl::InvalidArgumentError("`line` is undefined."); - } - const nlohmann::json& json_line = line_it.value(); - - if (json_line.is_null()) { - return absl::InvalidArgumentError("json_line is null."); - } - if (!json_line.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_line.is_number_integer()."); - } - return json_line.get(); + return GetRequiredField( + json, + "line", + JsonToInt64 + ); } absl::StatusOr JsPosition::GetColumn(const nlohmann::json& json) { - auto column_it = json.find("column"); - if (column_it == json.end()) { - return absl::InvalidArgumentError("`column` is undefined."); - } - const nlohmann::json& json_column = column_it.value(); - - if (json_column.is_null()) { - return absl::InvalidArgumentError("json_column is null."); - } - if (!json_column.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_column.is_number_integer()."); - } - return json_column.get(); + return GetRequiredField( + json, + "column", + JsonToInt64 + ); } absl::StatusOr> @@ -113,47 +83,29 @@ JsPosition::FromJson(const nlohmann::json& json) { absl::StatusOr> JsSourceLocation::GetStart(const nlohmann::json& json) { - auto start_it = json.find("start"); - if (start_it == json.end()) { - return absl::InvalidArgumentError("`start` is undefined."); - } - const nlohmann::json& json_start = start_it.value(); - - if (json_start.is_null()) { - return absl::InvalidArgumentError("json_start is null."); - } - return JsPosition::FromJson(json_start); + return GetRequiredField>( + json, + "start", + JsPosition::FromJson + ); } absl::StatusOr> JsSourceLocation::GetEnd(const nlohmann::json& json) { - auto end_it = json.find("end"); - if (end_it == json.end()) { - return absl::InvalidArgumentError("`end` is undefined."); - } - const nlohmann::json& json_end = end_it.value(); - - if (json_end.is_null()) { - return absl::InvalidArgumentError("json_end is null."); - } - return JsPosition::FromJson(json_end); + return GetRequiredField>( + json, + "end", + JsPosition::FromJson + ); } absl::StatusOr> JsSourceLocation::GetIdentifierName(const nlohmann::json& json) { - auto identifier_name_it = json.find("identifierName"); - if (identifier_name_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_identifier_name = identifier_name_it.value(); - - if (json_identifier_name.is_null()) { - return absl::InvalidArgumentError("json_identifier_name is null."); - } - if (!json_identifier_name.is_string()) { - return absl::InvalidArgumentError("Expecting json_identifier_name.is_string()."); - } - return json_identifier_name.get(); + return GetOptionalField( + json, + "identifierName", + JsonToString + ); } absl::StatusOr> @@ -178,67 +130,38 @@ JsSourceLocation::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsComment::GetLoc(const nlohmann::json& json) { - auto loc_it = json.find("loc"); - if (loc_it == json.end()) { - return absl::InvalidArgumentError("`loc` is undefined."); - } - const nlohmann::json& json_loc = loc_it.value(); - - if (json_loc.is_null()) { - return std::nullopt; - } - return JsSourceLocation::FromJson(json_loc); + return GetNullableField>( + json, + "loc", + JsSourceLocation::FromJson + ); } absl::StatusOr JsComment::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_value.is_string()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToString + ); } absl::StatusOr> JsComment::GetStart(const nlohmann::json& json) { - auto start_it = json.find("start"); - if (start_it == json.end()) { - return absl::InvalidArgumentError("`start` is undefined."); - } - const nlohmann::json& json_start = start_it.value(); - - if (json_start.is_null()) { - return std::nullopt; - } - if (!json_start.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_start.is_number_integer()."); - } - return json_start.get(); + return GetNullableField( + json, + "start", + JsonToInt64 + ); } absl::StatusOr> JsComment::GetEnd(const nlohmann::json& json) { - auto end_it = json.find("end"); - if (end_it == json.end()) { - return absl::InvalidArgumentError("`end` is undefined."); - } - const nlohmann::json& json_end = end_it.value(); - - if (json_end.is_null()) { - return std::nullopt; - } - if (!json_end.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_end.is_number_integer()."); - } - return json_end.get(); + return GetNullableField( + json, + "end", + JsonToInt64 + ); } absl::StatusOr> @@ -307,36 +230,20 @@ JsCommentLine::FromJson(const nlohmann::json& json) { absl::StatusOr JsSymbolId::GetName(const nlohmann::json& json) { - auto name_it = json.find("name"); - if (name_it == json.end()) { - return absl::InvalidArgumentError("`name` is undefined."); - } - const nlohmann::json& json_name = name_it.value(); - - if (json_name.is_null()) { - return absl::InvalidArgumentError("json_name is null."); - } - if (!json_name.is_string()) { - return absl::InvalidArgumentError("Expecting json_name.is_string()."); - } - return json_name.get(); + return GetRequiredField( + json, + "name", + JsonToString + ); } absl::StatusOr> JsSymbolId::GetDefScopeUid(const nlohmann::json& json) { - auto def_scope_uid_it = json.find("defScopeUid"); - if (def_scope_uid_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_def_scope_uid = def_scope_uid_it.value(); - - if (json_def_scope_uid.is_null()) { - return absl::InvalidArgumentError("json_def_scope_uid is null."); - } - if (!json_def_scope_uid.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_def_scope_uid.is_number_integer()."); - } - return json_def_scope_uid.get(); + return GetOptionalField( + json, + "defScopeUid", + JsonToInt64 + ); } absl::StatusOr> @@ -359,194 +266,91 @@ JsSymbolId::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsNode::GetLoc(const nlohmann::json& json) { - auto loc_it = json.find("loc"); - if (loc_it == json.end()) { - return absl::InvalidArgumentError("`loc` is undefined."); - } - const nlohmann::json& json_loc = loc_it.value(); - - if (json_loc.is_null()) { - return std::nullopt; - } - return JsSourceLocation::FromJson(json_loc); + return GetNullableField>( + json, + "loc", + JsSourceLocation::FromJson + ); } absl::StatusOr> JsNode::GetStart(const nlohmann::json& json) { - auto start_it = json.find("start"); - if (start_it == json.end()) { - return absl::InvalidArgumentError("`start` is undefined."); - } - const nlohmann::json& json_start = start_it.value(); - - if (json_start.is_null()) { - return std::nullopt; - } - if (!json_start.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_start.is_number_integer()."); - } - return json_start.get(); + return GetNullableField( + json, + "start", + JsonToInt64 + ); } absl::StatusOr> JsNode::GetEnd(const nlohmann::json& json) { - auto end_it = json.find("end"); - if (end_it == json.end()) { - return absl::InvalidArgumentError("`end` is undefined."); - } - const nlohmann::json& json_end = end_it.value(); - - if (json_end.is_null()) { - return std::nullopt; - } - if (!json_end.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_end.is_number_integer()."); - } - return json_end.get(); + return GetNullableField( + json, + "end", + JsonToInt64 + ); } absl::StatusOr>> JsNode::GetLeadingCommentUids(const nlohmann::json& json) { - auto leading_comment_uids_it = json.find("leadingCommentUids"); - if (leading_comment_uids_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_leading_comment_uids = leading_comment_uids_it.value(); - - if (json_leading_comment_uids.is_null()) { - return absl::InvalidArgumentError("json_leading_comment_uids is null."); - } - if (!json_leading_comment_uids.is_array()) { - return absl::InvalidArgumentError("json_leading_comment_uids expected to be array."); - } - - std::vector leading_comment_uids; - for (const nlohmann::json& json_leading_comment_uids_element : json_leading_comment_uids) { - if (json_leading_comment_uids_element.is_null()) { - return absl::InvalidArgumentError("json_leading_comment_uids_element is null."); - } - if (!json_leading_comment_uids_element.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_leading_comment_uids_element.is_number_integer()."); - } - auto leading_comment_uids_element = json_leading_comment_uids_element.get(); - leading_comment_uids.push_back(std::move(leading_comment_uids_element)); - } - return leading_comment_uids; + return GetOptionalField>( + json, + "leadingCommentUids", + List( + JsonToInt64 + ) + ); } absl::StatusOr>> JsNode::GetTrailingCommentUids(const nlohmann::json& json) { - auto trailing_comment_uids_it = json.find("trailingCommentUids"); - if (trailing_comment_uids_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_trailing_comment_uids = trailing_comment_uids_it.value(); - - if (json_trailing_comment_uids.is_null()) { - return absl::InvalidArgumentError("json_trailing_comment_uids is null."); - } - if (!json_trailing_comment_uids.is_array()) { - return absl::InvalidArgumentError("json_trailing_comment_uids expected to be array."); - } - - std::vector trailing_comment_uids; - for (const nlohmann::json& json_trailing_comment_uids_element : json_trailing_comment_uids) { - if (json_trailing_comment_uids_element.is_null()) { - return absl::InvalidArgumentError("json_trailing_comment_uids_element is null."); - } - if (!json_trailing_comment_uids_element.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_trailing_comment_uids_element.is_number_integer()."); - } - auto trailing_comment_uids_element = json_trailing_comment_uids_element.get(); - trailing_comment_uids.push_back(std::move(trailing_comment_uids_element)); - } - return trailing_comment_uids; + return GetOptionalField>( + json, + "trailingCommentUids", + List( + JsonToInt64 + ) + ); } absl::StatusOr>> JsNode::GetInnerCommentUids(const nlohmann::json& json) { - auto inner_comment_uids_it = json.find("innerCommentUids"); - if (inner_comment_uids_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_inner_comment_uids = inner_comment_uids_it.value(); - - if (json_inner_comment_uids.is_null()) { - return absl::InvalidArgumentError("json_inner_comment_uids is null."); - } - if (!json_inner_comment_uids.is_array()) { - return absl::InvalidArgumentError("json_inner_comment_uids expected to be array."); - } - - std::vector inner_comment_uids; - for (const nlohmann::json& json_inner_comment_uids_element : json_inner_comment_uids) { - if (json_inner_comment_uids_element.is_null()) { - return absl::InvalidArgumentError("json_inner_comment_uids_element is null."); - } - if (!json_inner_comment_uids_element.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_inner_comment_uids_element.is_number_integer()."); - } - auto inner_comment_uids_element = json_inner_comment_uids_element.get(); - inner_comment_uids.push_back(std::move(inner_comment_uids_element)); - } - return inner_comment_uids; + return GetOptionalField>( + json, + "innerCommentUids", + List( + JsonToInt64 + ) + ); } absl::StatusOr> JsNode::GetScopeUid(const nlohmann::json& json) { - auto scope_uid_it = json.find("scopeUid"); - if (scope_uid_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_scope_uid = scope_uid_it.value(); - - if (json_scope_uid.is_null()) { - return absl::InvalidArgumentError("json_scope_uid is null."); - } - if (!json_scope_uid.is_number_integer()) { - return absl::InvalidArgumentError("Expecting json_scope_uid.is_number_integer()."); - } - return json_scope_uid.get(); + return GetOptionalField( + json, + "scopeUid", + JsonToInt64 + ); } absl::StatusOr>> JsNode::GetReferencedSymbol(const nlohmann::json& json) { - auto referenced_symbol_it = json.find("referencedSymbol"); - if (referenced_symbol_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_referenced_symbol = referenced_symbol_it.value(); - - if (json_referenced_symbol.is_null()) { - return absl::InvalidArgumentError("json_referenced_symbol is null."); - } - return JsSymbolId::FromJson(json_referenced_symbol); + return GetOptionalField>( + json, + "referencedSymbol", + JsSymbolId::FromJson + ); } absl::StatusOr>>> JsNode::GetDefinedSymbols(const nlohmann::json& json) { - auto defined_symbols_it = json.find("definedSymbols"); - if (defined_symbols_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_defined_symbols = defined_symbols_it.value(); - - if (json_defined_symbols.is_null()) { - return absl::InvalidArgumentError("json_defined_symbols is null."); - } - if (!json_defined_symbols.is_array()) { - return absl::InvalidArgumentError("json_defined_symbols expected to be array."); - } - - std::vector> defined_symbols; - for (const nlohmann::json& json_defined_symbols_element : json_defined_symbols) { - if (json_defined_symbols_element.is_null()) { - return absl::InvalidArgumentError("json_defined_symbols_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto defined_symbols_element, JsSymbolId::FromJson(json_defined_symbols_element)); - defined_symbols.push_back(std::move(defined_symbols_element)); - } - return defined_symbols; + return GetOptionalField>>( + json, + "definedSymbols", + List>( + JsSymbolId::FromJson + ) + ); } absl::StatusOr> @@ -763,19 +567,11 @@ JsNode::FromJson(const nlohmann::json& json) { absl::StatusOr JsInterpreterDirective::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_value.is_string()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToString + ); } absl::StatusOr> @@ -886,36 +682,20 @@ JsProgramBodyElement::FromJson(const nlohmann::json& json) { absl::StatusOr JsDirectiveLiteralExtra::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr JsDirectiveLiteralExtra::GetRawValue(const nlohmann::json& json) { - auto raw_value_it = json.find("rawValue"); - if (raw_value_it == json.end()) { - return absl::InvalidArgumentError("`rawValue` is undefined."); - } - const nlohmann::json& json_raw_value = raw_value_it.value(); - - if (json_raw_value.is_null()) { - return absl::InvalidArgumentError("json_raw_value is null."); - } - if (!json_raw_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw_value.is_string()."); - } - return json_raw_value.get(); + return GetRequiredField( + json, + "rawValue", + JsonToString + ); } absl::StatusOr> @@ -938,33 +718,20 @@ JsDirectiveLiteralExtra::FromJson(const nlohmann::json& json) { absl::StatusOr JsDirectiveLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_value.is_string()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToString + ); } absl::StatusOr>> JsDirectiveLiteral::GetExtra(const nlohmann::json& json) { - auto extra_it = json.find("extra"); - if (extra_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_extra = extra_it.value(); - - if (json_extra.is_null()) { - return absl::InvalidArgumentError("json_extra is null."); - } - return JsDirectiveLiteralExtra::FromJson(json_extra); + return GetOptionalField>( + json, + "extra", + JsDirectiveLiteralExtra::FromJson + ); } absl::StatusOr> @@ -1005,16 +772,11 @@ JsDirectiveLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr> JsDirective::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - return JsDirectiveLiteral::FromJson(json_value); + return GetRequiredField>( + json, + "value", + JsDirectiveLiteral::FromJson + ); } absl::StatusOr> @@ -1053,85 +815,42 @@ JsDirective::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsProgram::GetInterpreter(const nlohmann::json& json) { - auto interpreter_it = json.find("interpreter"); - if (interpreter_it == json.end()) { - return absl::InvalidArgumentError("`interpreter` is undefined."); - } - const nlohmann::json& json_interpreter = interpreter_it.value(); - - if (json_interpreter.is_null()) { - return std::nullopt; - } - return JsInterpreterDirective::FromJson(json_interpreter); + return GetNullableField>( + json, + "interpreter", + JsInterpreterDirective::FromJson + ); } absl::StatusOr JsProgram::GetSourceType(const nlohmann::json& json) { - auto source_type_it = json.find("sourceType"); - if (source_type_it == json.end()) { - return absl::InvalidArgumentError("`sourceType` is undefined."); - } - const nlohmann::json& json_source_type = source_type_it.value(); - - if (json_source_type.is_null()) { - return absl::InvalidArgumentError("json_source_type is null."); - } - if (!json_source_type.is_string()) { - return absl::InvalidArgumentError("Expecting json_source_type.is_string()."); - } - return json_source_type.get(); + return GetRequiredField( + json, + "sourceType", + JsonToString + ); } absl::StatusOr>> JsProgram::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - if (!json_body.is_array()) { - return absl::InvalidArgumentError("json_body expected to be array."); - } - - std::vector> body; - for (const nlohmann::json& json_body_element : json_body) { - if (json_body_element.is_null()) { - return absl::InvalidArgumentError("json_body_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto body_element, JsProgramBodyElement::FromJson(json_body_element)); - body.push_back(std::move(body_element)); - } - return body; + return GetRequiredField>>( + json, + "body", + List>( + JsProgramBodyElement::FromJson + ) + ); } absl::StatusOr>> JsProgram::GetDirectives(const nlohmann::json& json) { - auto directives_it = json.find("directives"); - if (directives_it == json.end()) { - return absl::InvalidArgumentError("`directives` is undefined."); - } - const nlohmann::json& json_directives = directives_it.value(); - - if (json_directives.is_null()) { - return absl::InvalidArgumentError("json_directives is null."); - } - if (!json_directives.is_array()) { - return absl::InvalidArgumentError("json_directives expected to be array."); - } - - std::vector> directives; - for (const nlohmann::json& json_directives_element : json_directives) { - if (json_directives_element.is_null()) { - return absl::InvalidArgumentError("json_directives_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto directives_element, JsDirective::FromJson(json_directives_element)); - directives.push_back(std::move(directives_element)); - } - return directives; + return GetRequiredField>>( + json, + "directives", + List>( + JsDirective::FromJson + ) + ); } absl::StatusOr> @@ -1176,42 +895,22 @@ JsProgram::FromJson(const nlohmann::json& json) { absl::StatusOr> JsFile::GetProgram(const nlohmann::json& json) { - auto program_it = json.find("program"); - if (program_it == json.end()) { - return absl::InvalidArgumentError("`program` is undefined."); - } - const nlohmann::json& json_program = program_it.value(); - - if (json_program.is_null()) { - return absl::InvalidArgumentError("json_program is null."); - } - return JsProgram::FromJson(json_program); + return GetRequiredField>( + json, + "program", + JsProgram::FromJson + ); } absl::StatusOr>>> JsFile::GetComments(const nlohmann::json& json) { - auto comments_it = json.find("comments"); - if (comments_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_comments = comments_it.value(); - - if (json_comments.is_null()) { - return absl::InvalidArgumentError("json_comments is null."); - } - if (!json_comments.is_array()) { - return absl::InvalidArgumentError("json_comments expected to be array."); - } - - std::vector> comments; - for (const nlohmann::json& json_comments_element : json_comments) { - if (json_comments_element.is_null()) { - return absl::InvalidArgumentError("json_comments_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto comments_element, JsComment::FromJson(json_comments_element)); - comments.push_back(std::move(comments_element)); - } - return comments; + return GetOptionalField>>( + json, + "comments", + List>( + JsComment::FromJson + ) + ); } absl::StatusOr> @@ -1510,19 +1209,11 @@ static bool IsIdentifier(const nlohmann::json& json) { absl::StatusOr JsIdentifier::GetName(const nlohmann::json& json) { - auto name_it = json.find("name"); - if (name_it == json.end()) { - return absl::InvalidArgumentError("`name` is undefined."); - } - const nlohmann::json& json_name = name_it.value(); - - if (json_name.is_null()) { - return absl::InvalidArgumentError("json_name is null."); - } - if (!json_name.is_string()) { - return absl::InvalidArgumentError("Expecting json_name.is_string()."); - } - return json_name.get(); + return GetRequiredField( + json, + "name", + JsonToString + ); } absl::StatusOr> @@ -1577,16 +1268,11 @@ static bool IsPrivateName(const nlohmann::json& json) { absl::StatusOr> JsPrivateName::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return absl::InvalidArgumentError("json_id is null."); - } - return JsIdentifier::FromJson(json_id); + return GetRequiredField>( + json, + "id", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -1653,19 +1339,11 @@ JsLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr JsRegExpLiteralExtra::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr> @@ -1686,50 +1364,29 @@ JsRegExpLiteralExtra::FromJson(const nlohmann::json& json) { absl::StatusOr JsRegExpLiteral::GetPattern(const nlohmann::json& json) { - auto pattern_it = json.find("pattern"); - if (pattern_it == json.end()) { - return absl::InvalidArgumentError("`pattern` is undefined."); - } - const nlohmann::json& json_pattern = pattern_it.value(); - - if (json_pattern.is_null()) { - return absl::InvalidArgumentError("json_pattern is null."); - } - if (!json_pattern.is_string()) { - return absl::InvalidArgumentError("Expecting json_pattern.is_string()."); - } - return json_pattern.get(); + return GetRequiredField( + json, + "pattern", + JsonToString + ); } absl::StatusOr JsRegExpLiteral::GetFlags(const nlohmann::json& json) { - auto flags_it = json.find("flags"); - if (flags_it == json.end()) { - return absl::InvalidArgumentError("`flags` is undefined."); - } - const nlohmann::json& json_flags = flags_it.value(); - - if (json_flags.is_null()) { - return absl::InvalidArgumentError("json_flags is null."); - } - if (!json_flags.is_string()) { - return absl::InvalidArgumentError("Expecting json_flags.is_string()."); - } - return json_flags.get(); + return GetRequiredField( + json, + "flags", + JsonToString + ); } absl::StatusOr>> JsRegExpLiteral::GetExtra(const nlohmann::json& json) { - auto extra_it = json.find("extra"); - if (extra_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_extra = extra_it.value(); - - if (json_extra.is_null()) { - return absl::InvalidArgumentError("json_extra is null."); - } - return JsRegExpLiteralExtra::FromJson(json_extra); + return GetOptionalField>( + json, + "extra", + JsRegExpLiteralExtra::FromJson + ); } absl::StatusOr> @@ -1804,36 +1461,20 @@ JsNullLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr JsStringLiteralExtra::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr JsStringLiteralExtra::GetRawValue(const nlohmann::json& json) { - auto raw_value_it = json.find("rawValue"); - if (raw_value_it == json.end()) { - return absl::InvalidArgumentError("`rawValue` is undefined."); - } - const nlohmann::json& json_raw_value = raw_value_it.value(); - - if (json_raw_value.is_null()) { - return absl::InvalidArgumentError("json_raw_value is null."); - } - if (!json_raw_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw_value.is_string()."); - } - return json_raw_value.get(); + return GetRequiredField( + json, + "rawValue", + JsonToString + ); } absl::StatusOr> @@ -1872,33 +1513,20 @@ static bool IsStringLiteral(const nlohmann::json& json) { absl::StatusOr JsStringLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_value.is_string()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToString + ); } absl::StatusOr>> JsStringLiteral::GetExtra(const nlohmann::json& json) { - auto extra_it = json.find("extra"); - if (extra_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_extra = extra_it.value(); - - if (json_extra.is_null()) { - return absl::InvalidArgumentError("json_extra is null."); - } - return JsStringLiteralExtra::FromJson(json_extra); + return GetOptionalField>( + json, + "extra", + JsStringLiteralExtra::FromJson + ); } absl::StatusOr> @@ -1939,19 +1567,11 @@ JsStringLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr JsBooleanLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_value.is_boolean()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToBool + ); } absl::StatusOr> @@ -1990,36 +1610,20 @@ JsBooleanLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr JsNumericLiteralExtra::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr JsNumericLiteralExtra::GetRawValue(const nlohmann::json& json) { - auto raw_value_it = json.find("rawValue"); - if (raw_value_it == json.end()) { - return absl::InvalidArgumentError("`rawValue` is undefined."); - } - const nlohmann::json& json_raw_value = raw_value_it.value(); - - if (json_raw_value.is_null()) { - return absl::InvalidArgumentError("json_raw_value is null."); - } - if (!json_raw_value.is_number()) { - return absl::InvalidArgumentError("Expecting json_raw_value.is_number()."); - } - return json_raw_value.get(); + return GetRequiredField( + json, + "rawValue", + JsonToDouble + ); } absl::StatusOr> @@ -2042,33 +1646,20 @@ JsNumericLiteralExtra::FromJson(const nlohmann::json& json) { absl::StatusOr JsNumericLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_number()) { - return absl::InvalidArgumentError("Expecting json_value.is_number()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToDouble + ); } absl::StatusOr>> JsNumericLiteral::GetExtra(const nlohmann::json& json) { - auto extra_it = json.find("extra"); - if (extra_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_extra = extra_it.value(); - - if (json_extra.is_null()) { - return absl::InvalidArgumentError("json_extra is null."); - } - return JsNumericLiteralExtra::FromJson(json_extra); + return GetOptionalField>( + json, + "extra", + JsNumericLiteralExtra::FromJson + ); } absl::StatusOr> @@ -2109,36 +1700,20 @@ JsNumericLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr JsBigIntLiteralExtra::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr JsBigIntLiteralExtra::GetRawValue(const nlohmann::json& json) { - auto raw_value_it = json.find("rawValue"); - if (raw_value_it == json.end()) { - return absl::InvalidArgumentError("`rawValue` is undefined."); - } - const nlohmann::json& json_raw_value = raw_value_it.value(); - - if (json_raw_value.is_null()) { - return absl::InvalidArgumentError("json_raw_value is null."); - } - if (!json_raw_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw_value.is_string()."); - } - return json_raw_value.get(); + return GetRequiredField( + json, + "rawValue", + JsonToString + ); } absl::StatusOr> @@ -2161,33 +1736,20 @@ JsBigIntLiteralExtra::FromJson(const nlohmann::json& json) { absl::StatusOr JsBigIntLiteral::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (!json_value.is_string()) { - return absl::InvalidArgumentError("Expecting json_value.is_string()."); - } - return json_value.get(); + return GetRequiredField( + json, + "value", + JsonToString + ); } absl::StatusOr>> JsBigIntLiteral::GetExtra(const nlohmann::json& json) { - auto extra_it = json.find("extra"); - if (extra_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_extra = extra_it.value(); - - if (json_extra.is_null()) { - return absl::InvalidArgumentError("json_extra is null."); - } - return JsBigIntLiteralExtra::FromJson(json_extra); + return GetOptionalField>( + json, + "extra", + JsBigIntLiteralExtra::FromJson + ); } absl::StatusOr> @@ -2228,76 +1790,40 @@ JsBigIntLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsFunction::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return std::nullopt; - } - return JsIdentifier::FromJson(json_id); + return GetNullableField>( + json, + "id", + JsIdentifier::FromJson + ); } absl::StatusOr>> JsFunction::GetParams(const nlohmann::json& json) { - auto params_it = json.find("params"); - if (params_it == json.end()) { - return absl::InvalidArgumentError("`params` is undefined."); - } - const nlohmann::json& json_params = params_it.value(); - - if (json_params.is_null()) { - return absl::InvalidArgumentError("json_params is null."); - } - if (!json_params.is_array()) { - return absl::InvalidArgumentError("json_params expected to be array."); - } - - std::vector> params; - for (const nlohmann::json& json_params_element : json_params) { - if (json_params_element.is_null()) { - return absl::InvalidArgumentError("json_params_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto params_element, JsPattern::FromJson(json_params_element)); - params.push_back(std::move(params_element)); - } - return params; + return GetRequiredField>>( + json, + "params", + List>( + JsPattern::FromJson + ) + ); } absl::StatusOr JsFunction::GetGenerator(const nlohmann::json& json) { - auto generator_it = json.find("generator"); - if (generator_it == json.end()) { - return absl::InvalidArgumentError("`generator` is undefined."); - } - const nlohmann::json& json_generator = generator_it.value(); - - if (json_generator.is_null()) { - return absl::InvalidArgumentError("json_generator is null."); - } - if (!json_generator.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_generator.is_boolean()."); - } - return json_generator.get(); + return GetRequiredField( + json, + "generator", + JsonToBool + ); } absl::StatusOr JsFunction::GetAsync(const nlohmann::json& json) { - auto async_it = json.find("async"); - if (async_it == json.end()) { - return absl::InvalidArgumentError("`async` is undefined."); - } - const nlohmann::json& json_async = async_it.value(); - - if (json_async.is_null()) { - return absl::InvalidArgumentError("json_async is null."); - } - if (!json_async.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_async.is_boolean()."); - } - return json_async.get(); + return GetRequiredField( + json, + "async", + JsonToBool + ); } absl::StatusOr> @@ -2408,54 +1934,24 @@ static bool IsBlockStatement(const nlohmann::json& json) { absl::StatusOr>> JsBlockStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - if (!json_body.is_array()) { - return absl::InvalidArgumentError("json_body expected to be array."); - } - - std::vector> body; - for (const nlohmann::json& json_body_element : json_body) { - if (json_body_element.is_null()) { - return absl::InvalidArgumentError("json_body_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto body_element, JsStatement::FromJson(json_body_element)); - body.push_back(std::move(body_element)); - } - return body; + return GetRequiredField>>( + json, + "body", + List>( + JsStatement::FromJson + ) + ); } absl::StatusOr>> JsBlockStatement::GetDirectives(const nlohmann::json& json) { - auto directives_it = json.find("directives"); - if (directives_it == json.end()) { - return absl::InvalidArgumentError("`directives` is undefined."); - } - const nlohmann::json& json_directives = directives_it.value(); - - if (json_directives.is_null()) { - return absl::InvalidArgumentError("json_directives is null."); - } - if (!json_directives.is_array()) { - return absl::InvalidArgumentError("json_directives expected to be array."); - } - - std::vector> directives; - for (const nlohmann::json& json_directives_element : json_directives) { - if (json_directives_element.is_null()) { - return absl::InvalidArgumentError("json_directives_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto directives_element, JsDirective::FromJson(json_directives_element)); - directives.push_back(std::move(directives_element)); - } - return directives; + return GetRequiredField>>( + json, + "directives", + List>( + JsDirective::FromJson + ) + ); } absl::StatusOr> @@ -2496,16 +1992,11 @@ JsBlockStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsBlockStatementFunction::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsBlockStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsBlockStatement::FromJson + ); } absl::StatusOr> @@ -2536,16 +2027,11 @@ JsBlockStatementFunction::FromJson(const nlohmann::json& json) { absl::StatusOr> JsExpressionStatement::GetExpression(const nlohmann::json& json) { - auto expression_it = json.find("expression"); - if (expression_it == json.end()) { - return absl::InvalidArgumentError("`expression` is undefined."); - } - const nlohmann::json& json_expression = expression_it.value(); - - if (json_expression.is_null()) { - return absl::InvalidArgumentError("json_expression is null."); - } - return JsExpression::FromJson(json_expression); + return GetRequiredField>( + json, + "expression", + JsExpression::FromJson + ); } absl::StatusOr> @@ -2648,30 +2134,20 @@ JsDebuggerStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsWithStatement::GetObject(const nlohmann::json& json) { - auto object_it = json.find("object"); - if (object_it == json.end()) { - return absl::InvalidArgumentError("`object` is undefined."); - } - const nlohmann::json& json_object = object_it.value(); - - if (json_object.is_null()) { - return absl::InvalidArgumentError("json_object is null."); - } - return JsExpression::FromJson(json_object); + return GetRequiredField>( + json, + "object", + JsExpression::FromJson + ); } absl::StatusOr> JsWithStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> @@ -2712,16 +2188,11 @@ JsWithStatement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsReturnStatement::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_argument); + return GetNullableField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr> @@ -2760,30 +2231,20 @@ JsReturnStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsLabeledStatement::GetLabel(const nlohmann::json& json) { - auto label_it = json.find("label"); - if (label_it == json.end()) { - return absl::InvalidArgumentError("`label` is undefined."); - } - const nlohmann::json& json_label = label_it.value(); - - if (json_label.is_null()) { - return absl::InvalidArgumentError("json_label is null."); - } - return JsIdentifier::FromJson(json_label); + return GetRequiredField>( + json, + "label", + JsIdentifier::FromJson + ); } absl::StatusOr> JsLabeledStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> @@ -2824,16 +2285,11 @@ JsLabeledStatement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsBreakStatement::GetLabel(const nlohmann::json& json) { - auto label_it = json.find("label"); - if (label_it == json.end()) { - return absl::InvalidArgumentError("`label` is undefined."); - } - const nlohmann::json& json_label = label_it.value(); - - if (json_label.is_null()) { - return std::nullopt; - } - return JsIdentifier::FromJson(json_label); + return GetNullableField>( + json, + "label", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -2872,16 +2328,11 @@ JsBreakStatement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsContinueStatement::GetLabel(const nlohmann::json& json) { - auto label_it = json.find("label"); - if (label_it == json.end()) { - return absl::InvalidArgumentError("`label` is undefined."); - } - const nlohmann::json& json_label = label_it.value(); - - if (json_label.is_null()) { - return std::nullopt; - } - return JsIdentifier::FromJson(json_label); + return GetNullableField>( + json, + "label", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -2920,44 +2371,29 @@ JsContinueStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsIfStatement::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return absl::InvalidArgumentError("json_test is null."); - } - return JsExpression::FromJson(json_test); + return GetRequiredField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr> JsIfStatement::GetConsequent(const nlohmann::json& json) { - auto consequent_it = json.find("consequent"); - if (consequent_it == json.end()) { - return absl::InvalidArgumentError("`consequent` is undefined."); - } - const nlohmann::json& json_consequent = consequent_it.value(); - - if (json_consequent.is_null()) { - return absl::InvalidArgumentError("json_consequent is null."); - } - return JsStatement::FromJson(json_consequent); + return GetRequiredField>( + json, + "consequent", + JsStatement::FromJson + ); } absl::StatusOr>> JsIfStatement::GetAlternate(const nlohmann::json& json) { - auto alternate_it = json.find("alternate"); - if (alternate_it == json.end()) { - return absl::InvalidArgumentError("`alternate` is undefined."); - } - const nlohmann::json& json_alternate = alternate_it.value(); - - if (json_alternate.is_null()) { - return std::nullopt; - } - return JsStatement::FromJson(json_alternate); + return GetNullableField>( + json, + "alternate", + JsStatement::FromJson + ); } absl::StatusOr> @@ -3000,42 +2436,22 @@ JsIfStatement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsSwitchCase::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_test); + return GetNullableField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr>> JsSwitchCase::GetConsequent(const nlohmann::json& json) { - auto consequent_it = json.find("consequent"); - if (consequent_it == json.end()) { - return absl::InvalidArgumentError("`consequent` is undefined."); - } - const nlohmann::json& json_consequent = consequent_it.value(); - - if (json_consequent.is_null()) { - return absl::InvalidArgumentError("json_consequent is null."); - } - if (!json_consequent.is_array()) { - return absl::InvalidArgumentError("json_consequent expected to be array."); - } - - std::vector> consequent; - for (const nlohmann::json& json_consequent_element : json_consequent) { - if (json_consequent_element.is_null()) { - return absl::InvalidArgumentError("json_consequent_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto consequent_element, JsStatement::FromJson(json_consequent_element)); - consequent.push_back(std::move(consequent_element)); - } - return consequent; + return GetRequiredField>>( + json, + "consequent", + List>( + JsStatement::FromJson + ) + ); } absl::StatusOr> @@ -3076,42 +2492,22 @@ JsSwitchCase::FromJson(const nlohmann::json& json) { absl::StatusOr> JsSwitchStatement::GetDiscriminant(const nlohmann::json& json) { - auto discriminant_it = json.find("discriminant"); - if (discriminant_it == json.end()) { - return absl::InvalidArgumentError("`discriminant` is undefined."); - } - const nlohmann::json& json_discriminant = discriminant_it.value(); - - if (json_discriminant.is_null()) { - return absl::InvalidArgumentError("json_discriminant is null."); - } - return JsExpression::FromJson(json_discriminant); + return GetRequiredField>( + json, + "discriminant", + JsExpression::FromJson + ); } absl::StatusOr>> JsSwitchStatement::GetCases(const nlohmann::json& json) { - auto cases_it = json.find("cases"); - if (cases_it == json.end()) { - return absl::InvalidArgumentError("`cases` is undefined."); - } - const nlohmann::json& json_cases = cases_it.value(); - - if (json_cases.is_null()) { - return absl::InvalidArgumentError("json_cases is null."); - } - if (!json_cases.is_array()) { - return absl::InvalidArgumentError("json_cases expected to be array."); - } - - std::vector> cases; - for (const nlohmann::json& json_cases_element : json_cases) { - if (json_cases_element.is_null()) { - return absl::InvalidArgumentError("json_cases_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto cases_element, JsSwitchCase::FromJson(json_cases_element)); - cases.push_back(std::move(cases_element)); - } - return cases; + return GetRequiredField>>( + json, + "cases", + List>( + JsSwitchCase::FromJson + ) + ); } absl::StatusOr> @@ -3152,16 +2548,11 @@ JsSwitchStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsThrowStatement::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return JsExpression::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr> @@ -3200,30 +2591,20 @@ JsThrowStatement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsCatchClause::GetParam(const nlohmann::json& json) { - auto param_it = json.find("param"); - if (param_it == json.end()) { - return absl::InvalidArgumentError("`param` is undefined."); - } - const nlohmann::json& json_param = param_it.value(); - - if (json_param.is_null()) { - return std::nullopt; - } - return JsPattern::FromJson(json_param); + return GetNullableField>( + json, + "param", + JsPattern::FromJson + ); } absl::StatusOr> JsCatchClause::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsBlockStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsBlockStatement::FromJson + ); } absl::StatusOr> @@ -3264,44 +2645,29 @@ JsCatchClause::FromJson(const nlohmann::json& json) { absl::StatusOr> JsTryStatement::GetBlock(const nlohmann::json& json) { - auto block_it = json.find("block"); - if (block_it == json.end()) { - return absl::InvalidArgumentError("`block` is undefined."); - } - const nlohmann::json& json_block = block_it.value(); - - if (json_block.is_null()) { - return absl::InvalidArgumentError("json_block is null."); - } - return JsBlockStatement::FromJson(json_block); + return GetRequiredField>( + json, + "block", + JsBlockStatement::FromJson + ); } absl::StatusOr>> JsTryStatement::GetHandler(const nlohmann::json& json) { - auto handler_it = json.find("handler"); - if (handler_it == json.end()) { - return absl::InvalidArgumentError("`handler` is undefined."); - } - const nlohmann::json& json_handler = handler_it.value(); - - if (json_handler.is_null()) { - return std::nullopt; - } - return JsCatchClause::FromJson(json_handler); + return GetNullableField>( + json, + "handler", + JsCatchClause::FromJson + ); } absl::StatusOr>> JsTryStatement::GetFinalizer(const nlohmann::json& json) { - auto finalizer_it = json.find("finalizer"); - if (finalizer_it == json.end()) { - return absl::InvalidArgumentError("`finalizer` is undefined."); - } - const nlohmann::json& json_finalizer = finalizer_it.value(); - - if (json_finalizer.is_null()) { - return std::nullopt; - } - return JsBlockStatement::FromJson(json_finalizer); + return GetNullableField>( + json, + "finalizer", + JsBlockStatement::FromJson + ); } absl::StatusOr> @@ -3344,30 +2710,20 @@ JsTryStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsWhileStatement::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return absl::InvalidArgumentError("json_test is null."); - } - return JsExpression::FromJson(json_test); + return GetRequiredField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr> JsWhileStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> @@ -3408,30 +2764,20 @@ JsWhileStatement::FromJson(const nlohmann::json& json) { absl::StatusOr> JsDoWhileStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> JsDoWhileStatement::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return absl::InvalidArgumentError("json_test is null."); - } - return JsExpression::FromJson(json_test); + return GetRequiredField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr> @@ -3494,30 +2840,20 @@ JsDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr> JsVariableDeclarator::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return absl::InvalidArgumentError("json_id is null."); - } - return JsLVal::FromJson(json_id); + return GetRequiredField>( + json, + "id", + JsLVal::FromJson + ); } absl::StatusOr>> JsVariableDeclarator::GetInit(const nlohmann::json& json) { - auto init_it = json.find("init"); - if (init_it == json.end()) { - return absl::InvalidArgumentError("`init` is undefined."); - } - const nlohmann::json& json_init = init_it.value(); - - if (json_init.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_init); + return GetNullableField>( + json, + "init", + JsExpression::FromJson + ); } absl::StatusOr> @@ -3574,45 +2910,22 @@ static bool IsVariableDeclaration(const nlohmann::json& json) { absl::StatusOr>> JsVariableDeclaration::GetDeclarations(const nlohmann::json& json) { - auto declarations_it = json.find("declarations"); - if (declarations_it == json.end()) { - return absl::InvalidArgumentError("`declarations` is undefined."); - } - const nlohmann::json& json_declarations = declarations_it.value(); - - if (json_declarations.is_null()) { - return absl::InvalidArgumentError("json_declarations is null."); - } - if (!json_declarations.is_array()) { - return absl::InvalidArgumentError("json_declarations expected to be array."); - } - - std::vector> declarations; - for (const nlohmann::json& json_declarations_element : json_declarations) { - if (json_declarations_element.is_null()) { - return absl::InvalidArgumentError("json_declarations_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto declarations_element, JsVariableDeclarator::FromJson(json_declarations_element)); - declarations.push_back(std::move(declarations_element)); - } - return declarations; + return GetRequiredField>>( + json, + "declarations", + List>( + JsVariableDeclarator::FromJson + ) + ); } absl::StatusOr JsVariableDeclaration::GetKind(const nlohmann::json& json) { - auto kind_it = json.find("kind"); - if (kind_it == json.end()) { - return absl::InvalidArgumentError("`kind` is undefined."); - } - const nlohmann::json& json_kind = kind_it.value(); - - if (json_kind.is_null()) { - return absl::InvalidArgumentError("json_kind is null."); - } - if (!json_kind.is_string()) { - return absl::InvalidArgumentError("Expecting json_kind.is_string()."); - } - return json_kind.get(); + return GetRequiredField( + json, + "kind", + JsonToString + ); } absl::StatusOr> @@ -3653,67 +2966,46 @@ JsVariableDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>>> JsForStatement::GetInit(const nlohmann::json& json) { - auto init_it = json.find("init"); - if (init_it == json.end()) { - return absl::InvalidArgumentError("`init` is undefined."); - } - const nlohmann::json& json_init = init_it.value(); - - if (json_init.is_null()) { - return std::nullopt; - } - if (IsVariableDeclaration(json_init)) { - return JsVariableDeclaration::FromJson(json_init); - } else if (IsExpression(json_init)) { - return JsExpression::FromJson(json_init); - } else { - auto result = absl::InvalidArgumentError("json_init has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_init.dump()}); - return result; - } + return GetNullableField, std::unique_ptr>>( + json, + "init", + Variant( + VariantOption>{ + .predicate = IsVariableDeclaration, + .converter = JsVariableDeclaration::FromJson, + }, + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }) + ); } absl::StatusOr>> JsForStatement::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_test); + return GetNullableField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr>> JsForStatement::GetUpdate(const nlohmann::json& json) { - auto update_it = json.find("update"); - if (update_it == json.end()) { - return absl::InvalidArgumentError("`update` is undefined."); - } - const nlohmann::json& json_update = update_it.value(); - - if (json_update.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_update); + return GetNullableField>( + json, + "update", + JsExpression::FromJson + ); } absl::StatusOr> JsForStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> @@ -3758,53 +3050,37 @@ JsForStatement::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsForInStatement::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - if (IsVariableDeclaration(json_left)) { - return JsVariableDeclaration::FromJson(json_left); - } else if (IsLVal(json_left)) { - return JsLVal::FromJson(json_left); - } else { - auto result = absl::InvalidArgumentError("json_left has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_left.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "left", + Variant( + VariantOption>{ + .predicate = IsVariableDeclaration, + .converter = JsVariableDeclaration::FromJson, + }, + VariantOption>{ + .predicate = IsLVal, + .converter = JsLVal::FromJson, + }) + ); } absl::StatusOr> JsForInStatement::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> JsForInStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr> @@ -3847,70 +3123,46 @@ JsForInStatement::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsForOfStatement::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - if (IsVariableDeclaration(json_left)) { - return JsVariableDeclaration::FromJson(json_left); - } else if (IsLVal(json_left)) { - return JsLVal::FromJson(json_left); - } else { - auto result = absl::InvalidArgumentError("json_left has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_left.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "left", + Variant( + VariantOption>{ + .predicate = IsVariableDeclaration, + .converter = JsVariableDeclaration::FromJson, + }, + VariantOption>{ + .predicate = IsLVal, + .converter = JsLVal::FromJson, + }) + ); } absl::StatusOr> JsForOfStatement::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> JsForOfStatement::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsStatement::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsStatement::FromJson + ); } absl::StatusOr JsForOfStatement::GetAwait(const nlohmann::json& json) { - auto await_it = json.find("await"); - if (await_it == json.end()) { - return absl::InvalidArgumentError("`await` is undefined."); - } - const nlohmann::json& json_await = await_it.value(); - - if (json_await.is_null()) { - return absl::InvalidArgumentError("json_await is null."); - } - if (!json_await.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_await.is_boolean()."); - } - return json_await.get(); + return GetRequiredField( + json, + "await", + JsonToBool + ); } absl::StatusOr> @@ -4141,25 +3393,19 @@ JsThisExpression::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsArrowFunctionExpression::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - if (IsBlockStatement(json_body)) { - return JsBlockStatement::FromJson(json_body); - } else if (IsExpression(json_body)) { - return JsExpression::FromJson(json_body); - } else { - auto result = absl::InvalidArgumentError("json_body has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_body.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "body", + Variant( + VariantOption>{ + .predicate = IsBlockStatement, + .converter = JsBlockStatement::FromJson, + }, + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }) + ); } absl::StatusOr> @@ -4206,33 +3452,20 @@ JsArrowFunctionExpression::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsYieldExpression::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_argument); + return GetNullableField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr JsYieldExpression::GetDelegate(const nlohmann::json& json) { - auto delegate_it = json.find("delegate"); - if (delegate_it == json.end()) { - return absl::InvalidArgumentError("`delegate` is undefined."); - } - const nlohmann::json& json_delegate = delegate_it.value(); - - if (json_delegate.is_null()) { - return absl::InvalidArgumentError("json_delegate is null."); - } - if (!json_delegate.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_delegate.is_boolean()."); - } - return json_delegate.get(); + return GetRequiredField( + json, + "delegate", + JsonToBool + ); } absl::StatusOr> @@ -4273,16 +3506,11 @@ JsYieldExpression::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsAwaitExpression::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_argument); + return GetNullableField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr> @@ -4337,16 +3565,11 @@ static bool IsSpreadElement(const nlohmann::json& json) { absl::StatusOr> JsSpreadElement::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return JsExpression::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr> @@ -4385,37 +3608,23 @@ JsSpreadElement::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>>>> JsArrayExpression::GetElements(const nlohmann::json& json) { - auto elements_it = json.find("elements"); - if (elements_it == json.end()) { - return absl::InvalidArgumentError("`elements` is undefined."); - } - const nlohmann::json& json_elements = elements_it.value(); - - if (json_elements.is_null()) { - return absl::InvalidArgumentError("json_elements is null."); - } - if (!json_elements.is_array()) { - return absl::InvalidArgumentError("json_elements expected to be array."); - } - - std::vector, std::unique_ptr>>> elements; - for (const nlohmann::json& json_elements_element : json_elements) { - std::optional, std::unique_ptr>> elements_element; - if (!json_elements_element.is_null()) { - if (IsExpression(json_elements_element)) { - MALDOCA_ASSIGN_OR_RETURN(elements_element, JsExpression::FromJson(json_elements_element)); - } else if (IsSpreadElement(json_elements_element)) { - MALDOCA_ASSIGN_OR_RETURN(elements_element, JsSpreadElement::FromJson(json_elements_element)); - } else { - auto result = absl::InvalidArgumentError("json_elements_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_elements_element.dump()}); - return result; - } - } - elements.push_back(std::move(elements_element)); - } - return elements; + return GetRequiredField, std::unique_ptr>>>>( + json, + "elements", + List, std::unique_ptr>>>( + Nullable, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSpreadElement, + .converter = JsSpreadElement::FromJson, + }) + ) + ) + ); } absl::StatusOr> @@ -4454,33 +3663,20 @@ JsArrayExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsObjectMember::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsExpression::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsExpression::FromJson + ); } absl::StatusOr JsObjectMember::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr> @@ -4521,42 +3717,28 @@ static bool IsObjectProperty(const nlohmann::json& json) { absl::StatusOr JsObjectProperty::GetShorthand(const nlohmann::json& json) { - auto shorthand_it = json.find("shorthand"); - if (shorthand_it == json.end()) { - return absl::InvalidArgumentError("`shorthand` is undefined."); - } - const nlohmann::json& json_shorthand = shorthand_it.value(); - - if (json_shorthand.is_null()) { - return absl::InvalidArgumentError("json_shorthand is null."); - } - if (!json_shorthand.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_shorthand.is_boolean()."); - } - return json_shorthand.get(); + return GetRequiredField( + json, + "shorthand", + JsonToBool + ); } absl::StatusOr, std::unique_ptr>> JsObjectProperty::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - if (IsExpression(json_value)) { - return JsExpression::FromJson(json_value); - } else if (IsPattern(json_value)) { - return JsPattern::FromJson(json_value); - } else { - auto result = absl::InvalidArgumentError("json_value has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_value.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "value", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsPattern, + .converter = JsPattern::FromJson, + }) + ); } absl::StatusOr> @@ -4617,19 +3799,11 @@ static bool IsObjectMethod(const nlohmann::json& json) { absl::StatusOr JsObjectMethod::GetKind(const nlohmann::json& json) { - auto kind_it = json.find("kind"); - if (kind_it == json.end()) { - return absl::InvalidArgumentError("`kind` is undefined."); - } - const nlohmann::json& json_kind = kind_it.value(); - - if (json_kind.is_null()) { - return absl::InvalidArgumentError("json_kind is null."); - } - if (!json_kind.is_string()) { - return absl::InvalidArgumentError("Expecting json_kind.is_string()."); - } - return json_kind.get(); + return GetRequiredField( + json, + "kind", + JsonToString + ); } absl::StatusOr> @@ -4682,40 +3856,25 @@ JsObjectMethod::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr>>> JsObjectExpression::GetProperties(const nlohmann::json& json) { - auto properties_it = json.find("properties"); - if (properties_it == json.end()) { - return absl::InvalidArgumentError("`properties` is undefined."); - } - const nlohmann::json& json_properties = properties_it.value(); - - if (json_properties.is_null()) { - return absl::InvalidArgumentError("json_properties is null."); - } - if (!json_properties.is_array()) { - return absl::InvalidArgumentError("json_properties expected to be array."); - } - - std::vector, std::unique_ptr, std::unique_ptr>> properties_; - for (const nlohmann::json& json_properties_element : json_properties) { - if (json_properties_element.is_null()) { - return absl::InvalidArgumentError("json_properties_element is null."); - } - std::variant, std::unique_ptr, std::unique_ptr> properties_element; - if (IsObjectProperty(json_properties_element)) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, JsObjectProperty::FromJson(json_properties_element)); - } else if (IsObjectMethod(json_properties_element)) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, JsObjectMethod::FromJson(json_properties_element)); - } else if (IsSpreadElement(json_properties_element)) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, JsSpreadElement::FromJson(json_properties_element)); - } else { - auto result = absl::InvalidArgumentError("json_properties_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_properties_element.dump()}); - return result; - } - properties_.push_back(std::move(properties_element)); - } - return properties_; + return GetRequiredField, std::unique_ptr, std::unique_ptr>>>( + json, + "properties", + List, std::unique_ptr, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsObjectProperty, + .converter = JsObjectProperty::FromJson, + }, + VariantOption>{ + .predicate = IsObjectMethod, + .converter = JsObjectMethod::FromJson, + }, + VariantOption>{ + .predicate = IsSpreadElement, + .converter = JsSpreadElement::FromJson, + }) + ) + ); } absl::StatusOr> @@ -4796,51 +3955,29 @@ JsFunctionExpression::FromJson(const nlohmann::json& json) { absl::StatusOr JsUnaryExpression::GetOperator(const nlohmann::json& json) { - auto operator_it = json.find("operator"); - if (operator_it == json.end()) { - return absl::InvalidArgumentError("`operator` is undefined."); - } - const nlohmann::json& json_operator = operator_it.value(); - - if (json_operator.is_null()) { - return absl::InvalidArgumentError("json_operator is null."); - } - if (!json_operator.is_string()) { - return absl::InvalidArgumentError("`json_operator` expected to be a string."); - } - std::string json_operator_str = json_operator.get(); - return StringToJsUnaryOperator(json_operator_str); + return GetRequiredField( + json, + "operator", + Enum(StringToJsUnaryOperator) + ); } absl::StatusOr JsUnaryExpression::GetPrefix(const nlohmann::json& json) { - auto prefix_it = json.find("prefix"); - if (prefix_it == json.end()) { - return absl::InvalidArgumentError("`prefix` is undefined."); - } - const nlohmann::json& json_prefix = prefix_it.value(); - - if (json_prefix.is_null()) { - return absl::InvalidArgumentError("json_prefix is null."); - } - if (!json_prefix.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_prefix.is_boolean()."); - } - return json_prefix.get(); + return GetRequiredField( + json, + "prefix", + JsonToBool + ); } absl::StatusOr> JsUnaryExpression::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return JsExpression::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + JsExpression::FromJson + ); } absl::StatusOr> @@ -4883,51 +4020,29 @@ JsUnaryExpression::FromJson(const nlohmann::json& json) { absl::StatusOr JsUpdateExpression::GetOperator(const nlohmann::json& json) { - auto operator_it = json.find("operator"); - if (operator_it == json.end()) { - return absl::InvalidArgumentError("`operator` is undefined."); - } - const nlohmann::json& json_operator = operator_it.value(); - - if (json_operator.is_null()) { - return absl::InvalidArgumentError("json_operator is null."); - } - if (!json_operator.is_string()) { - return absl::InvalidArgumentError("`json_operator` expected to be a string."); - } - std::string json_operator_str = json_operator.get(); - return StringToJsUpdateOperator(json_operator_str); + return GetRequiredField( + json, + "operator", + Enum(StringToJsUpdateOperator) + ); } absl::StatusOr> JsUpdateExpression::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return JsLVal::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + JsLVal::FromJson + ); } absl::StatusOr JsUpdateExpression::GetPrefix(const nlohmann::json& json) { - auto prefix_it = json.find("prefix"); - if (prefix_it == json.end()) { - return absl::InvalidArgumentError("`prefix` is undefined."); - } - const nlohmann::json& json_prefix = prefix_it.value(); - - if (json_prefix.is_null()) { - return absl::InvalidArgumentError("json_prefix is null."); - } - if (!json_prefix.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_prefix.is_boolean()."); - } - return json_prefix.get(); + return GetRequiredField( + json, + "prefix", + JsonToBool + ); } absl::StatusOr> @@ -4970,57 +4085,37 @@ JsUpdateExpression::FromJson(const nlohmann::json& json) { absl::StatusOr JsBinaryExpression::GetOperator(const nlohmann::json& json) { - auto operator_it = json.find("operator"); - if (operator_it == json.end()) { - return absl::InvalidArgumentError("`operator` is undefined."); - } - const nlohmann::json& json_operator = operator_it.value(); - - if (json_operator.is_null()) { - return absl::InvalidArgumentError("json_operator is null."); - } - if (!json_operator.is_string()) { - return absl::InvalidArgumentError("`json_operator` expected to be a string."); - } - std::string json_operator_str = json_operator.get(); - return StringToJsBinaryOperator(json_operator_str); + return GetRequiredField( + json, + "operator", + Enum(StringToJsBinaryOperator) + ); } absl::StatusOr, std::unique_ptr>> JsBinaryExpression::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - if (IsExpression(json_left)) { - return JsExpression::FromJson(json_left); - } else if (IsPrivateName(json_left)) { - return JsPrivateName::FromJson(json_left); - } else { - auto result = absl::InvalidArgumentError("json_left has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_left.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "left", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsPrivateName, + .converter = JsPrivateName::FromJson, + }) + ); } absl::StatusOr> JsBinaryExpression::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> @@ -5063,48 +4158,29 @@ JsBinaryExpression::FromJson(const nlohmann::json& json) { absl::StatusOr JsAssignmentExpression::GetOperator(const nlohmann::json& json) { - auto operator_it = json.find("operator"); - if (operator_it == json.end()) { - return absl::InvalidArgumentError("`operator` is undefined."); - } - const nlohmann::json& json_operator = operator_it.value(); - - if (json_operator.is_null()) { - return absl::InvalidArgumentError("json_operator is null."); - } - if (!json_operator.is_string()) { - return absl::InvalidArgumentError("`json_operator` expected to be a string."); - } - std::string json_operator_str = json_operator.get(); - return StringToJsAssignmentOperator(json_operator_str); + return GetRequiredField( + json, + "operator", + Enum(StringToJsAssignmentOperator) + ); } absl::StatusOr> JsAssignmentExpression::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - return JsLVal::FromJson(json_left); + return GetRequiredField>( + json, + "left", + JsLVal::FromJson + ); } absl::StatusOr> JsAssignmentExpression::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> @@ -5147,48 +4223,29 @@ JsAssignmentExpression::FromJson(const nlohmann::json& json) { absl::StatusOr JsLogicalExpression::GetOperator(const nlohmann::json& json) { - auto operator_it = json.find("operator"); - if (operator_it == json.end()) { - return absl::InvalidArgumentError("`operator` is undefined."); - } - const nlohmann::json& json_operator = operator_it.value(); - - if (json_operator.is_null()) { - return absl::InvalidArgumentError("json_operator is null."); - } - if (!json_operator.is_string()) { - return absl::InvalidArgumentError("`json_operator` expected to be a string."); - } - std::string json_operator_str = json_operator.get(); - return StringToJsLogicalOperator(json_operator_str); + return GetRequiredField( + json, + "operator", + Enum(StringToJsLogicalOperator) + ); } absl::StatusOr> JsLogicalExpression::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - return JsExpression::FromJson(json_left); + return GetRequiredField>( + json, + "left", + JsExpression::FromJson + ); } absl::StatusOr> JsLogicalExpression::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> @@ -5231,65 +4288,45 @@ JsLogicalExpression::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsMemberExpression::GetObject(const nlohmann::json& json) { - auto object_it = json.find("object"); - if (object_it == json.end()) { - return absl::InvalidArgumentError("`object` is undefined."); - } - const nlohmann::json& json_object = object_it.value(); - - if (json_object.is_null()) { - return absl::InvalidArgumentError("json_object is null."); - } - if (IsExpression(json_object)) { - return JsExpression::FromJson(json_object); - } else if (IsSuper(json_object)) { - return JsSuper::FromJson(json_object); - } else { - auto result = absl::InvalidArgumentError("json_object has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_object.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "object", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSuper, + .converter = JsSuper::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>> JsMemberExpression::GetProperty(const nlohmann::json& json) { - auto property_it = json.find("property"); - if (property_it == json.end()) { - return absl::InvalidArgumentError("`property` is undefined."); - } - const nlohmann::json& json_property = property_it.value(); - - if (json_property.is_null()) { - return absl::InvalidArgumentError("json_property is null."); - } - if (IsExpression(json_property)) { - return JsExpression::FromJson(json_property); - } else if (IsPrivateName(json_property)) { - return JsPrivateName::FromJson(json_property); - } else { - auto result = absl::InvalidArgumentError("json_property has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_property.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "property", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsPrivateName, + .converter = JsPrivateName::FromJson, + }) + ); } absl::StatusOr JsMemberExpression::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr> @@ -5332,73 +4369,46 @@ JsMemberExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsOptionalMemberExpression::GetObject(const nlohmann::json& json) { - auto object_it = json.find("object"); - if (object_it == json.end()) { - return absl::InvalidArgumentError("`object` is undefined."); - } - const nlohmann::json& json_object = object_it.value(); - - if (json_object.is_null()) { - return absl::InvalidArgumentError("json_object is null."); - } - return JsExpression::FromJson(json_object); + return GetRequiredField>( + json, + "object", + JsExpression::FromJson + ); } absl::StatusOr, std::unique_ptr>> JsOptionalMemberExpression::GetProperty(const nlohmann::json& json) { - auto property_it = json.find("property"); - if (property_it == json.end()) { - return absl::InvalidArgumentError("`property` is undefined."); - } - const nlohmann::json& json_property = property_it.value(); - - if (json_property.is_null()) { - return absl::InvalidArgumentError("json_property is null."); - } - if (IsExpression(json_property)) { - return JsExpression::FromJson(json_property); - } else if (IsPrivateName(json_property)) { - return JsPrivateName::FromJson(json_property); - } else { - auto result = absl::InvalidArgumentError("json_property has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_property.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "property", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsPrivateName, + .converter = JsPrivateName::FromJson, + }) + ); } absl::StatusOr JsOptionalMemberExpression::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr JsOptionalMemberExpression::GetOptional(const nlohmann::json& json) { - auto optional_it = json.find("optional"); - if (optional_it == json.end()) { - return absl::InvalidArgumentError("`optional` is undefined."); - } - const nlohmann::json& json_optional = optional_it.value(); - - if (json_optional.is_null()) { - return absl::InvalidArgumentError("json_optional is null."); - } - if (!json_optional.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_optional.is_boolean()."); - } - return json_optional.get(); + return GetRequiredField( + json, + "optional", + JsonToBool + ); } absl::StatusOr> @@ -5443,44 +4453,29 @@ JsOptionalMemberExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsConditionalExpression::GetTest(const nlohmann::json& json) { - auto test_it = json.find("test"); - if (test_it == json.end()) { - return absl::InvalidArgumentError("`test` is undefined."); - } - const nlohmann::json& json_test = test_it.value(); - - if (json_test.is_null()) { - return absl::InvalidArgumentError("json_test is null."); - } - return JsExpression::FromJson(json_test); + return GetRequiredField>( + json, + "test", + JsExpression::FromJson + ); } absl::StatusOr> JsConditionalExpression::GetAlternate(const nlohmann::json& json) { - auto alternate_it = json.find("alternate"); - if (alternate_it == json.end()) { - return absl::InvalidArgumentError("`alternate` is undefined."); - } - const nlohmann::json& json_alternate = alternate_it.value(); - - if (json_alternate.is_null()) { - return absl::InvalidArgumentError("json_alternate is null."); - } - return JsExpression::FromJson(json_alternate); + return GetRequiredField>( + json, + "alternate", + JsExpression::FromJson + ); } absl::StatusOr> JsConditionalExpression::GetConsequent(const nlohmann::json& json) { - auto consequent_it = json.find("consequent"); - if (consequent_it == json.end()) { - return absl::InvalidArgumentError("`consequent` is undefined."); - } - const nlohmann::json& json_consequent = consequent_it.value(); - - if (json_consequent.is_null()) { - return absl::InvalidArgumentError("json_consequent is null."); - } - return JsExpression::FromJson(json_consequent); + return GetRequiredField>( + json, + "consequent", + JsExpression::FromJson + ); } absl::StatusOr> @@ -5523,63 +4518,42 @@ JsConditionalExpression::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr>> JsCallExpression::GetCallee(const nlohmann::json& json) { - auto callee_it = json.find("callee"); - if (callee_it == json.end()) { - return absl::InvalidArgumentError("`callee` is undefined."); - } - const nlohmann::json& json_callee = callee_it.value(); - - if (json_callee.is_null()) { - return absl::InvalidArgumentError("json_callee is null."); - } - if (IsExpression(json_callee)) { - return JsExpression::FromJson(json_callee); - } else if (IsSuper(json_callee)) { - return JsSuper::FromJson(json_callee); - } else if (IsImport(json_callee)) { - return JsImport::FromJson(json_callee); - } else { - auto result = absl::InvalidArgumentError("json_callee has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_callee.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr, std::unique_ptr>>( + json, + "callee", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSuper, + .converter = JsSuper::FromJson, + }, + VariantOption>{ + .predicate = IsImport, + .converter = JsImport::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>>> JsCallExpression::GetArguments(const nlohmann::json& json) { - auto arguments_it = json.find("arguments"); - if (arguments_it == json.end()) { - return absl::InvalidArgumentError("`arguments` is undefined."); - } - const nlohmann::json& json_arguments = arguments_it.value(); - - if (json_arguments.is_null()) { - return absl::InvalidArgumentError("json_arguments is null."); - } - if (!json_arguments.is_array()) { - return absl::InvalidArgumentError("json_arguments expected to be array."); - } - - std::vector, std::unique_ptr>> arguments; - for (const nlohmann::json& json_arguments_element : json_arguments) { - if (json_arguments_element.is_null()) { - return absl::InvalidArgumentError("json_arguments_element is null."); - } - std::variant, std::unique_ptr> arguments_element; - if (IsExpression(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsExpression::FromJson(json_arguments_element)); - } else if (IsSpreadElement(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsSpreadElement::FromJson(json_arguments_element)); - } else { - auto result = absl::InvalidArgumentError("json_arguments_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_arguments_element.dump()}); - return result; - } - arguments.push_back(std::move(arguments_element)); - } - return arguments; + return GetRequiredField, std::unique_ptr>>>( + json, + "arguments", + List, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSpreadElement, + .converter = JsSpreadElement::FromJson, + }) + ) + ); } absl::StatusOr> @@ -5620,69 +4594,39 @@ JsCallExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsOptionalCallExpression::GetCallee(const nlohmann::json& json) { - auto callee_it = json.find("callee"); - if (callee_it == json.end()) { - return absl::InvalidArgumentError("`callee` is undefined."); - } - const nlohmann::json& json_callee = callee_it.value(); - - if (json_callee.is_null()) { - return absl::InvalidArgumentError("json_callee is null."); - } - return JsExpression::FromJson(json_callee); + return GetRequiredField>( + json, + "callee", + JsExpression::FromJson + ); } absl::StatusOr, std::unique_ptr>>> JsOptionalCallExpression::GetArguments(const nlohmann::json& json) { - auto arguments_it = json.find("arguments"); - if (arguments_it == json.end()) { - return absl::InvalidArgumentError("`arguments` is undefined."); - } - const nlohmann::json& json_arguments = arguments_it.value(); - - if (json_arguments.is_null()) { - return absl::InvalidArgumentError("json_arguments is null."); - } - if (!json_arguments.is_array()) { - return absl::InvalidArgumentError("json_arguments expected to be array."); - } - - std::vector, std::unique_ptr>> arguments; - for (const nlohmann::json& json_arguments_element : json_arguments) { - if (json_arguments_element.is_null()) { - return absl::InvalidArgumentError("json_arguments_element is null."); - } - std::variant, std::unique_ptr> arguments_element; - if (IsExpression(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsExpression::FromJson(json_arguments_element)); - } else if (IsSpreadElement(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsSpreadElement::FromJson(json_arguments_element)); - } else { - auto result = absl::InvalidArgumentError("json_arguments_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_arguments_element.dump()}); - return result; - } - arguments.push_back(std::move(arguments_element)); - } - return arguments; + return GetRequiredField, std::unique_ptr>>>( + json, + "arguments", + List, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSpreadElement, + .converter = JsSpreadElement::FromJson, + }) + ) + ); } absl::StatusOr JsOptionalCallExpression::GetOptional(const nlohmann::json& json) { - auto optional_it = json.find("optional"); - if (optional_it == json.end()) { - return absl::InvalidArgumentError("`optional` is undefined."); - } - const nlohmann::json& json_optional = optional_it.value(); - - if (json_optional.is_null()) { - return absl::InvalidArgumentError("json_optional is null."); - } - if (!json_optional.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_optional.is_boolean()."); - } - return json_optional.get(); + return GetRequiredField( + json, + "optional", + JsonToBool + ); } absl::StatusOr> @@ -5725,63 +4669,42 @@ JsOptionalCallExpression::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr>> JsNewExpression::GetCallee(const nlohmann::json& json) { - auto callee_it = json.find("callee"); - if (callee_it == json.end()) { - return absl::InvalidArgumentError("`callee` is undefined."); - } - const nlohmann::json& json_callee = callee_it.value(); - - if (json_callee.is_null()) { - return absl::InvalidArgumentError("json_callee is null."); - } - if (IsExpression(json_callee)) { - return JsExpression::FromJson(json_callee); - } else if (IsSuper(json_callee)) { - return JsSuper::FromJson(json_callee); - } else if (IsImport(json_callee)) { - return JsImport::FromJson(json_callee); - } else { - auto result = absl::InvalidArgumentError("json_callee has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_callee.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr, std::unique_ptr>>( + json, + "callee", + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSuper, + .converter = JsSuper::FromJson, + }, + VariantOption>{ + .predicate = IsImport, + .converter = JsImport::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>>> JsNewExpression::GetArguments(const nlohmann::json& json) { - auto arguments_it = json.find("arguments"); - if (arguments_it == json.end()) { - return absl::InvalidArgumentError("`arguments` is undefined."); - } - const nlohmann::json& json_arguments = arguments_it.value(); - - if (json_arguments.is_null()) { - return absl::InvalidArgumentError("json_arguments is null."); - } - if (!json_arguments.is_array()) { - return absl::InvalidArgumentError("json_arguments expected to be array."); - } - - std::vector, std::unique_ptr>> arguments; - for (const nlohmann::json& json_arguments_element : json_arguments) { - if (json_arguments_element.is_null()) { - return absl::InvalidArgumentError("json_arguments_element is null."); - } - std::variant, std::unique_ptr> arguments_element; - if (IsExpression(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsExpression::FromJson(json_arguments_element)); - } else if (IsSpreadElement(json_arguments_element)) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, JsSpreadElement::FromJson(json_arguments_element)); - } else { - auto result = absl::InvalidArgumentError("json_arguments_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_arguments_element.dump()}); - return result; - } - arguments.push_back(std::move(arguments_element)); - } - return arguments; + return GetRequiredField, std::unique_ptr>>>( + json, + "arguments", + List, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }, + VariantOption>{ + .predicate = IsSpreadElement, + .converter = JsSpreadElement::FromJson, + }) + ) + ); } absl::StatusOr> @@ -5822,28 +4745,13 @@ JsNewExpression::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsSequenceExpression::GetExpressions(const nlohmann::json& json) { - auto expressions_it = json.find("expressions"); - if (expressions_it == json.end()) { - return absl::InvalidArgumentError("`expressions` is undefined."); - } - const nlohmann::json& json_expressions = expressions_it.value(); - - if (json_expressions.is_null()) { - return absl::InvalidArgumentError("json_expressions is null."); - } - if (!json_expressions.is_array()) { - return absl::InvalidArgumentError("json_expressions expected to be array."); - } - - std::vector> expressions; - for (const nlohmann::json& json_expressions_element : json_expressions) { - if (json_expressions_element.is_null()) { - return absl::InvalidArgumentError("json_expressions_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto expressions_element, JsExpression::FromJson(json_expressions_element)); - expressions.push_back(std::move(expressions_element)); - } - return expressions; + return GetRequiredField>>( + json, + "expressions", + List>( + JsExpression::FromJson + ) + ); } absl::StatusOr> @@ -5882,16 +4790,11 @@ JsSequenceExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsParenthesizedExpression::GetExpression(const nlohmann::json& json) { - auto expression_it = json.find("expression"); - if (expression_it == json.end()) { - return absl::InvalidArgumentError("`expression` is undefined."); - } - const nlohmann::json& json_expression = expression_it.value(); - - if (json_expression.is_null()) { - return absl::InvalidArgumentError("json_expression is null."); - } - return JsExpression::FromJson(json_expression); + return GetRequiredField>( + json, + "expression", + JsExpression::FromJson + ); } absl::StatusOr> @@ -5930,36 +4833,20 @@ JsParenthesizedExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsTemplateElementValue::GetCooked(const nlohmann::json& json) { - auto cooked_it = json.find("cooked"); - if (cooked_it == json.end()) { - return absl::InvalidArgumentError("`cooked` is undefined."); - } - const nlohmann::json& json_cooked = cooked_it.value(); - - if (json_cooked.is_null()) { - return std::nullopt; - } - if (!json_cooked.is_string()) { - return absl::InvalidArgumentError("Expecting json_cooked.is_string()."); - } - return json_cooked.get(); + return GetNullableField( + json, + "cooked", + JsonToString + ); } absl::StatusOr JsTemplateElementValue::GetRaw(const nlohmann::json& json) { - auto raw_it = json.find("raw"); - if (raw_it == json.end()) { - return absl::InvalidArgumentError("`raw` is undefined."); - } - const nlohmann::json& json_raw = raw_it.value(); - - if (json_raw.is_null()) { - return absl::InvalidArgumentError("json_raw is null."); - } - if (!json_raw.is_string()) { - return absl::InvalidArgumentError("Expecting json_raw.is_string()."); - } - return json_raw.get(); + return GetRequiredField( + json, + "raw", + JsonToString + ); } absl::StatusOr> @@ -5982,33 +4869,20 @@ JsTemplateElementValue::FromJson(const nlohmann::json& json) { absl::StatusOr JsTemplateElement::GetTail(const nlohmann::json& json) { - auto tail_it = json.find("tail"); - if (tail_it == json.end()) { - return absl::InvalidArgumentError("`tail` is undefined."); - } - const nlohmann::json& json_tail = tail_it.value(); - - if (json_tail.is_null()) { - return absl::InvalidArgumentError("json_tail is null."); - } - if (!json_tail.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_tail.is_boolean()."); - } - return json_tail.get(); + return GetRequiredField( + json, + "tail", + JsonToBool + ); } absl::StatusOr> JsTemplateElement::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - return JsTemplateElementValue::FromJson(json_value); + return GetRequiredField>( + json, + "value", + JsTemplateElementValue::FromJson + ); } absl::StatusOr> @@ -6049,54 +4923,24 @@ JsTemplateElement::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsTemplateLiteral::GetQuasis(const nlohmann::json& json) { - auto quasis_it = json.find("quasis"); - if (quasis_it == json.end()) { - return absl::InvalidArgumentError("`quasis` is undefined."); - } - const nlohmann::json& json_quasis = quasis_it.value(); - - if (json_quasis.is_null()) { - return absl::InvalidArgumentError("json_quasis is null."); - } - if (!json_quasis.is_array()) { - return absl::InvalidArgumentError("json_quasis expected to be array."); - } - - std::vector> quasis; - for (const nlohmann::json& json_quasis_element : json_quasis) { - if (json_quasis_element.is_null()) { - return absl::InvalidArgumentError("json_quasis_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto quasis_element, JsTemplateElement::FromJson(json_quasis_element)); - quasis.push_back(std::move(quasis_element)); - } - return quasis; + return GetRequiredField>>( + json, + "quasis", + List>( + JsTemplateElement::FromJson + ) + ); } absl::StatusOr>> JsTemplateLiteral::GetExpressions(const nlohmann::json& json) { - auto expressions_it = json.find("expressions"); - if (expressions_it == json.end()) { - return absl::InvalidArgumentError("`expressions` is undefined."); - } - const nlohmann::json& json_expressions = expressions_it.value(); - - if (json_expressions.is_null()) { - return absl::InvalidArgumentError("json_expressions is null."); - } - if (!json_expressions.is_array()) { - return absl::InvalidArgumentError("json_expressions expected to be array."); - } - - std::vector> expressions; - for (const nlohmann::json& json_expressions_element : json_expressions) { - if (json_expressions_element.is_null()) { - return absl::InvalidArgumentError("json_expressions_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto expressions_element, JsExpression::FromJson(json_expressions_element)); - expressions.push_back(std::move(expressions_element)); - } - return expressions; + return GetRequiredField>>( + json, + "expressions", + List>( + JsExpression::FromJson + ) + ); } absl::StatusOr> @@ -6137,30 +4981,20 @@ JsTemplateLiteral::FromJson(const nlohmann::json& json) { absl::StatusOr> JsTaggedTemplateExpression::GetTag(const nlohmann::json& json) { - auto tag_it = json.find("tag"); - if (tag_it == json.end()) { - return absl::InvalidArgumentError("`tag` is undefined."); - } - const nlohmann::json& json_tag = tag_it.value(); - - if (json_tag.is_null()) { - return absl::InvalidArgumentError("json_tag is null."); - } - return JsExpression::FromJson(json_tag); + return GetRequiredField>( + json, + "tag", + JsExpression::FromJson + ); } absl::StatusOr> JsTaggedTemplateExpression::GetQuasi(const nlohmann::json& json) { - auto quasi_it = json.find("quasi"); - if (quasi_it == json.end()) { - return absl::InvalidArgumentError("`quasi` is undefined."); - } - const nlohmann::json& json_quasi = quasi_it.value(); - - if (json_quasi.is_null()) { - return absl::InvalidArgumentError("json_quasi is null."); - } - return JsTemplateLiteral::FromJson(json_quasi); + return GetRequiredField>( + json, + "quasi", + JsTemplateLiteral::FromJson + ); } absl::StatusOr> @@ -6217,16 +5051,11 @@ static bool IsRestElement(const nlohmann::json& json) { absl::StatusOr> JsRestElement::GetArgument(const nlohmann::json& json) { - auto argument_it = json.find("argument"); - if (argument_it == json.end()) { - return absl::InvalidArgumentError("`argument` is undefined."); - } - const nlohmann::json& json_argument = argument_it.value(); - - if (json_argument.is_null()) { - return absl::InvalidArgumentError("json_argument is null."); - } - return JsLVal::FromJson(json_argument); + return GetRequiredField>( + json, + "argument", + JsLVal::FromJson + ); } absl::StatusOr> @@ -6265,38 +5094,21 @@ JsRestElement::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>>> JsObjectPattern::GetProperties(const nlohmann::json& json) { - auto properties_it = json.find("properties"); - if (properties_it == json.end()) { - return absl::InvalidArgumentError("`properties` is undefined."); - } - const nlohmann::json& json_properties = properties_it.value(); - - if (json_properties.is_null()) { - return absl::InvalidArgumentError("json_properties is null."); - } - if (!json_properties.is_array()) { - return absl::InvalidArgumentError("json_properties expected to be array."); - } - - std::vector, std::unique_ptr>> properties_; - for (const nlohmann::json& json_properties_element : json_properties) { - if (json_properties_element.is_null()) { - return absl::InvalidArgumentError("json_properties_element is null."); - } - std::variant, std::unique_ptr> properties_element; - if (IsObjectProperty(json_properties_element)) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, JsObjectProperty::FromJson(json_properties_element)); - } else if (IsRestElement(json_properties_element)) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, JsRestElement::FromJson(json_properties_element)); - } else { - auto result = absl::InvalidArgumentError("json_properties_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_properties_element.dump()}); - return result; - } - properties_.push_back(std::move(properties_element)); - } - return properties_; + return GetRequiredField, std::unique_ptr>>>( + json, + "properties", + List, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsObjectProperty, + .converter = JsObjectProperty::FromJson, + }, + VariantOption>{ + .predicate = IsRestElement, + .converter = JsRestElement::FromJson, + }) + ) + ); } absl::StatusOr> @@ -6335,28 +5147,15 @@ JsObjectPattern::FromJson(const nlohmann::json& json) { absl::StatusOr>>> JsArrayPattern::GetElements(const nlohmann::json& json) { - auto elements_it = json.find("elements"); - if (elements_it == json.end()) { - return absl::InvalidArgumentError("`elements` is undefined."); - } - const nlohmann::json& json_elements = elements_it.value(); - - if (json_elements.is_null()) { - return absl::InvalidArgumentError("json_elements is null."); - } - if (!json_elements.is_array()) { - return absl::InvalidArgumentError("json_elements expected to be array."); - } - - std::vector>> elements; - for (const nlohmann::json& json_elements_element : json_elements) { - std::optional> elements_element; - if (!json_elements_element.is_null()) { - MALDOCA_ASSIGN_OR_RETURN(elements_element, JsPattern::FromJson(json_elements_element)); - } - elements.push_back(std::move(elements_element)); - } - return elements; + return GetRequiredField>>>( + json, + "elements", + List>>( + Nullable>( + JsPattern::FromJson + ) + ) + ); } absl::StatusOr> @@ -6395,30 +5194,20 @@ JsArrayPattern::FromJson(const nlohmann::json& json) { absl::StatusOr> JsAssignmentPattern::GetLeft(const nlohmann::json& json) { - auto left_it = json.find("left"); - if (left_it == json.end()) { - return absl::InvalidArgumentError("`left` is undefined."); - } - const nlohmann::json& json_left = left_it.value(); - - if (json_left.is_null()) { - return absl::InvalidArgumentError("json_left is null."); - } - return JsPattern::FromJson(json_left); + return GetRequiredField>( + json, + "left", + JsPattern::FromJson + ); } absl::StatusOr> JsAssignmentPattern::GetRight(const nlohmann::json& json) { - auto right_it = json.find("right"); - if (right_it == json.end()) { - return absl::InvalidArgumentError("`right` is undefined."); - } - const nlohmann::json& json_right = right_it.value(); - - if (json_right.is_null()) { - return absl::InvalidArgumentError("json_right is null."); - } - return JsExpression::FromJson(json_right); + return GetRequiredField>( + json, + "right", + JsExpression::FromJson + ); } absl::StatusOr> @@ -6475,67 +5264,38 @@ static bool IsClassMethod(const nlohmann::json& json) { absl::StatusOr> JsClassMethod::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsExpression::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsExpression::FromJson + ); } absl::StatusOr JsClassMethod::GetKind(const nlohmann::json& json) { - auto kind_it = json.find("kind"); - if (kind_it == json.end()) { - return absl::InvalidArgumentError("`kind` is undefined."); - } - const nlohmann::json& json_kind = kind_it.value(); - - if (json_kind.is_null()) { - return absl::InvalidArgumentError("json_kind is null."); - } - if (!json_kind.is_string()) { - return absl::InvalidArgumentError("Expecting json_kind.is_string()."); - } - return json_kind.get(); + return GetRequiredField( + json, + "kind", + JsonToString + ); } absl::StatusOr JsClassMethod::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr JsClassMethod::GetStatic(const nlohmann::json& json) { - auto static_it = json.find("static"); - if (static_it == json.end()) { - return absl::InvalidArgumentError("`static` is undefined."); - } - const nlohmann::json& json_static = static_it.value(); - - if (json_static.is_null()) { - return absl::InvalidArgumentError("json_static is null."); - } - if (!json_static.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_static.is_boolean()."); - } - return json_static.get(); + return GetRequiredField( + json, + "static", + JsonToBool + ); } absl::StatusOr> @@ -6606,67 +5366,38 @@ static bool IsClassPrivateMethod(const nlohmann::json& json) { absl::StatusOr> JsClassPrivateMethod::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsPrivateName::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsPrivateName::FromJson + ); } absl::StatusOr JsClassPrivateMethod::GetKind(const nlohmann::json& json) { - auto kind_it = json.find("kind"); - if (kind_it == json.end()) { - return absl::InvalidArgumentError("`kind` is undefined."); - } - const nlohmann::json& json_kind = kind_it.value(); - - if (json_kind.is_null()) { - return absl::InvalidArgumentError("json_kind is null."); - } - if (!json_kind.is_string()) { - return absl::InvalidArgumentError("Expecting json_kind.is_string()."); - } - return json_kind.get(); + return GetRequiredField( + json, + "kind", + JsonToString + ); } absl::StatusOr JsClassPrivateMethod::GetStatic(const nlohmann::json& json) { - auto static_it = json.find("static"); - if (static_it == json.end()) { - return absl::InvalidArgumentError("`static` is undefined."); - } - const nlohmann::json& json_static = static_it.value(); - - if (json_static.is_null()) { - return absl::InvalidArgumentError("json_static is null."); - } - if (!json_static.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_static.is_boolean()."); - } - return json_static.get(); + return GetRequiredField( + json, + "static", + JsonToBool + ); } absl::StatusOr> JsClassPrivateMethod::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetOptionalField( + json, + "computed", + JsonToBool + ); } absl::StatusOr> @@ -6737,64 +5468,38 @@ static bool IsClassProperty(const nlohmann::json& json) { absl::StatusOr> JsClassProperty::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsExpression::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsExpression::FromJson + ); } absl::StatusOr>> JsClassProperty::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_value); + return GetNullableField>( + json, + "value", + JsExpression::FromJson + ); } absl::StatusOr JsClassProperty::GetStatic(const nlohmann::json& json) { - auto static_it = json.find("static"); - if (static_it == json.end()) { - return absl::InvalidArgumentError("`static` is undefined."); - } - const nlohmann::json& json_static = static_it.value(); - - if (json_static.is_null()) { - return absl::InvalidArgumentError("json_static is null."); - } - if (!json_static.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_static.is_boolean()."); - } - return json_static.get(); + return GetRequiredField( + json, + "static", + JsonToBool + ); } absl::StatusOr JsClassProperty::GetComputed(const nlohmann::json& json) { - auto computed_it = json.find("computed"); - if (computed_it == json.end()) { - return absl::InvalidArgumentError("`computed` is undefined."); - } - const nlohmann::json& json_computed = computed_it.value(); - - if (json_computed.is_null()) { - return absl::InvalidArgumentError("json_computed is null."); - } - if (!json_computed.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_computed.is_boolean()."); - } - return json_computed.get(); + return GetRequiredField( + json, + "computed", + JsonToBool + ); } absl::StatusOr> @@ -6855,47 +5560,29 @@ static bool IsClassPrivateProperty(const nlohmann::json& json) { absl::StatusOr> JsClassPrivateProperty::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsPrivateName::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsPrivateName::FromJson + ); } absl::StatusOr>> JsClassPrivateProperty::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_value); + return GetNullableField>( + json, + "value", + JsExpression::FromJson + ); } absl::StatusOr JsClassPrivateProperty::GetStatic(const nlohmann::json& json) { - auto static_it = json.find("static"); - if (static_it == json.end()) { - return absl::InvalidArgumentError("`static` is undefined."); - } - const nlohmann::json& json_static = static_it.value(); - - if (json_static.is_null()) { - return absl::InvalidArgumentError("json_static is null."); - } - if (!json_static.is_boolean()) { - return absl::InvalidArgumentError("Expecting json_static.is_boolean()."); - } - return json_static.get(); + return GetRequiredField( + json, + "static", + JsonToBool + ); } absl::StatusOr> @@ -6938,42 +5625,29 @@ JsClassPrivateProperty::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr, std::unique_ptr>>> JsClassBody::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - if (!json_body.is_array()) { - return absl::InvalidArgumentError("json_body expected to be array."); - } - - std::vector, std::unique_ptr, std::unique_ptr, std::unique_ptr>> body; - for (const nlohmann::json& json_body_element : json_body) { - if (json_body_element.is_null()) { - return absl::InvalidArgumentError("json_body_element is null."); - } - std::variant, std::unique_ptr, std::unique_ptr, std::unique_ptr> body_element; - if (IsClassMethod(json_body_element)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, JsClassMethod::FromJson(json_body_element)); - } else if (IsClassPrivateMethod(json_body_element)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, JsClassPrivateMethod::FromJson(json_body_element)); - } else if (IsClassProperty(json_body_element)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, JsClassProperty::FromJson(json_body_element)); - } else if (IsClassPrivateProperty(json_body_element)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, JsClassPrivateProperty::FromJson(json_body_element)); - } else { - auto result = absl::InvalidArgumentError("json_body_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_body_element.dump()}); - return result; - } - body.push_back(std::move(body_element)); - } - return body; + return GetRequiredField, std::unique_ptr, std::unique_ptr, std::unique_ptr>>>( + json, + "body", + List, std::unique_ptr, std::unique_ptr, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsClassMethod, + .converter = JsClassMethod::FromJson, + }, + VariantOption>{ + .predicate = IsClassPrivateMethod, + .converter = JsClassPrivateMethod::FromJson, + }, + VariantOption>{ + .predicate = IsClassProperty, + .converter = JsClassProperty::FromJson, + }, + VariantOption>{ + .predicate = IsClassPrivateProperty, + .converter = JsClassPrivateProperty::FromJson, + }) + ) + ); } absl::StatusOr> @@ -7012,30 +5686,20 @@ JsClassBody::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsClass::GetSuperClass(const nlohmann::json& json) { - auto super_class_it = json.find("superClass"); - if (super_class_it == json.end()) { - return absl::InvalidArgumentError("`superClass` is undefined."); - } - const nlohmann::json& json_super_class = super_class_it.value(); - - if (json_super_class.is_null()) { - return std::nullopt; - } - return JsExpression::FromJson(json_super_class); + return GetNullableField>( + json, + "superClass", + JsExpression::FromJson + ); } absl::StatusOr> JsClass::GetBody(const nlohmann::json& json) { - auto body_it = json.find("body"); - if (body_it == json.end()) { - return absl::InvalidArgumentError("`body` is undefined."); - } - const nlohmann::json& json_body = body_it.value(); - - if (json_body.is_null()) { - return absl::InvalidArgumentError("json_body is null."); - } - return JsClassBody::FromJson(json_body); + return GetRequiredField>( + json, + "body", + JsClassBody::FromJson + ); } absl::StatusOr> @@ -7076,16 +5740,11 @@ static bool IsClassDeclaration(const nlohmann::json& json) { absl::StatusOr>> JsClassDeclaration::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return std::nullopt; - } - return JsIdentifier::FromJson(json_id); + return GetNullableField>( + json, + "id", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7128,16 +5787,11 @@ JsClassDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsClassExpression::GetId(const nlohmann::json& json) { - auto id_it = json.find("id"); - if (id_it == json.end()) { - return absl::InvalidArgumentError("`id` is undefined."); - } - const nlohmann::json& json_id = id_it.value(); - - if (json_id.is_null()) { - return std::nullopt; - } - return JsIdentifier::FromJson(json_id); + return GetNullableField>( + json, + "id", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7180,30 +5834,20 @@ JsClassExpression::FromJson(const nlohmann::json& json) { absl::StatusOr> JsMetaProperty::GetMeta(const nlohmann::json& json) { - auto meta_it = json.find("meta"); - if (meta_it == json.end()) { - return absl::InvalidArgumentError("`meta` is undefined."); - } - const nlohmann::json& json_meta = meta_it.value(); - - if (json_meta.is_null()) { - return absl::InvalidArgumentError("json_meta is null."); - } - return JsIdentifier::FromJson(json_meta); + return GetRequiredField>( + json, + "meta", + JsIdentifier::FromJson + ); } absl::StatusOr> JsMetaProperty::GetProperty(const nlohmann::json& json) { - auto property_it = json.find("property"); - if (property_it == json.end()) { - return absl::InvalidArgumentError("`property` is undefined."); - } - const nlohmann::json& json_property = property_it.value(); - - if (json_property.is_null()) { - return absl::InvalidArgumentError("json_property is null."); - } - return JsIdentifier::FromJson(json_property); + return GetRequiredField>( + json, + "property", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7308,39 +5952,28 @@ static bool IsImportSpecifier(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsImportSpecifier::GetImported(const nlohmann::json& json) { - auto imported_it = json.find("imported"); - if (imported_it == json.end()) { - return absl::InvalidArgumentError("`imported` is undefined."); - } - const nlohmann::json& json_imported = imported_it.value(); - - if (json_imported.is_null()) { - return absl::InvalidArgumentError("json_imported is null."); - } - if (IsIdentifier(json_imported)) { - return JsIdentifier::FromJson(json_imported); - } else if (IsStringLiteral(json_imported)) { - return JsStringLiteral::FromJson(json_imported); - } else { - auto result = absl::InvalidArgumentError("json_imported has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_imported.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "imported", + Variant( + VariantOption>{ + .predicate = IsIdentifier, + .converter = JsIdentifier::FromJson, + }, + VariantOption>{ + .predicate = IsStringLiteral, + .converter = JsStringLiteral::FromJson, + }) + ); } absl::StatusOr> JsImportSpecifier::GetLocal(const nlohmann::json& json) { - auto local_it = json.find("local"); - if (local_it == json.end()) { - return absl::InvalidArgumentError("`local` is undefined."); - } - const nlohmann::json& json_local = local_it.value(); - - if (json_local.is_null()) { - return absl::InvalidArgumentError("json_local is null."); - } - return JsIdentifier::FromJson(json_local); + return GetRequiredField>( + json, + "local", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7397,16 +6030,11 @@ static bool IsImportDefaultSpecifier(const nlohmann::json& json) { absl::StatusOr> JsImportDefaultSpecifier::GetLocal(const nlohmann::json& json) { - auto local_it = json.find("local"); - if (local_it == json.end()) { - return absl::InvalidArgumentError("`local` is undefined."); - } - const nlohmann::json& json_local = local_it.value(); - - if (json_local.is_null()) { - return absl::InvalidArgumentError("json_local is null."); - } - return JsIdentifier::FromJson(json_local); + return GetRequiredField>( + json, + "local", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7461,16 +6089,11 @@ static bool IsImportNamespaceSpecifier(const nlohmann::json& json) { absl::StatusOr> JsImportNamespaceSpecifier::GetLocal(const nlohmann::json& json) { - auto local_it = json.find("local"); - if (local_it == json.end()) { - return absl::InvalidArgumentError("`local` is undefined."); - } - const nlohmann::json& json_local = local_it.value(); - - if (json_local.is_null()) { - return absl::InvalidArgumentError("json_local is null."); - } - return JsIdentifier::FromJson(json_local); + return GetRequiredField>( + json, + "local", + JsIdentifier::FromJson + ); } absl::StatusOr> @@ -7509,30 +6132,20 @@ JsImportNamespaceSpecifier::FromJson(const nlohmann::json& json) { absl::StatusOr> JsImportAttribute::GetKey(const nlohmann::json& json) { - auto key_it = json.find("key"); - if (key_it == json.end()) { - return absl::InvalidArgumentError("`key` is undefined."); - } - const nlohmann::json& json_key = key_it.value(); - - if (json_key.is_null()) { - return absl::InvalidArgumentError("json_key is null."); - } - return JsIdentifier::FromJson(json_key); + return GetRequiredField>( + json, + "key", + JsIdentifier::FromJson + ); } absl::StatusOr> JsImportAttribute::GetValue(const nlohmann::json& json) { - auto value_it = json.find("value"); - if (value_it == json.end()) { - return absl::InvalidArgumentError("`value` is undefined."); - } - const nlohmann::json& json_value = value_it.value(); - - if (json_value.is_null()) { - return absl::InvalidArgumentError("json_value is null."); - } - return JsStringLiteral::FromJson(json_value); + return GetRequiredField>( + json, + "value", + JsStringLiteral::FromJson + ); } absl::StatusOr> @@ -7573,68 +6186,43 @@ JsImportAttribute::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr>>> JsImportDeclaration::GetSpecifiers(const nlohmann::json& json) { - auto specifiers_it = json.find("specifiers"); - if (specifiers_it == json.end()) { - return absl::InvalidArgumentError("`specifiers` is undefined."); - } - const nlohmann::json& json_specifiers = specifiers_it.value(); - - if (json_specifiers.is_null()) { - return absl::InvalidArgumentError("json_specifiers is null."); - } - if (!json_specifiers.is_array()) { - return absl::InvalidArgumentError("json_specifiers expected to be array."); - } - - std::vector, std::unique_ptr, std::unique_ptr>> specifiers; - for (const nlohmann::json& json_specifiers_element : json_specifiers) { - if (json_specifiers_element.is_null()) { - return absl::InvalidArgumentError("json_specifiers_element is null."); - } - std::variant, std::unique_ptr, std::unique_ptr> specifiers_element; - if (IsImportSpecifier(json_specifiers_element)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, JsImportSpecifier::FromJson(json_specifiers_element)); - } else if (IsImportDefaultSpecifier(json_specifiers_element)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, JsImportDefaultSpecifier::FromJson(json_specifiers_element)); - } else if (IsImportNamespaceSpecifier(json_specifiers_element)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, JsImportNamespaceSpecifier::FromJson(json_specifiers_element)); - } else { - auto result = absl::InvalidArgumentError("json_specifiers_element has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_specifiers_element.dump()}); - return result; - } - specifiers.push_back(std::move(specifiers_element)); - } - return specifiers; + return GetRequiredField, std::unique_ptr, std::unique_ptr>>>( + json, + "specifiers", + List, std::unique_ptr, std::unique_ptr>>( + Variant( + VariantOption>{ + .predicate = IsImportSpecifier, + .converter = JsImportSpecifier::FromJson, + }, + VariantOption>{ + .predicate = IsImportDefaultSpecifier, + .converter = JsImportDefaultSpecifier::FromJson, + }, + VariantOption>{ + .predicate = IsImportNamespaceSpecifier, + .converter = JsImportNamespaceSpecifier::FromJson, + }) + ) + ); } absl::StatusOr> JsImportDeclaration::GetSource(const nlohmann::json& json) { - auto source_it = json.find("source"); - if (source_it == json.end()) { - return absl::InvalidArgumentError("`source` is undefined."); - } - const nlohmann::json& json_source = source_it.value(); - - if (json_source.is_null()) { - return absl::InvalidArgumentError("json_source is null."); - } - return JsStringLiteral::FromJson(json_source); + return GetRequiredField>( + json, + "source", + JsStringLiteral::FromJson + ); } absl::StatusOr>> JsImportDeclaration::GetAssertions(const nlohmann::json& json) { - auto assertions_it = json.find("assertions"); - if (assertions_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_assertions = assertions_it.value(); - - if (json_assertions.is_null()) { - return absl::InvalidArgumentError("json_assertions is null."); - } - return JsImportAttribute::FromJson(json_assertions); + return GetOptionalField>( + json, + "assertions", + JsImportAttribute::FromJson + ); } absl::StatusOr> @@ -7677,48 +6265,36 @@ JsImportDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr>> JsExportSpecifier::GetExported(const nlohmann::json& json) { - auto exported_it = json.find("exported"); - if (exported_it == json.end()) { - return absl::InvalidArgumentError("`exported` is undefined."); - } - const nlohmann::json& json_exported = exported_it.value(); - - if (json_exported.is_null()) { - return absl::InvalidArgumentError("json_exported is null."); - } - if (IsIdentifier(json_exported)) { - return JsIdentifier::FromJson(json_exported); - } else if (IsStringLiteral(json_exported)) { - return JsStringLiteral::FromJson(json_exported); - } else { - auto result = absl::InvalidArgumentError("json_exported has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_exported.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr>>( + json, + "exported", + Variant( + VariantOption>{ + .predicate = IsIdentifier, + .converter = JsIdentifier::FromJson, + }, + VariantOption>{ + .predicate = IsStringLiteral, + .converter = JsStringLiteral::FromJson, + }) + ); } absl::StatusOr, std::unique_ptr>>> JsExportSpecifier::GetLocal(const nlohmann::json& json) { - auto local_it = json.find("local"); - if (local_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_local = local_it.value(); - - if (json_local.is_null()) { - return absl::InvalidArgumentError("json_local is null."); - } - if (IsIdentifier(json_local)) { - return JsIdentifier::FromJson(json_local); - } else if (IsStringLiteral(json_local)) { - return JsStringLiteral::FromJson(json_local); - } else { - auto result = absl::InvalidArgumentError("json_local has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_local.dump()}); - return result; - } + return GetOptionalField, std::unique_ptr>>( + json, + "local", + Variant( + VariantOption>{ + .predicate = IsIdentifier, + .converter = JsIdentifier::FromJson, + }, + VariantOption>{ + .predicate = IsStringLiteral, + .converter = JsStringLiteral::FromJson, + }) + ); } absl::StatusOr> @@ -7759,82 +6335,42 @@ JsExportSpecifier::FromJson(const nlohmann::json& json) { absl::StatusOr>> JsExportNamedDeclaration::GetDeclaration(const nlohmann::json& json) { - auto declaration_it = json.find("declaration"); - if (declaration_it == json.end()) { - return absl::InvalidArgumentError("`declaration` is undefined."); - } - const nlohmann::json& json_declaration = declaration_it.value(); - - if (json_declaration.is_null()) { - return std::nullopt; - } - return JsDeclaration::FromJson(json_declaration); + return GetNullableField>( + json, + "declaration", + JsDeclaration::FromJson + ); } absl::StatusOr>> JsExportNamedDeclaration::GetSpecifiers(const nlohmann::json& json) { - auto specifiers_it = json.find("specifiers"); - if (specifiers_it == json.end()) { - return absl::InvalidArgumentError("`specifiers` is undefined."); - } - const nlohmann::json& json_specifiers = specifiers_it.value(); - - if (json_specifiers.is_null()) { - return absl::InvalidArgumentError("json_specifiers is null."); - } - if (!json_specifiers.is_array()) { - return absl::InvalidArgumentError("json_specifiers expected to be array."); - } - - std::vector> specifiers; - for (const nlohmann::json& json_specifiers_element : json_specifiers) { - if (json_specifiers_element.is_null()) { - return absl::InvalidArgumentError("json_specifiers_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto specifiers_element, JsExportSpecifier::FromJson(json_specifiers_element)); - specifiers.push_back(std::move(specifiers_element)); - } - return specifiers; + return GetRequiredField>>( + json, + "specifiers", + List>( + JsExportSpecifier::FromJson + ) + ); } absl::StatusOr>> JsExportNamedDeclaration::GetSource(const nlohmann::json& json) { - auto source_it = json.find("source"); - if (source_it == json.end()) { - return absl::InvalidArgumentError("`source` is undefined."); - } - const nlohmann::json& json_source = source_it.value(); - - if (json_source.is_null()) { - return std::nullopt; - } - return JsStringLiteral::FromJson(json_source); + return GetNullableField>( + json, + "source", + JsStringLiteral::FromJson + ); } absl::StatusOr>>> JsExportNamedDeclaration::GetAssertions(const nlohmann::json& json) { - auto assertions_it = json.find("assertions"); - if (assertions_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_assertions = assertions_it.value(); - - if (json_assertions.is_null()) { - return absl::InvalidArgumentError("json_assertions is null."); - } - if (!json_assertions.is_array()) { - return absl::InvalidArgumentError("json_assertions expected to be array."); - } - - std::vector> assertions; - for (const nlohmann::json& json_assertions_element : json_assertions) { - if (json_assertions_element.is_null()) { - return absl::InvalidArgumentError("json_assertions_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto assertions_element, JsImportAttribute::FromJson(json_assertions_element)); - assertions.push_back(std::move(assertions_element)); - } - return assertions; + return GetOptionalField>>( + json, + "assertions", + List>( + JsImportAttribute::FromJson + ) + ); } absl::StatusOr> @@ -7879,27 +6415,23 @@ JsExportNamedDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr, std::unique_ptr, std::unique_ptr>> JsExportDefaultDeclaration::GetDeclaration(const nlohmann::json& json) { - auto declaration_it = json.find("declaration"); - if (declaration_it == json.end()) { - return absl::InvalidArgumentError("`declaration` is undefined."); - } - const nlohmann::json& json_declaration = declaration_it.value(); - - if (json_declaration.is_null()) { - return absl::InvalidArgumentError("json_declaration is null."); - } - if (IsFunctionDeclaration(json_declaration)) { - return JsFunctionDeclaration::FromJson(json_declaration); - } else if (IsClassDeclaration(json_declaration)) { - return JsClassDeclaration::FromJson(json_declaration); - } else if (IsExpression(json_declaration)) { - return JsExpression::FromJson(json_declaration); - } else { - auto result = absl::InvalidArgumentError("json_declaration has invalid type."); - result.SetPayload("json", absl::Cord{json.dump()}); - result.SetPayload("json_element", absl::Cord{json_declaration.dump()}); - return result; - } + return GetRequiredField, std::unique_ptr, std::unique_ptr>>( + json, + "declaration", + Variant( + VariantOption>{ + .predicate = IsFunctionDeclaration, + .converter = JsFunctionDeclaration::FromJson, + }, + VariantOption>{ + .predicate = IsClassDeclaration, + .converter = JsClassDeclaration::FromJson, + }, + VariantOption>{ + .predicate = IsExpression, + .converter = JsExpression::FromJson, + }) + ); } absl::StatusOr> @@ -7938,42 +6470,22 @@ JsExportDefaultDeclaration::FromJson(const nlohmann::json& json) { absl::StatusOr> JsExportAllDeclaration::GetSource(const nlohmann::json& json) { - auto source_it = json.find("source"); - if (source_it == json.end()) { - return absl::InvalidArgumentError("`source` is undefined."); - } - const nlohmann::json& json_source = source_it.value(); - - if (json_source.is_null()) { - return absl::InvalidArgumentError("json_source is null."); - } - return JsStringLiteral::FromJson(json_source); + return GetRequiredField>( + json, + "source", + JsStringLiteral::FromJson + ); } absl::StatusOr>>> JsExportAllDeclaration::GetAssertions(const nlohmann::json& json) { - auto assertions_it = json.find("assertions"); - if (assertions_it == json.end()) { - return std::nullopt; - } - const nlohmann::json& json_assertions = assertions_it.value(); - - if (json_assertions.is_null()) { - return absl::InvalidArgumentError("json_assertions is null."); - } - if (!json_assertions.is_array()) { - return absl::InvalidArgumentError("json_assertions expected to be array."); - } - - std::vector> assertions; - for (const nlohmann::json& json_assertions_element : json_assertions) { - if (json_assertions_element.is_null()) { - return absl::InvalidArgumentError("json_assertions_element is null."); - } - MALDOCA_ASSIGN_OR_RETURN(auto assertions_element, JsImportAttribute::FromJson(json_assertions_element)); - assertions.push_back(std::move(assertions_element)); - } - return assertions; + return GetOptionalField>>( + json, + "assertions", + List>( + JsImportAttribute::FromJson + ) + ); } absl::StatusOr> diff --git a/maldoca/js/driver/conversion.h b/maldoca/js/driver/conversion.h index 2c439f5..b037794 100644 --- a/maldoca/js/driver/conversion.h +++ b/maldoca/js/driver/conversion.h @@ -93,22 +93,6 @@ struct ToJsHirRepr { mlir::MLIRContext &mlir_context); }; -struct ToJsLirRepr { - static absl::StatusOr FromJsSourceRepr( - absl::string_view source, BabelParseRequest parse_request, - absl::Duration timeout, std::optional recursion_depth_limit, - Babel &babel, mlir::MLIRContext &mlir_context); - - static absl::StatusOr FromJsAstStringRepr( - const BabelAstString &ast_string, - std::optional recursion_depth_limit, - mlir::MLIRContext &mlir_context); - - static absl::StatusOr FromJsAstRepr( - const JsFile &ast, const BabelScopes &scopes, - mlir::MLIRContext &mlir_context); -}; - } // namespace maldoca #endif // MALDOCA_JS_DRIVER_CONVERSION_H_ diff --git a/maldoca/js/driver/driver.cc b/maldoca/js/driver/driver.cc index 467f7bd..93b6535 100644 --- a/maldoca/js/driver/driver.cc +++ b/maldoca/js/driver/driver.cc @@ -27,6 +27,7 @@ #include "absl/status/status.h" #include "absl/strings/cord.h" #include "absl/strings/string_view.h" +#include "absl/time/time.h" #include "absl/types/span.h" #include "maldoca/base/status_macros.h" #include "maldoca/js/babel/babel.h" @@ -49,8 +50,6 @@ std::ostream &operator<<(std::ostream &os, JsReprKind kind) { return os << "Ast"; case JsReprKind::kJshir: return os << "Jshir"; - case JsReprKind::kJslir: - return os << "Jslir"; } } @@ -64,7 +63,6 @@ absl::StatusOr> JsRepr::FromProto( case JsReprPb::kBabelAstString: return std::make_unique(proto.babel_ast_string()); case JsReprPb::kJsHir: - case JsReprPb::kJsLir: return absl::UnimplementedError("JSIR parsing not supported"); } } @@ -87,12 +85,6 @@ absl::StatusOr JsHirRepr::ToProto() const { return proto; } -absl::StatusOr JsLirRepr::ToProto() const { - JsReprPb proto; - proto.set_js_lir(mlir::debugString(*op)); - return proto; -} - // ============================================================================= // JsPass // ============================================================================= @@ -173,8 +165,12 @@ bool PassRequiresBabel(const JsPassConfig &pass) { } absl::StatusOr UnsandboxedJsPassRunner::Run( - absl::string_view original_source, const JsReprPb &input_repr_pb, - const JsPassConfigs &passes) { + absl::string_view original_source, const JsReprPb& input_repr_pb, + const JsPassConfigs& passes, absl::Duration timeout) { + if (timeout != absl::InfiniteDuration()) { + DLOG(ERROR) << "In UnsandboxedJsPassRunner, timeout must be infinite. The " + "provided timeout is ignored."; + } MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr input_repr, JsRepr::FromProto(input_repr_pb)); diff --git a/maldoca/js/driver/driver.h b/maldoca/js/driver/driver.h index 6a88b77..60aed9e 100644 --- a/maldoca/js/driver/driver.h +++ b/maldoca/js/driver/driver.h @@ -35,6 +35,7 @@ #include "absl/strings/str_cat.h" #include "absl/strings/str_format.h" #include "absl/strings/string_view.h" +#include "absl/time/time.h" #include "absl/types/span.h" #include "nlohmann/json.hpp" #include "maldoca/base/ret_check.h" @@ -58,7 +59,6 @@ enum class JsReprKind { kAstString, kAst, kJshir, - kJslir, }; std::ostream& operator<<(std::ostream& os, JsReprKind kind); @@ -173,7 +173,7 @@ struct JsirRepr : JsRepr { BabelScopes scopes; static bool classof(const JsRepr* repr) { - return repr->kind == JsReprKind::kJshir || repr->kind == JsReprKind::kJslir; + return repr->kind == JsReprKind::kJshir; } std::string Dump() const override { return mlir::debugString(*op); } @@ -195,17 +195,6 @@ struct JsHirRepr : JsirRepr { absl::StatusOr ToProto() const override; }; -struct JsLirRepr : JsirRepr { - explicit JsLirRepr(mlir::OwningOpRef op, BabelScopes scopes) - : JsirRepr(JsReprKind::kJslir, std::move(op), std::move(scopes)) {} - - static bool classof(const JsRepr* repr) { - return repr->kind == JsReprKind::kJslir; - } - - absl::StatusOr ToProto() const override; -}; - // ============================================================================= // JsPass // ============================================================================= @@ -252,7 +241,8 @@ class JsPassRunner { virtual absl::StatusOr Run(absl::string_view original_source, const JsReprPb& input_repr_pb, - const JsPassConfigs& passes) = 0; + const JsPassConfigs& passes, + absl::Duration timeout) = 0; }; class UnsandboxedJsPassRunner : public JsPassRunner { @@ -262,7 +252,17 @@ class UnsandboxedJsPassRunner : public JsPassRunner { absl::StatusOr Run(absl::string_view original_source, const JsReprPb& input_repr_pb, - const JsPassConfigs& passes) override; + const JsPassConfigs& passes, + absl::Duration timeout) override; + + absl::StatusOr Run(absl::string_view original_source, + const JsReprPb& input_repr_pb, + const JsPassConfigs& passes) { + // Default arguments on virtual or override methods are prohibited. + // go/cstyle#Default_Arguments. + return Run(original_source, input_repr_pb, passes, + absl::InfiniteDuration()); + }; private: Babel* absl_nullable babel_; diff --git a/maldoca/js/driver/driver.proto b/maldoca/js/driver/driver.proto index 0e8e061..c428fdf 100644 --- a/maldoca/js/driver/driver.proto +++ b/maldoca/js/driver/driver.proto @@ -26,11 +26,12 @@ option java_multiple_files = true; // ============================================================================= message JsReprPb { + reserved 4; + oneof kind { string js_source = 1; BabelAstString babel_ast_string = 2; string js_hir = 3; - string js_lir = 4; } } @@ -74,10 +75,6 @@ message JsAstToHirConfig {} message JsHirToAstConfig {} -message JsHirToLirConfig {} - -message JsLirToHirConfig {} - // ============================================================================= // Analysis // ============================================================================= diff --git a/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h b/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h index 0729cda..78eeda8 100644 --- a/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h +++ b/maldoca/js/ir/analyses/conditional_forward_dataflow_analysis.h @@ -22,6 +22,7 @@ #include "mlir/Analysis/DataFlowFramework.h" #include "mlir/IR/Block.h" #include "mlir/IR/BlockSupport.h" +#include "mlir/IR/MLIRContext.h" #include "mlir/IR/Operation.h" #include "maldoca/js/ir/analyses/dataflow_analysis.h" #include "maldoca/js/ir/ir.h" @@ -55,7 +56,10 @@ class JsirConditionalForwardDataFlowAnalysis llvm::MutableArrayRef> results, JsirStateRef after) = 0; - virtual bool IsCfgEdgeExecutable(JsirGeneralCfgEdge *edge) { return true; } + virtual bool IsCfgEdgeExecutable(JsirGeneralCfgEdge *edge, + mlir::MLIRContext *context) { + return true; + } void PrintAtBlockEntry(mlir::Block &block, size_t num_indents, llvm::raw_ostream &os) override { @@ -95,7 +99,7 @@ void JsirConditionalForwardDataFlowAnalysis::VisitOp( auto [operands, result_state_refs] = Base::GetValueStateRefs(op); for (JsirGeneralCfgEdge *edge : this->op_to_cfg_edges_[op]) { - if (!IsCfgEdgeExecutable(edge) || + if (!IsCfgEdgeExecutable(edge, op->getContext()) || !*GetIsExecutable(edge->getPred()->getBlock()).value()) { continue; } @@ -160,7 +164,7 @@ template void JsirConditionalForwardDataFlowAnalysis::VisitBlock( mlir::Block *block) { for (auto *edge : Base::block_to_cfg_edges_[block]) { - if (!IsCfgEdgeExecutable(edge) || + if (!IsCfgEdgeExecutable(edge, block->getParent()->getContext()) || !*GetIsExecutable(edge->getPred()->getBlock()).value()) { continue; } diff --git a/maldoca/js/ir/analyses/constant_propagation/analysis.cc b/maldoca/js/ir/analyses/constant_propagation/analysis.cc index 586ab3b..4291b3a 100644 --- a/maldoca/js/ir/analyses/constant_propagation/analysis.cc +++ b/maldoca/js/ir/analyses/constant_propagation/analysis.cc @@ -269,16 +269,17 @@ void JsirConstantPropagationAnalysis::VisitUpdateExpression( } bool JsirConstantPropagationAnalysis::IsCfgEdgeExecutable( - JsirGeneralCfgEdge *edge) { + JsirGeneralCfgEdge *edge, mlir::MLIRContext *context) { if (!edge->getLivenessInfo().has_value()) { return true; } - auto [liveness_kind, liveness_values] = edge->getLivenessInfo().value(); + JsirDialect* dialect = context->getOrLoadDialect(); + + std::unique_ptr& qjs_context = + dialect->qjs_context; - std::unique_ptr qjs_runtime{JS_NewRuntime()}; - std::unique_ptr qjs_context{ - JS_NewContext(qjs_runtime.get())}; + auto [liveness_kind, liveness_values] = edge->getLivenessInfo().value(); std::vector> qjs_values; for (auto arg : liveness_values) { diff --git a/maldoca/js/ir/analyses/constant_propagation/analysis.h b/maldoca/js/ir/analyses/constant_propagation/analysis.h index 3cfeb83..97f52a1 100644 --- a/maldoca/js/ir/analyses/constant_propagation/analysis.h +++ b/maldoca/js/ir/analyses/constant_propagation/analysis.h @@ -194,7 +194,8 @@ class JsirConstantPropagationAnalysis llvm::MutableArrayRef> results, JsirStateRef after); - bool IsCfgEdgeExecutable(JsirGeneralCfgEdge *edge) override; + bool IsCfgEdgeExecutable(JsirGeneralCfgEdge *edge, mlir::MLIRContext *context) + override; void VisitOp( mlir::Operation *op, diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/and/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/and/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/and/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/and/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/break/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/break/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/break/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/break/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/conditional/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/conditional/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/continue/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/continue/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/continue/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/continue/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/do_while/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/do_while/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/for/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_in/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_in/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/for_of/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/for_of/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/function/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/function/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/function/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/function/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/if/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_dead/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/if_var_unknown/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/label/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/label/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/label/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/label/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/literal/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/literal/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/literal/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/literal/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/nullish_coalesce/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/obfuscated/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/or/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/or/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/or/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/or/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/simple/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/simple_symbol/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/switch/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/switch/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/switch/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/switch/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/try_catch/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/undeclared_var/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/update_expression/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/void_0/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/void_0/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/while/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/BUILD b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/BUILD index 9944d5f..224e845 100644 --- a/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/BUILD +++ b/maldoca/js/ir/analyses/constant_propagation/tests/while_dead/BUILD @@ -18,12 +18,20 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "README.generated.md", "input.js", "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/BUILD b/maldoca/js/ir/conversion/BUILD index 7e8ab2e..a8cce85 100644 --- a/maldoca/js/ir/conversion/BUILD +++ b/maldoca/js/ir/conversion/BUILD @@ -61,6 +61,7 @@ cc_library( "jsir_to_ast.h", ], deps = [ + "//maldoca/astgen:ir_to_ast_util", "//maldoca/base:status", "//maldoca/js/ast", "//maldoca/js/ir", diff --git a/maldoca/js/ir/conversion/ast_to_jsir.generated.cc b/maldoca/js/ir/conversion/ast_to_jsir.generated.cc index 48c6997..b95be6f 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.generated.cc +++ b/maldoca/js/ir/conversion/ast_to_jsir.generated.cc @@ -45,832 +45,832 @@ namespace maldoca { -JsirProgramBodyElementOpInterface AstToJsir::VisitProgramBodyElement(const JsProgramBodyElement *node) { +JsirProgramBodyElementOpInterface AstToJsir::VisitProgramBodyElement(mlir::OpBuilder &builder, const JsProgramBodyElement *node) { if (auto *expression_statement = dynamic_cast(node)) { - return VisitExpressionStatement(expression_statement); + return VisitExpressionStatement(builder, expression_statement); } if (auto *block_statement = dynamic_cast(node)) { - return VisitBlockStatement(block_statement); + return VisitBlockStatement(builder, block_statement); } if (auto *empty_statement = dynamic_cast(node)) { - return VisitEmptyStatement(empty_statement); + return VisitEmptyStatement(builder, empty_statement); } if (auto *debugger_statement = dynamic_cast(node)) { - return VisitDebuggerStatement(debugger_statement); + return VisitDebuggerStatement(builder, debugger_statement); } if (auto *with_statement = dynamic_cast(node)) { - return VisitWithStatement(with_statement); + return VisitWithStatement(builder, with_statement); } if (auto *return_statement = dynamic_cast(node)) { - return VisitReturnStatement(return_statement); + return VisitReturnStatement(builder, return_statement); } if (auto *labeled_statement = dynamic_cast(node)) { - return VisitLabeledStatement(labeled_statement); + return VisitLabeledStatement(builder, labeled_statement); } if (auto *break_statement = dynamic_cast(node)) { - return VisitBreakStatement(break_statement); + return VisitBreakStatement(builder, break_statement); } if (auto *continue_statement = dynamic_cast(node)) { - return VisitContinueStatement(continue_statement); + return VisitContinueStatement(builder, continue_statement); } if (auto *if_statement = dynamic_cast(node)) { - return VisitIfStatement(if_statement); + return VisitIfStatement(builder, if_statement); } if (auto *switch_statement = dynamic_cast(node)) { - return VisitSwitchStatement(switch_statement); + return VisitSwitchStatement(builder, switch_statement); } if (auto *throw_statement = dynamic_cast(node)) { - return VisitThrowStatement(throw_statement); + return VisitThrowStatement(builder, throw_statement); } if (auto *try_statement = dynamic_cast(node)) { - return VisitTryStatement(try_statement); + return VisitTryStatement(builder, try_statement); } if (auto *while_statement = dynamic_cast(node)) { - return VisitWhileStatement(while_statement); + return VisitWhileStatement(builder, while_statement); } if (auto *do_while_statement = dynamic_cast(node)) { - return VisitDoWhileStatement(do_while_statement); + return VisitDoWhileStatement(builder, do_while_statement); } if (auto *for_statement = dynamic_cast(node)) { - return VisitForStatement(for_statement); + return VisitForStatement(builder, for_statement); } if (auto *for_in_statement = dynamic_cast(node)) { - return VisitForInStatement(for_in_statement); + return VisitForInStatement(builder, for_in_statement); } if (auto *for_of_statement = dynamic_cast(node)) { - return VisitForOfStatement(for_of_statement); + return VisitForOfStatement(builder, for_of_statement); } if (auto *function_declaration = dynamic_cast(node)) { - return VisitFunctionDeclaration(function_declaration); + return VisitFunctionDeclaration(builder, function_declaration); } if (auto *variable_declaration = dynamic_cast(node)) { - return VisitVariableDeclaration(variable_declaration); + return VisitVariableDeclaration(builder, variable_declaration); } if (auto *class_declaration = dynamic_cast(node)) { - return VisitClassDeclaration(class_declaration); + return VisitClassDeclaration(builder, class_declaration); } if (auto *import_declaration = dynamic_cast(node)) { - return VisitImportDeclaration(import_declaration); + return VisitImportDeclaration(builder, import_declaration); } if (auto *export_named_declaration = dynamic_cast(node)) { - return VisitExportNamedDeclaration(export_named_declaration); + return VisitExportNamedDeclaration(builder, export_named_declaration); } if (auto *export_default_declaration = dynamic_cast(node)) { - return VisitExportDefaultDeclaration(export_default_declaration); + return VisitExportDefaultDeclaration(builder, export_default_declaration); } if (auto *export_all_declaration = dynamic_cast(node)) { - return VisitExportAllDeclaration(export_all_declaration); + return VisitExportAllDeclaration(builder, export_all_declaration); } LOG(FATAL) << "Unreachable code."; } -JsirDirectiveLiteralOp AstToJsir::VisitDirectiveLiteral(const JsDirectiveLiteral *node) { - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); +JsirDirectiveLiteralOp AstToJsir::VisitDirectiveLiteral(mlir::OpBuilder &builder, const JsDirectiveLiteral *node) { + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); JsirDirectiveLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitDirectiveLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitDirectiveLiteralExtraAttr(builder, node->extra().value()); } - return CreateExpr(node, mlir_value, mlir_extra); + return CreateExpr(builder, node, mlir_value, mlir_extra); } -JsirDirectiveOp AstToJsir::VisitDirective(const JsDirective *node) { - mlir::Value mlir_value = VisitDirectiveLiteral(node->value()); - return CreateStmt(node, mlir_value); +JsirDirectiveOp AstToJsir::VisitDirective(mlir::OpBuilder &builder, const JsDirective *node) { + mlir::Value mlir_value = VisitDirectiveLiteral(builder, node->value()); + return CreateStmt(builder, node, mlir_value); } -JsirProgramOp AstToJsir::VisitProgram(const JsProgram *node) { +JsirProgramOp AstToJsir::VisitProgram(mlir::OpBuilder &builder, const JsProgram *node) { JsirInterpreterDirectiveAttr mlir_interpreter; if (node->interpreter().has_value()) { - mlir_interpreter = VisitInterpreterDirectiveAttr(node->interpreter().value()); + mlir_interpreter = VisitInterpreterDirectiveAttr(builder, node->interpreter().value()); } - mlir::StringAttr mlir_source_type = builder_.getStringAttr(node->source_type()); - auto op = CreateStmt(node, mlir_interpreter, mlir_source_type); + mlir::StringAttr mlir_source_type = builder.getStringAttr(node->source_type()); + auto op = CreateStmt(builder, node, mlir_interpreter, mlir_source_type); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { for (const auto &element : *node->body()) { - VisitProgramBodyElement(element.get()); + VisitProgramBodyElement(builder, element.get()); } }); mlir::Region &mlir_directives_region = op.getDirectives(); - AppendNewBlockAndPopulate(mlir_directives_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_directives_region, [&] { for (const auto &element : *node->directives()) { - VisitDirective(element.get()); + VisitDirective(builder, element.get()); } }); return op; } -JsirFileOp AstToJsir::VisitFile(const JsFile *node) { +JsirFileOp AstToJsir::VisitFile(mlir::OpBuilder &builder, const JsFile *node) { mlir::ArrayAttr mlir_comments; if (node->comments().has_value()) { std::vector mlir_comments_data; for (const auto &element : *node->comments().value()) { - JsirCommentAttrInterface mlir_element = VisitCommentAttr(element.get()); + JsirCommentAttrInterface mlir_element = VisitCommentAttr(builder, element.get()); mlir_comments_data.push_back(std::move(mlir_element)); } - mlir_comments = builder_.getArrayAttr(mlir_comments_data); + mlir_comments = builder.getArrayAttr(mlir_comments_data); } - auto op = CreateStmt(node, mlir_comments); + auto op = CreateStmt(builder, node, mlir_comments); mlir::Region &mlir_program_region = op.getProgram(); - AppendNewBlockAndPopulate(mlir_program_region, [&] { - VisitProgram(node->program()); + AppendNewBlockAndPopulate(builder, mlir_program_region, [&] { + VisitProgram(builder, node->program()); }); return op; } -JsirExpressionOpInterface AstToJsir::VisitExpression(const JsExpression *node) { +JsirExpressionOpInterface AstToJsir::VisitExpression(mlir::OpBuilder &builder, const JsExpression *node) { if (auto *identifier = dynamic_cast(node)) { - return VisitIdentifier(identifier); + return VisitIdentifier(builder, identifier); } if (auto *reg_exp_literal = dynamic_cast(node)) { - return VisitRegExpLiteral(reg_exp_literal); + return VisitRegExpLiteral(builder, reg_exp_literal); } if (auto *null_literal = dynamic_cast(node)) { - return VisitNullLiteral(null_literal); + return VisitNullLiteral(builder, null_literal); } if (auto *string_literal = dynamic_cast(node)) { - return VisitStringLiteral(string_literal); + return VisitStringLiteral(builder, string_literal); } if (auto *boolean_literal = dynamic_cast(node)) { - return VisitBooleanLiteral(boolean_literal); + return VisitBooleanLiteral(builder, boolean_literal); } if (auto *numeric_literal = dynamic_cast(node)) { - return VisitNumericLiteral(numeric_literal); + return VisitNumericLiteral(builder, numeric_literal); } if (auto *big_int_literal = dynamic_cast(node)) { - return VisitBigIntLiteral(big_int_literal); + return VisitBigIntLiteral(builder, big_int_literal); } if (auto *this_expression = dynamic_cast(node)) { - return VisitThisExpression(this_expression); + return VisitThisExpression(builder, this_expression); } if (auto *arrow_function_expression = dynamic_cast(node)) { - return VisitArrowFunctionExpression(arrow_function_expression); + return VisitArrowFunctionExpression(builder, arrow_function_expression); } if (auto *yield_expression = dynamic_cast(node)) { - return VisitYieldExpression(yield_expression); + return VisitYieldExpression(builder, yield_expression); } if (auto *await_expression = dynamic_cast(node)) { - return VisitAwaitExpression(await_expression); + return VisitAwaitExpression(builder, await_expression); } if (auto *array_expression = dynamic_cast(node)) { - return VisitArrayExpression(array_expression); + return VisitArrayExpression(builder, array_expression); } if (auto *object_expression = dynamic_cast(node)) { - return VisitObjectExpression(object_expression); + return VisitObjectExpression(builder, object_expression); } if (auto *function_expression = dynamic_cast(node)) { - return VisitFunctionExpression(function_expression); + return VisitFunctionExpression(builder, function_expression); } if (auto *unary_expression = dynamic_cast(node)) { - return VisitUnaryExpression(unary_expression); + return VisitUnaryExpression(builder, unary_expression); } if (auto *update_expression = dynamic_cast(node)) { - return VisitUpdateExpression(update_expression); + return VisitUpdateExpression(builder, update_expression); } if (auto *binary_expression = dynamic_cast(node)) { - return VisitBinaryExpression(binary_expression); + return VisitBinaryExpression(builder, binary_expression); } if (auto *assignment_expression = dynamic_cast(node)) { - return VisitAssignmentExpression(assignment_expression); + return VisitAssignmentExpression(builder, assignment_expression); } if (auto *logical_expression = dynamic_cast(node)) { - return VisitLogicalExpression(logical_expression); + return VisitLogicalExpression(builder, logical_expression); } if (auto *member_expression = dynamic_cast(node)) { - return VisitMemberExpression(member_expression); + return VisitMemberExpression(builder, member_expression); } if (auto *optional_member_expression = dynamic_cast(node)) { - return VisitOptionalMemberExpression(optional_member_expression); + return VisitOptionalMemberExpression(builder, optional_member_expression); } if (auto *conditional_expression = dynamic_cast(node)) { - return VisitConditionalExpression(conditional_expression); + return VisitConditionalExpression(builder, conditional_expression); } if (auto *call_expression = dynamic_cast(node)) { - return VisitCallExpression(call_expression); + return VisitCallExpression(builder, call_expression); } if (auto *optional_call_expression = dynamic_cast(node)) { - return VisitOptionalCallExpression(optional_call_expression); + return VisitOptionalCallExpression(builder, optional_call_expression); } if (auto *new_expression = dynamic_cast(node)) { - return VisitNewExpression(new_expression); + return VisitNewExpression(builder, new_expression); } if (auto *sequence_expression = dynamic_cast(node)) { - return VisitSequenceExpression(sequence_expression); + return VisitSequenceExpression(builder, sequence_expression); } if (auto *parenthesized_expression = dynamic_cast(node)) { - return VisitParenthesizedExpression(parenthesized_expression); + return VisitParenthesizedExpression(builder, parenthesized_expression); } if (auto *template_literal = dynamic_cast(node)) { - return VisitTemplateLiteral(template_literal); + return VisitTemplateLiteral(builder, template_literal); } if (auto *tagged_template_expression = dynamic_cast(node)) { - return VisitTaggedTemplateExpression(tagged_template_expression); + return VisitTaggedTemplateExpression(builder, tagged_template_expression); } if (auto *class_expression = dynamic_cast(node)) { - return VisitClassExpression(class_expression); + return VisitClassExpression(builder, class_expression); } if (auto *meta_property = dynamic_cast(node)) { - return VisitMetaProperty(meta_property); + return VisitMetaProperty(builder, meta_property); } LOG(FATAL) << "Unreachable code."; } -JsirPatternRefOpInterface AstToJsir::VisitPatternRef(const JsPattern *node) { +JsirPatternRefOpInterface AstToJsir::VisitPatternRef(mlir::OpBuilder &builder, const JsPattern *node) { if (auto *identifier = dynamic_cast(node)) { - return VisitIdentifierRef(identifier); + return VisitIdentifierRef(builder, identifier); } if (auto *member_expression = dynamic_cast(node)) { - return VisitMemberExpressionRef(member_expression); + return VisitMemberExpressionRef(builder, member_expression); } if (auto *parenthesized_expression = dynamic_cast(node)) { - return VisitParenthesizedExpressionRef(parenthesized_expression); + return VisitParenthesizedExpressionRef(builder, parenthesized_expression); } if (auto *object_pattern = dynamic_cast(node)) { - return VisitObjectPatternRef(object_pattern); + return VisitObjectPatternRef(builder, object_pattern); } if (auto *array_pattern = dynamic_cast(node)) { - return VisitArrayPatternRef(array_pattern); + return VisitArrayPatternRef(builder, array_pattern); } if (auto *rest_element = dynamic_cast(node)) { - return VisitRestElementRef(rest_element); + return VisitRestElementRef(builder, rest_element); } if (auto *assignment_pattern = dynamic_cast(node)) { - return VisitAssignmentPatternRef(assignment_pattern); + return VisitAssignmentPatternRef(builder, assignment_pattern); } LOG(FATAL) << "Unreachable code."; } -JsirLValRefOpInterface AstToJsir::VisitLValRef(const JsLVal *node) { +JsirLValRefOpInterface AstToJsir::VisitLValRef(mlir::OpBuilder &builder, const JsLVal *node) { if (auto *identifier = dynamic_cast(node)) { - return VisitIdentifierRef(identifier); + return VisitIdentifierRef(builder, identifier); } if (auto *member_expression = dynamic_cast(node)) { - return VisitMemberExpressionRef(member_expression); + return VisitMemberExpressionRef(builder, member_expression); } if (auto *parenthesized_expression = dynamic_cast(node)) { - return VisitParenthesizedExpressionRef(parenthesized_expression); + return VisitParenthesizedExpressionRef(builder, parenthesized_expression); } if (auto *object_pattern = dynamic_cast(node)) { - return VisitObjectPatternRef(object_pattern); + return VisitObjectPatternRef(builder, object_pattern); } if (auto *array_pattern = dynamic_cast(node)) { - return VisitArrayPatternRef(array_pattern); + return VisitArrayPatternRef(builder, array_pattern); } if (auto *rest_element = dynamic_cast(node)) { - return VisitRestElementRef(rest_element); + return VisitRestElementRef(builder, rest_element); } if (auto *assignment_pattern = dynamic_cast(node)) { - return VisitAssignmentPatternRef(assignment_pattern); + return VisitAssignmentPatternRef(builder, assignment_pattern); } LOG(FATAL) << "Unreachable code."; } -JsirIdentifierOp AstToJsir::VisitIdentifier(const JsIdentifier *node) { - mlir::StringAttr mlir_name = builder_.getStringAttr(node->name()); - return CreateExpr(node, mlir_name); +JsirIdentifierOp AstToJsir::VisitIdentifier(mlir::OpBuilder &builder, const JsIdentifier *node) { + mlir::StringAttr mlir_name = builder.getStringAttr(node->name()); + return CreateExpr(builder, node, mlir_name); } -JsirIdentifierRefOp AstToJsir::VisitIdentifierRef(const JsIdentifier *node) { - mlir::StringAttr mlir_name = builder_.getStringAttr(node->name()); - return CreateExpr(node, mlir_name); +JsirIdentifierRefOp AstToJsir::VisitIdentifierRef(mlir::OpBuilder &builder, const JsIdentifier *node) { + mlir::StringAttr mlir_name = builder.getStringAttr(node->name()); + return CreateExpr(builder, node, mlir_name); } -JsirPrivateNameOp AstToJsir::VisitPrivateName(const JsPrivateName *node) { - JsirIdentifierAttr mlir_id = VisitIdentifierAttr(node->id()); - return CreateExpr(node, mlir_id); +JsirPrivateNameOp AstToJsir::VisitPrivateName(mlir::OpBuilder &builder, const JsPrivateName *node) { + JsirIdentifierAttr mlir_id = VisitIdentifierAttr(builder, node->id()); + return CreateExpr(builder, node, mlir_id); } -JsirLiteralOpInterface AstToJsir::VisitLiteral(const JsLiteral *node) { +JsirLiteralOpInterface AstToJsir::VisitLiteral(mlir::OpBuilder &builder, const JsLiteral *node) { if (auto *reg_exp_literal = dynamic_cast(node)) { - return VisitRegExpLiteral(reg_exp_literal); + return VisitRegExpLiteral(builder, reg_exp_literal); } if (auto *null_literal = dynamic_cast(node)) { - return VisitNullLiteral(null_literal); + return VisitNullLiteral(builder, null_literal); } if (auto *string_literal = dynamic_cast(node)) { - return VisitStringLiteral(string_literal); + return VisitStringLiteral(builder, string_literal); } if (auto *boolean_literal = dynamic_cast(node)) { - return VisitBooleanLiteral(boolean_literal); + return VisitBooleanLiteral(builder, boolean_literal); } if (auto *numeric_literal = dynamic_cast(node)) { - return VisitNumericLiteral(numeric_literal); + return VisitNumericLiteral(builder, numeric_literal); } if (auto *big_int_literal = dynamic_cast(node)) { - return VisitBigIntLiteral(big_int_literal); + return VisitBigIntLiteral(builder, big_int_literal); } LOG(FATAL) << "Unreachable code."; } -JsirRegExpLiteralOp AstToJsir::VisitRegExpLiteral(const JsRegExpLiteral *node) { - mlir::StringAttr mlir_pattern = builder_.getStringAttr(node->pattern()); - mlir::StringAttr mlir_flags = builder_.getStringAttr(node->flags()); +JsirRegExpLiteralOp AstToJsir::VisitRegExpLiteral(mlir::OpBuilder &builder, const JsRegExpLiteral *node) { + mlir::StringAttr mlir_pattern = builder.getStringAttr(node->pattern()); + mlir::StringAttr mlir_flags = builder.getStringAttr(node->flags()); JsirRegExpLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitRegExpLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitRegExpLiteralExtraAttr(builder, node->extra().value()); } - return CreateExpr(node, mlir_pattern, mlir_flags, mlir_extra); + return CreateExpr(builder, node, mlir_pattern, mlir_flags, mlir_extra); } -JsirNullLiteralOp AstToJsir::VisitNullLiteral(const JsNullLiteral *node) { - return CreateExpr(node); +JsirNullLiteralOp AstToJsir::VisitNullLiteral(mlir::OpBuilder &builder, const JsNullLiteral *node) { + return CreateExpr(builder, node); } -JsirStringLiteralOp AstToJsir::VisitStringLiteral(const JsStringLiteral *node) { - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); +JsirStringLiteralOp AstToJsir::VisitStringLiteral(mlir::OpBuilder &builder, const JsStringLiteral *node) { + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); JsirStringLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitStringLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitStringLiteralExtraAttr(builder, node->extra().value()); } - return CreateExpr(node, mlir_value, mlir_extra); + return CreateExpr(builder, node, mlir_value, mlir_extra); } -JsirBooleanLiteralOp AstToJsir::VisitBooleanLiteral(const JsBooleanLiteral *node) { - mlir::BoolAttr mlir_value = builder_.getBoolAttr(node->value()); - return CreateExpr(node, mlir_value); +JsirBooleanLiteralOp AstToJsir::VisitBooleanLiteral(mlir::OpBuilder &builder, const JsBooleanLiteral *node) { + mlir::BoolAttr mlir_value = builder.getBoolAttr(node->value()); + return CreateExpr(builder, node, mlir_value); } -JsirNumericLiteralOp AstToJsir::VisitNumericLiteral(const JsNumericLiteral *node) { - mlir::FloatAttr mlir_value = builder_.getF64FloatAttr(node->value()); +JsirNumericLiteralOp AstToJsir::VisitNumericLiteral(mlir::OpBuilder &builder, const JsNumericLiteral *node) { + mlir::FloatAttr mlir_value = builder.getF64FloatAttr(node->value()); JsirNumericLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitNumericLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitNumericLiteralExtraAttr(builder, node->extra().value()); } - return CreateExpr(node, mlir_value, mlir_extra); + return CreateExpr(builder, node, mlir_value, mlir_extra); } -JsirBigIntLiteralOp AstToJsir::VisitBigIntLiteral(const JsBigIntLiteral *node) { - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); +JsirBigIntLiteralOp AstToJsir::VisitBigIntLiteral(mlir::OpBuilder &builder, const JsBigIntLiteral *node) { + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); JsirBigIntLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitBigIntLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitBigIntLiteralExtraAttr(builder, node->extra().value()); } - return CreateExpr(node, mlir_value, mlir_extra); + return CreateExpr(builder, node, mlir_value, mlir_extra); } -JsirStatementOpInterface AstToJsir::VisitStatement(const JsStatement *node) { +JsirStatementOpInterface AstToJsir::VisitStatement(mlir::OpBuilder &builder, const JsStatement *node) { if (auto *expression_statement = dynamic_cast(node)) { - return VisitExpressionStatement(expression_statement); + return VisitExpressionStatement(builder, expression_statement); } if (auto *block_statement = dynamic_cast(node)) { - return VisitBlockStatement(block_statement); + return VisitBlockStatement(builder, block_statement); } if (auto *empty_statement = dynamic_cast(node)) { - return VisitEmptyStatement(empty_statement); + return VisitEmptyStatement(builder, empty_statement); } if (auto *debugger_statement = dynamic_cast(node)) { - return VisitDebuggerStatement(debugger_statement); + return VisitDebuggerStatement(builder, debugger_statement); } if (auto *with_statement = dynamic_cast(node)) { - return VisitWithStatement(with_statement); + return VisitWithStatement(builder, with_statement); } if (auto *return_statement = dynamic_cast(node)) { - return VisitReturnStatement(return_statement); + return VisitReturnStatement(builder, return_statement); } if (auto *labeled_statement = dynamic_cast(node)) { - return VisitLabeledStatement(labeled_statement); + return VisitLabeledStatement(builder, labeled_statement); } if (auto *break_statement = dynamic_cast(node)) { - return VisitBreakStatement(break_statement); + return VisitBreakStatement(builder, break_statement); } if (auto *continue_statement = dynamic_cast(node)) { - return VisitContinueStatement(continue_statement); + return VisitContinueStatement(builder, continue_statement); } if (auto *if_statement = dynamic_cast(node)) { - return VisitIfStatement(if_statement); + return VisitIfStatement(builder, if_statement); } if (auto *switch_statement = dynamic_cast(node)) { - return VisitSwitchStatement(switch_statement); + return VisitSwitchStatement(builder, switch_statement); } if (auto *throw_statement = dynamic_cast(node)) { - return VisitThrowStatement(throw_statement); + return VisitThrowStatement(builder, throw_statement); } if (auto *try_statement = dynamic_cast(node)) { - return VisitTryStatement(try_statement); + return VisitTryStatement(builder, try_statement); } if (auto *while_statement = dynamic_cast(node)) { - return VisitWhileStatement(while_statement); + return VisitWhileStatement(builder, while_statement); } if (auto *do_while_statement = dynamic_cast(node)) { - return VisitDoWhileStatement(do_while_statement); + return VisitDoWhileStatement(builder, do_while_statement); } if (auto *for_statement = dynamic_cast(node)) { - return VisitForStatement(for_statement); + return VisitForStatement(builder, for_statement); } if (auto *for_in_statement = dynamic_cast(node)) { - return VisitForInStatement(for_in_statement); + return VisitForInStatement(builder, for_in_statement); } if (auto *for_of_statement = dynamic_cast(node)) { - return VisitForOfStatement(for_of_statement); + return VisitForOfStatement(builder, for_of_statement); } if (auto *function_declaration = dynamic_cast(node)) { - return VisitFunctionDeclaration(function_declaration); + return VisitFunctionDeclaration(builder, function_declaration); } if (auto *variable_declaration = dynamic_cast(node)) { - return VisitVariableDeclaration(variable_declaration); + return VisitVariableDeclaration(builder, variable_declaration); } if (auto *class_declaration = dynamic_cast(node)) { - return VisitClassDeclaration(class_declaration); + return VisitClassDeclaration(builder, class_declaration); } LOG(FATAL) << "Unreachable code."; } -JshirBlockStatementOp AstToJsir::VisitBlockStatement(const JsBlockStatement *node) { - auto op = CreateStmt(node); +JshirBlockStatementOp AstToJsir::VisitBlockStatement(mlir::OpBuilder &builder, const JsBlockStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { for (const auto &element : *node->body()) { - VisitStatement(element.get()); + VisitStatement(builder, element.get()); } }); mlir::Region &mlir_directives_region = op.getDirectives(); - AppendNewBlockAndPopulate(mlir_directives_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_directives_region, [&] { for (const auto &element : *node->directives()) { - VisitDirective(element.get()); + VisitDirective(builder, element.get()); } }); return op; } -JsirExpressionStatementOp AstToJsir::VisitExpressionStatement(const JsExpressionStatement *node) { - mlir::Value mlir_expression = VisitExpression(node->expression()); - return CreateStmt(node, mlir_expression); +JsirExpressionStatementOp AstToJsir::VisitExpressionStatement(mlir::OpBuilder &builder, const JsExpressionStatement *node) { + mlir::Value mlir_expression = VisitExpression(builder, node->expression()); + return CreateStmt(builder, node, mlir_expression); } -JsirEmptyStatementOp AstToJsir::VisitEmptyStatement(const JsEmptyStatement *node) { - return CreateStmt(node); +JsirEmptyStatementOp AstToJsir::VisitEmptyStatement(mlir::OpBuilder &builder, const JsEmptyStatement *node) { + return CreateStmt(builder, node); } -JsirDebuggerStatementOp AstToJsir::VisitDebuggerStatement(const JsDebuggerStatement *node) { - return CreateStmt(node); +JsirDebuggerStatementOp AstToJsir::VisitDebuggerStatement(mlir::OpBuilder &builder, const JsDebuggerStatement *node) { + return CreateStmt(builder, node); } -JshirWithStatementOp AstToJsir::VisitWithStatement(const JsWithStatement *node) { - mlir::Value mlir_object = VisitExpression(node->object()); - auto op = CreateStmt(node, mlir_object); +JshirWithStatementOp AstToJsir::VisitWithStatement(mlir::OpBuilder &builder, const JsWithStatement *node) { + mlir::Value mlir_object = VisitExpression(builder, node->object()); + auto op = CreateStmt(builder, node, mlir_object); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitStatement(builder, node->body()); }); return op; } -JsirReturnStatementOp AstToJsir::VisitReturnStatement(const JsReturnStatement *node) { +JsirReturnStatementOp AstToJsir::VisitReturnStatement(mlir::OpBuilder &builder, const JsReturnStatement *node) { mlir::Value mlir_argument; if (node->argument().has_value()) { - mlir_argument = VisitExpression(node->argument().value()); + mlir_argument = VisitExpression(builder, node->argument().value()); } - return CreateStmt(node, mlir_argument); + return CreateStmt(builder, node, mlir_argument); } -JshirLabeledStatementOp AstToJsir::VisitLabeledStatement(const JsLabeledStatement *node) { - JsirIdentifierAttr mlir_label = VisitIdentifierAttr(node->label()); - auto op = CreateStmt(node, mlir_label); +JshirLabeledStatementOp AstToJsir::VisitLabeledStatement(mlir::OpBuilder &builder, const JsLabeledStatement *node) { + JsirIdentifierAttr mlir_label = VisitIdentifierAttr(builder, node->label()); + auto op = CreateStmt(builder, node, mlir_label); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitStatement(builder, node->body()); }); return op; } -JshirIfStatementOp AstToJsir::VisitIfStatement(const JsIfStatement *node) { - mlir::Value mlir_test = VisitExpression(node->test()); - auto op = CreateStmt(node, mlir_test); +JshirIfStatementOp AstToJsir::VisitIfStatement(mlir::OpBuilder &builder, const JsIfStatement *node) { + mlir::Value mlir_test = VisitExpression(builder, node->test()); + auto op = CreateStmt(builder, node, mlir_test); mlir::Region &mlir_consequent_region = op.getConsequent(); - AppendNewBlockAndPopulate(mlir_consequent_region, [&] { - VisitStatement(node->consequent()); + AppendNewBlockAndPopulate(builder, mlir_consequent_region, [&] { + VisitStatement(builder, node->consequent()); }); if (node->alternate().has_value()) { mlir::Region &mlir_alternate_region = op.getAlternate(); - AppendNewBlockAndPopulate(mlir_alternate_region, [&] { - VisitStatement(node->alternate().value()); + AppendNewBlockAndPopulate(builder, mlir_alternate_region, [&] { + VisitStatement(builder, node->alternate().value()); }); } return op; } -JshirSwitchCaseOp AstToJsir::VisitSwitchCase(const JsSwitchCase *node) { - auto op = CreateStmt(node); +JshirSwitchCaseOp 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(mlir_test_region, [&] { - mlir::Value mlir_test = VisitExpression(node->test().value()); - CreateStmt(node, mlir_test); + AppendNewBlockAndPopulate(builder, mlir_test_region, [&] { + mlir::Value mlir_test = VisitExpression(builder, node->test().value()); + CreateStmt(builder, nullptr, mlir_test); }); } mlir::Region &mlir_consequent_region = op.getConsequent(); - AppendNewBlockAndPopulate(mlir_consequent_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_consequent_region, [&] { for (const auto &element : *node->consequent()) { - VisitStatement(element.get()); + VisitStatement(builder, element.get()); } }); return op; } -JshirSwitchStatementOp AstToJsir::VisitSwitchStatement(const JsSwitchStatement *node) { - mlir::Value mlir_discriminant = VisitExpression(node->discriminant()); - auto op = CreateStmt(node, mlir_discriminant); +JshirSwitchStatementOp AstToJsir::VisitSwitchStatement(mlir::OpBuilder &builder, const JsSwitchStatement *node) { + mlir::Value mlir_discriminant = VisitExpression(builder, node->discriminant()); + auto op = CreateStmt(builder, node, mlir_discriminant); mlir::Region &mlir_cases_region = op.getCases(); - AppendNewBlockAndPopulate(mlir_cases_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_cases_region, [&] { for (const auto &element : *node->cases()) { - VisitSwitchCase(element.get()); + VisitSwitchCase(builder, element.get()); } }); return op; } -JsirThrowStatementOp AstToJsir::VisitThrowStatement(const JsThrowStatement *node) { - mlir::Value mlir_argument = VisitExpression(node->argument()); - return CreateStmt(node, mlir_argument); +JsirThrowStatementOp AstToJsir::VisitThrowStatement(mlir::OpBuilder &builder, const JsThrowStatement *node) { + mlir::Value mlir_argument = VisitExpression(builder, node->argument()); + return CreateStmt(builder, node, mlir_argument); } -JshirCatchClauseOp AstToJsir::VisitCatchClause(const JsCatchClause *node) { +JshirCatchClauseOp AstToJsir::VisitCatchClause(mlir::OpBuilder &builder, const JsCatchClause *node) { mlir::Value mlir_param; if (node->param().has_value()) { - mlir_param = VisitPatternRef(node->param().value()); + mlir_param = VisitPatternRef(builder, node->param().value()); } - auto op = CreateStmt(node, mlir_param); + auto op = CreateStmt(builder, node, mlir_param); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitBlockStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); }); return op; } -JshirTryStatementOp AstToJsir::VisitTryStatement(const JsTryStatement *node) { - auto op = CreateStmt(node); +JshirTryStatementOp AstToJsir::VisitTryStatement(mlir::OpBuilder &builder, const JsTryStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_block_region = op.getBlock(); - AppendNewBlockAndPopulate(mlir_block_region, [&] { - VisitBlockStatement(node->block()); + AppendNewBlockAndPopulate(builder, mlir_block_region, [&] { + VisitBlockStatement(builder, node->block()); }); if (node->handler().has_value()) { mlir::Region &mlir_handler_region = op.getHandler(); - AppendNewBlockAndPopulate(mlir_handler_region, [&] { - VisitCatchClause(node->handler().value()); + AppendNewBlockAndPopulate(builder, mlir_handler_region, [&] { + VisitCatchClause(builder, node->handler().value()); }); } if (node->finalizer().has_value()) { mlir::Region &mlir_finalizer_region = op.getFinalizer(); - AppendNewBlockAndPopulate(mlir_finalizer_region, [&] { - VisitBlockStatement(node->finalizer().value()); + AppendNewBlockAndPopulate(builder, mlir_finalizer_region, [&] { + VisitBlockStatement(builder, node->finalizer().value()); }); } return op; } -JshirWhileStatementOp AstToJsir::VisitWhileStatement(const JsWhileStatement *node) { - auto op = CreateStmt(node); +JshirWhileStatementOp AstToJsir::VisitWhileStatement(mlir::OpBuilder &builder, const JsWhileStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_test_region = op.getTest(); - AppendNewBlockAndPopulate(mlir_test_region, [&] { - mlir::Value mlir_test = VisitExpression(node->test()); - CreateStmt(node, mlir_test); + AppendNewBlockAndPopulate(builder, mlir_test_region, [&] { + mlir::Value mlir_test = VisitExpression(builder, node->test()); + CreateStmt(builder, nullptr, mlir_test); }); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitStatement(builder, node->body()); }); return op; } -JshirDoWhileStatementOp AstToJsir::VisitDoWhileStatement(const JsDoWhileStatement *node) { - auto op = CreateStmt(node); +JshirDoWhileStatementOp AstToJsir::VisitDoWhileStatement(mlir::OpBuilder &builder, const JsDoWhileStatement *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitStatement(builder, node->body()); }); mlir::Region &mlir_test_region = op.getTest(); - AppendNewBlockAndPopulate(mlir_test_region, [&] { - mlir::Value mlir_test = VisitExpression(node->test()); - CreateStmt(node, mlir_test); + AppendNewBlockAndPopulate(builder, mlir_test_region, [&] { + mlir::Value mlir_test = VisitExpression(builder, node->test()); + CreateStmt(builder, nullptr, mlir_test); }); return op; } -JsirDeclarationOpInterface AstToJsir::VisitDeclaration(const JsDeclaration *node) { +JsirDeclarationOpInterface AstToJsir::VisitDeclaration(mlir::OpBuilder &builder, const JsDeclaration *node) { if (auto *function_declaration = dynamic_cast(node)) { - return VisitFunctionDeclaration(function_declaration); + return VisitFunctionDeclaration(builder, function_declaration); } if (auto *variable_declaration = dynamic_cast(node)) { - return VisitVariableDeclaration(variable_declaration); + return VisitVariableDeclaration(builder, variable_declaration); } if (auto *class_declaration = dynamic_cast(node)) { - return VisitClassDeclaration(class_declaration); + return VisitClassDeclaration(builder, class_declaration); } LOG(FATAL) << "Unreachable code."; } -JsirVariableDeclaratorOp AstToJsir::VisitVariableDeclarator(const JsVariableDeclarator *node) { - mlir::Value mlir_id = VisitLValRef(node->id()); +JsirVariableDeclaratorOp AstToJsir::VisitVariableDeclarator(mlir::OpBuilder &builder, const JsVariableDeclarator *node) { + mlir::Value mlir_id = VisitLValRef(builder, node->id()); mlir::Value mlir_init; if (node->init().has_value()) { - mlir_init = VisitExpression(node->init().value()); + mlir_init = VisitExpression(builder, node->init().value()); } - return CreateExpr(node, mlir_id, mlir_init); + return CreateExpr(builder, node, mlir_id, mlir_init); } -JsirVariableDeclarationOp AstToJsir::VisitVariableDeclaration(const JsVariableDeclaration *node) { - mlir::StringAttr mlir_kind = builder_.getStringAttr(node->kind()); - auto op = CreateStmt(node, mlir_kind); +JsirVariableDeclarationOp AstToJsir::VisitVariableDeclaration(mlir::OpBuilder &builder, const JsVariableDeclaration *node) { + mlir::StringAttr mlir_kind = builder.getStringAttr(node->kind()); + auto op = CreateStmt(builder, node, mlir_kind); mlir::Region &mlir_declarations_region = op.getDeclarations(); - AppendNewBlockAndPopulate(mlir_declarations_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_declarations_region, [&] { std::vector mlir_declarations; for (const auto &element : *node->declarations()) { - mlir::Value mlir_element = VisitVariableDeclarator(element.get()); + mlir::Value mlir_element = VisitVariableDeclarator(builder, element.get()); mlir_declarations.push_back(std::move(mlir_element)); } - CreateStmt(node, mlir_declarations); + CreateStmt(builder, nullptr, mlir_declarations); }); return op; } -JsirFunctionDeclarationOp AstToJsir::VisitFunctionDeclaration(const JsFunctionDeclaration *node) { +JsirFunctionDeclarationOp AstToJsir::VisitFunctionDeclaration(mlir::OpBuilder &builder, const JsFunctionDeclaration *node) { JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); - auto op = CreateStmt(node, mlir_id, mlir_generator, mlir_async); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); + auto op = CreateStmt(builder, node, mlir_id, mlir_generator, mlir_async); mlir::Region &mlir_params_region = op.getParams(); - AppendNewBlockAndPopulate(mlir_params_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_params_region, [&] { std::vector mlir_params; for (const auto &element : *node->params()) { - mlir::Value mlir_element = VisitPatternRef(element.get()); + mlir::Value mlir_element = VisitPatternRef(builder, element.get()); mlir_params.push_back(std::move(mlir_element)); } - CreateStmt(node, mlir_params); + CreateStmt(builder, nullptr, mlir_params); }); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitBlockStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); }); return op; } -JsirSuperOp AstToJsir::VisitSuper(const JsSuper *node) { - return CreateExpr(node); +JsirSuperOp AstToJsir::VisitSuper(mlir::OpBuilder &builder, const JsSuper *node) { + return CreateExpr(builder, node); } -JsirImportOp AstToJsir::VisitImport(const JsImport *node) { - return CreateExpr(node); +JsirImportOp AstToJsir::VisitImport(mlir::OpBuilder &builder, const JsImport *node) { + return CreateExpr(builder, node); } -JsirThisExpressionOp AstToJsir::VisitThisExpression(const JsThisExpression *node) { - return CreateExpr(node); +JsirThisExpressionOp AstToJsir::VisitThisExpression(mlir::OpBuilder &builder, const JsThisExpression *node) { + return CreateExpr(builder, node); } -JsirYieldExpressionOp AstToJsir::VisitYieldExpression(const JsYieldExpression *node) { +JsirYieldExpressionOp AstToJsir::VisitYieldExpression(mlir::OpBuilder &builder, const JsYieldExpression *node) { mlir::Value mlir_argument; if (node->argument().has_value()) { - mlir_argument = VisitExpression(node->argument().value()); + mlir_argument = VisitExpression(builder, node->argument().value()); } - mlir::BoolAttr mlir_delegate = builder_.getBoolAttr(node->delegate()); - return CreateExpr(node, mlir_argument, mlir_delegate); + mlir::BoolAttr mlir_delegate = builder.getBoolAttr(node->delegate()); + return CreateExpr(builder, node, mlir_argument, mlir_delegate); } -JsirAwaitExpressionOp AstToJsir::VisitAwaitExpression(const JsAwaitExpression *node) { +JsirAwaitExpressionOp AstToJsir::VisitAwaitExpression(mlir::OpBuilder &builder, const JsAwaitExpression *node) { mlir::Value mlir_argument; if (node->argument().has_value()) { - mlir_argument = VisitExpression(node->argument().value()); + mlir_argument = VisitExpression(builder, node->argument().value()); } - return CreateExpr(node, mlir_argument); + return CreateExpr(builder, node, mlir_argument); } -JsirSpreadElementOp AstToJsir::VisitSpreadElement(const JsSpreadElement *node) { - mlir::Value mlir_argument = VisitExpression(node->argument()); - return CreateExpr(node, mlir_argument); +JsirSpreadElementOp AstToJsir::VisitSpreadElement(mlir::OpBuilder &builder, const JsSpreadElement *node) { + mlir::Value mlir_argument = VisitExpression(builder, node->argument()); + return CreateExpr(builder, node, mlir_argument); } -JsirArrayExpressionOp AstToJsir::VisitArrayExpression(const JsArrayExpression *node) { +JsirArrayExpressionOp AstToJsir::VisitArrayExpression(mlir::OpBuilder &builder, const JsArrayExpression *node) { std::vector mlir_elements; for (const auto &element : *node->elements()) { mlir::Value mlir_element; if (element.has_value()) { switch (element.value().index()) { case 0: { - mlir_element = VisitExpression(std::get<0>(element.value()).get()); + mlir_element = VisitExpression(builder, std::get<0>(element.value()).get()); break; } case 1: { - mlir_element = VisitSpreadElement(std::get<1>(element.value()).get()); + mlir_element = VisitSpreadElement(builder, std::get<1>(element.value()).get()); break; } default: LOG(FATAL) << "Unreachable code."; } } else { - mlir_element = CreateExpr(node); + mlir_element = CreateExpr(builder, node); } mlir_elements.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_elements); + return CreateExpr(builder, node, mlir_elements); } -JsirFunctionExpressionOp AstToJsir::VisitFunctionExpression(const JsFunctionExpression *node) { +JsirFunctionExpressionOp AstToJsir::VisitFunctionExpression(mlir::OpBuilder &builder, const JsFunctionExpression *node) { JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); - auto op = CreateExpr(node, mlir_id, mlir_generator, mlir_async); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); + auto op = CreateExpr(builder, node, mlir_id, mlir_generator, mlir_async); mlir::Region &mlir_params_region = op.getParams(); - AppendNewBlockAndPopulate(mlir_params_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_params_region, [&] { std::vector mlir_params; for (const auto &element : *node->params()) { - mlir::Value mlir_element = VisitPatternRef(element.get()); + mlir::Value mlir_element = VisitPatternRef(builder, element.get()); mlir_params.push_back(std::move(mlir_element)); } - CreateStmt(node, mlir_params); + CreateStmt(builder, nullptr, mlir_params); }); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitBlockStatement(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); }); return op; } -JsirUnaryExpressionOp AstToJsir::VisitUnaryExpression(const JsUnaryExpression *node) { - mlir::StringAttr mlir_operator = builder_.getStringAttr(JsUnaryOperatorToString(node->operator_())); - mlir::BoolAttr mlir_prefix = builder_.getBoolAttr(node->prefix()); - mlir::Value mlir_argument = VisitExpression(node->argument()); - return CreateExpr(node, mlir_operator, mlir_prefix, mlir_argument); +JsirUnaryExpressionOp AstToJsir::VisitUnaryExpression(mlir::OpBuilder &builder, const JsUnaryExpression *node) { + mlir::StringAttr mlir_operator = builder.getStringAttr(JsUnaryOperatorToString(node->operator_())); + mlir::BoolAttr mlir_prefix = builder.getBoolAttr(node->prefix()); + mlir::Value mlir_argument = VisitExpression(builder, node->argument()); + return CreateExpr(builder, node, mlir_operator, mlir_prefix, mlir_argument); } -JsirUpdateExpressionOp AstToJsir::VisitUpdateExpression(const JsUpdateExpression *node) { - mlir::StringAttr mlir_operator = builder_.getStringAttr(JsUpdateOperatorToString(node->operator_())); - mlir::Value mlir_argument = VisitLValRef(node->argument()); - mlir::BoolAttr mlir_prefix = builder_.getBoolAttr(node->prefix()); - return CreateExpr(node, mlir_operator, mlir_argument, mlir_prefix); +JsirUpdateExpressionOp AstToJsir::VisitUpdateExpression(mlir::OpBuilder &builder, const JsUpdateExpression *node) { + mlir::StringAttr mlir_operator = builder.getStringAttr(JsUpdateOperatorToString(node->operator_())); + mlir::Value mlir_argument = VisitLValRef(builder, node->argument()); + mlir::BoolAttr mlir_prefix = builder.getBoolAttr(node->prefix()); + return CreateExpr(builder, node, mlir_operator, mlir_argument, mlir_prefix); } -JsirBinaryExpressionOp AstToJsir::VisitBinaryExpression(const JsBinaryExpression *node) { - mlir::StringAttr mlir_operator = builder_.getStringAttr(JsBinaryOperatorToString(node->operator_())); +JsirBinaryExpressionOp AstToJsir::VisitBinaryExpression(mlir::OpBuilder &builder, const JsBinaryExpression *node) { + mlir::StringAttr mlir_operator = builder.getStringAttr(JsBinaryOperatorToString(node->operator_())); mlir::Value mlir_left; switch (node->left().index()) { case 0: { - mlir_left = VisitExpression(std::get<0>(node->left())); + mlir_left = VisitExpression(builder, std::get<0>(node->left())); break; } case 1: { - mlir_left = VisitPrivateName(std::get<1>(node->left())); + mlir_left = VisitPrivateName(builder, std::get<1>(node->left())); break; } default: LOG(FATAL) << "Unreachable code."; } - mlir::Value mlir_right = VisitExpression(node->right()); - return CreateExpr(node, mlir_operator, mlir_left, mlir_right); + mlir::Value mlir_right = VisitExpression(builder, node->right()); + return CreateExpr(builder, node, mlir_operator, mlir_left, mlir_right); } -JsirAssignmentExpressionOp AstToJsir::VisitAssignmentExpression(const JsAssignmentExpression *node) { - mlir::StringAttr mlir_operator = builder_.getStringAttr(JsAssignmentOperatorToString(node->operator_())); - mlir::Value mlir_left = VisitLValRef(node->left()); - mlir::Value mlir_right = VisitExpression(node->right()); - return CreateExpr(node, mlir_operator, mlir_left, mlir_right); +JsirAssignmentExpressionOp AstToJsir::VisitAssignmentExpression(mlir::OpBuilder &builder, const JsAssignmentExpression *node) { + mlir::StringAttr mlir_operator = builder.getStringAttr(JsAssignmentOperatorToString(node->operator_())); + mlir::Value mlir_left = VisitLValRef(builder, node->left()); + mlir::Value mlir_right = VisitExpression(builder, node->right()); + return CreateExpr(builder, node, mlir_operator, mlir_left, mlir_right); } -JshirLogicalExpressionOp AstToJsir::VisitLogicalExpression(const JsLogicalExpression *node) { - mlir::StringAttr mlir_operator = builder_.getStringAttr(JsLogicalOperatorToString(node->operator_())); - mlir::Value mlir_left = VisitExpression(node->left()); - auto op = CreateExpr(node, mlir_operator, mlir_left); +JshirLogicalExpressionOp 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); mlir::Region &mlir_right_region = op.getRight(); - AppendNewBlockAndPopulate(mlir_right_region, [&] { - mlir::Value mlir_right = VisitExpression(node->right()); - CreateStmt(node, mlir_right); + AppendNewBlockAndPopulate(builder, mlir_right_region, [&] { + mlir::Value mlir_right = VisitExpression(builder, node->right()); + CreateStmt(builder, nullptr, mlir_right); }); return op; } -JshirConditionalExpressionOp AstToJsir::VisitConditionalExpression(const JsConditionalExpression *node) { - mlir::Value mlir_test = VisitExpression(node->test()); - auto op = CreateExpr(node, mlir_test); +JshirConditionalExpressionOp AstToJsir::VisitConditionalExpression(mlir::OpBuilder &builder, const JsConditionalExpression *node) { + mlir::Value mlir_test = VisitExpression(builder, node->test()); + auto op = CreateExpr(builder, node, mlir_test); mlir::Region &mlir_alternate_region = op.getAlternate(); - AppendNewBlockAndPopulate(mlir_alternate_region, [&] { - mlir::Value mlir_alternate = VisitExpression(node->alternate()); - CreateStmt(node, mlir_alternate); + AppendNewBlockAndPopulate(builder, mlir_alternate_region, [&] { + mlir::Value mlir_alternate = VisitExpression(builder, node->alternate()); + CreateStmt(builder, nullptr, mlir_alternate); }); mlir::Region &mlir_consequent_region = op.getConsequent(); - AppendNewBlockAndPopulate(mlir_consequent_region, [&] { - mlir::Value mlir_consequent = VisitExpression(node->consequent()); - CreateStmt(node, mlir_consequent); + AppendNewBlockAndPopulate(builder, mlir_consequent_region, [&] { + mlir::Value mlir_consequent = VisitExpression(builder, node->consequent()); + CreateStmt(builder, nullptr, mlir_consequent); }); return op; } -JsirCallExpressionOp AstToJsir::VisitCallExpression(const JsCallExpression *node) { +JsirCallExpressionOp AstToJsir::VisitCallExpression(mlir::OpBuilder &builder, const JsCallExpression *node) { mlir::Value mlir_callee; switch (node->callee().index()) { case 0: { - mlir_callee = VisitExpression(std::get<0>(node->callee())); + mlir_callee = VisitExpression(builder, std::get<0>(node->callee())); break; } case 1: { - mlir_callee = VisitSuper(std::get<1>(node->callee())); + mlir_callee = VisitSuper(builder, std::get<1>(node->callee())); break; } case 2: { - mlir_callee = VisitImport(std::get<2>(node->callee())); + mlir_callee = VisitImport(builder, std::get<2>(node->callee())); break; } default: @@ -881,11 +881,11 @@ JsirCallExpressionOp AstToJsir::VisitCallExpression(const JsCallExpression *node mlir::Value mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitExpression(std::get<0>(element).get()); + mlir_element = VisitExpression(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitSpreadElement(std::get<1>(element).get()); + mlir_element = VisitSpreadElement(builder, std::get<1>(element).get()); break; } default: @@ -893,21 +893,21 @@ JsirCallExpressionOp AstToJsir::VisitCallExpression(const JsCallExpression *node } mlir_arguments.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_callee, mlir_arguments); + return CreateExpr(builder, node, mlir_callee, mlir_arguments); } -JsirOptionalCallExpressionOp AstToJsir::VisitOptionalCallExpression(const JsOptionalCallExpression *node) { - mlir::Value mlir_callee = VisitExpression(node->callee()); +JsirOptionalCallExpressionOp AstToJsir::VisitOptionalCallExpression(mlir::OpBuilder &builder, const JsOptionalCallExpression *node) { + mlir::Value mlir_callee = VisitExpression(builder, node->callee()); std::vector mlir_arguments; for (const auto &element : *node->arguments()) { mlir::Value mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitExpression(std::get<0>(element).get()); + mlir_element = VisitExpression(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitSpreadElement(std::get<1>(element).get()); + mlir_element = VisitSpreadElement(builder, std::get<1>(element).get()); break; } default: @@ -915,23 +915,23 @@ JsirOptionalCallExpressionOp AstToJsir::VisitOptionalCallExpression(const JsOpti } mlir_arguments.push_back(std::move(mlir_element)); } - mlir::BoolAttr mlir_optional = builder_.getBoolAttr(node->optional()); - return CreateExpr(node, mlir_callee, mlir_arguments, mlir_optional); + mlir::BoolAttr mlir_optional = builder.getBoolAttr(node->optional()); + return CreateExpr(builder, node, mlir_callee, mlir_arguments, mlir_optional); } -JsirNewExpressionOp AstToJsir::VisitNewExpression(const JsNewExpression *node) { +JsirNewExpressionOp AstToJsir::VisitNewExpression(mlir::OpBuilder &builder, const JsNewExpression *node) { mlir::Value mlir_callee; switch (node->callee().index()) { case 0: { - mlir_callee = VisitExpression(std::get<0>(node->callee())); + mlir_callee = VisitExpression(builder, std::get<0>(node->callee())); break; } case 1: { - mlir_callee = VisitSuper(std::get<1>(node->callee())); + mlir_callee = VisitSuper(builder, std::get<1>(node->callee())); break; } case 2: { - mlir_callee = VisitImport(std::get<2>(node->callee())); + mlir_callee = VisitImport(builder, std::get<2>(node->callee())); break; } default: @@ -942,11 +942,11 @@ JsirNewExpressionOp AstToJsir::VisitNewExpression(const JsNewExpression *node) { mlir::Value mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitExpression(std::get<0>(element).get()); + mlir_element = VisitExpression(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitSpreadElement(std::get<1>(element).get()); + mlir_element = VisitSpreadElement(builder, std::get<1>(element).get()); break; } default: @@ -954,72 +954,72 @@ JsirNewExpressionOp AstToJsir::VisitNewExpression(const JsNewExpression *node) { } mlir_arguments.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_callee, mlir_arguments); + return CreateExpr(builder, node, mlir_callee, mlir_arguments); } -JsirSequenceExpressionOp AstToJsir::VisitSequenceExpression(const JsSequenceExpression *node) { +JsirSequenceExpressionOp AstToJsir::VisitSequenceExpression(mlir::OpBuilder &builder, const JsSequenceExpression *node) { std::vector mlir_expressions; for (const auto &element : *node->expressions()) { - mlir::Value mlir_element = VisitExpression(element.get()); + mlir::Value mlir_element = VisitExpression(builder, element.get()); mlir_expressions.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_expressions); + return CreateExpr(builder, node, mlir_expressions); } -JsirTemplateElementValueOp AstToJsir::VisitTemplateElementValue(const JsTemplateElementValue *node) { +JsirTemplateElementValueOp AstToJsir::VisitTemplateElementValue(mlir::OpBuilder &builder, const JsTemplateElementValue *node) { mlir::StringAttr mlir_cooked; if (node->cooked().has_value()) { - mlir_cooked = builder_.getStringAttr(node->cooked().value()); + mlir_cooked = builder.getStringAttr(node->cooked().value()); } - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - return CreateExpr(node, mlir_cooked, mlir_raw); + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + return CreateExpr(builder, node, mlir_cooked, mlir_raw); } -JsirTemplateElementOp AstToJsir::VisitTemplateElement(const JsTemplateElement *node) { - mlir::BoolAttr mlir_tail = builder_.getBoolAttr(node->tail()); - mlir::Value mlir_value = VisitTemplateElementValue(node->value()); - return CreateExpr(node, mlir_tail, mlir_value); +JsirTemplateElementOp AstToJsir::VisitTemplateElement(mlir::OpBuilder &builder, const JsTemplateElement *node) { + mlir::BoolAttr mlir_tail = builder.getBoolAttr(node->tail()); + mlir::Value mlir_value = VisitTemplateElementValue(builder, node->value()); + return CreateExpr(builder, node, mlir_tail, mlir_value); } -JsirTemplateLiteralOp AstToJsir::VisitTemplateLiteral(const JsTemplateLiteral *node) { +JsirTemplateLiteralOp AstToJsir::VisitTemplateLiteral(mlir::OpBuilder &builder, const JsTemplateLiteral *node) { std::vector mlir_quasis; for (const auto &element : *node->quasis()) { - mlir::Value mlir_element = VisitTemplateElement(element.get()); + mlir::Value mlir_element = VisitTemplateElement(builder, element.get()); mlir_quasis.push_back(std::move(mlir_element)); } std::vector mlir_expressions; for (const auto &element : *node->expressions()) { - mlir::Value mlir_element = VisitExpression(element.get()); + mlir::Value mlir_element = VisitExpression(builder, element.get()); mlir_expressions.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_quasis, mlir_expressions); + return CreateExpr(builder, node, mlir_quasis, mlir_expressions); } -JsirTaggedTemplateExpressionOp AstToJsir::VisitTaggedTemplateExpression(const JsTaggedTemplateExpression *node) { - mlir::Value mlir_tag = VisitExpression(node->tag()); - mlir::Value mlir_quasi = VisitTemplateLiteral(node->quasi()); - return CreateExpr(node, mlir_tag, mlir_quasi); +JsirTaggedTemplateExpressionOp AstToJsir::VisitTaggedTemplateExpression(mlir::OpBuilder &builder, const JsTaggedTemplateExpression *node) { + mlir::Value mlir_tag = VisitExpression(builder, node->tag()); + mlir::Value mlir_quasi = VisitTemplateLiteral(builder, node->quasi()); + return CreateExpr(builder, node, mlir_tag, mlir_quasi); } -JsirRestElementRefOp AstToJsir::VisitRestElementRef(const JsRestElement *node) { - mlir::Value mlir_argument = VisitLValRef(node->argument()); - return CreateExpr(node, mlir_argument); +JsirRestElementRefOp AstToJsir::VisitRestElementRef(mlir::OpBuilder &builder, const JsRestElement *node) { + mlir::Value mlir_argument = VisitLValRef(builder, node->argument()); + return CreateExpr(builder, node, mlir_argument); } -JsirObjectPatternRefOp AstToJsir::VisitObjectPatternRef(const JsObjectPattern *node) { - auto op = CreateExpr(node); +JsirObjectPatternRefOp AstToJsir::VisitObjectPatternRef(mlir::OpBuilder &builder, const JsObjectPattern *node) { + auto op = CreateExpr(builder, node); mlir::Region &mlir_properties_region = op.getProperties_(); - AppendNewBlockAndPopulate(mlir_properties_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_properties_region, [&] { std::vector mlir_properties; for (const auto &element : *node->properties_()) { mlir::Value mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitObjectPropertyRef(std::get<0>(element).get()); + mlir_element = VisitObjectPropertyRef(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitRestElementRef(std::get<1>(element).get()); + mlir_element = VisitRestElementRef(builder, std::get<1>(element).get()); break; } default: @@ -1027,65 +1027,65 @@ JsirObjectPatternRefOp AstToJsir::VisitObjectPatternRef(const JsObjectPattern *n } mlir_properties.push_back(std::move(mlir_element)); } - CreateStmt(node, mlir_properties); + CreateStmt(builder, nullptr, mlir_properties); }); return op; } -JsirArrayPatternRefOp AstToJsir::VisitArrayPatternRef(const JsArrayPattern *node) { +JsirArrayPatternRefOp AstToJsir::VisitArrayPatternRef(mlir::OpBuilder &builder, const JsArrayPattern *node) { std::vector mlir_elements; for (const auto &element : *node->elements()) { mlir::Value mlir_element; if (element.has_value()) { - mlir_element = VisitPatternRef(element.value().get()); + mlir_element = VisitPatternRef(builder, element.value().get()); } else { - mlir_element = CreateExpr(node); + mlir_element = CreateExpr(builder, node); } mlir_elements.push_back(std::move(mlir_element)); } - return CreateExpr(node, mlir_elements); + return CreateExpr(builder, node, mlir_elements); } -JsirAssignmentPatternRefOp AstToJsir::VisitAssignmentPatternRef(const JsAssignmentPattern *node) { - mlir::Value mlir_left = VisitPatternRef(node->left()); - mlir::Value mlir_right = VisitExpression(node->right()); - return CreateExpr(node, mlir_left, mlir_right); +JsirAssignmentPatternRefOp AstToJsir::VisitAssignmentPatternRef(mlir::OpBuilder &builder, const JsAssignmentPattern *node) { + mlir::Value mlir_left = VisitPatternRef(builder, node->left()); + mlir::Value mlir_right = VisitExpression(builder, node->right()); + return CreateExpr(builder, node, mlir_left, mlir_right); } -JsirClassPrivatePropertyOp AstToJsir::VisitClassPrivateProperty(const JsClassPrivateProperty *node) { - JsirPrivateNameAttr mlir_key = VisitPrivateNameAttr(node->key()); - mlir::BoolAttr mlir_static = builder_.getBoolAttr(node->static_()); - auto op = CreateStmt(node, mlir_key, mlir_static); +JsirClassPrivatePropertyOp AstToJsir::VisitClassPrivateProperty(mlir::OpBuilder &builder, const JsClassPrivateProperty *node) { + JsirPrivateNameAttr mlir_key = VisitPrivateNameAttr(builder, node->key()); + mlir::BoolAttr mlir_static = builder.getBoolAttr(node->static_()); + auto op = CreateStmt(builder, node, mlir_key, mlir_static); if (node->value().has_value()) { mlir::Region &mlir_value_region = op.getValue(); - AppendNewBlockAndPopulate(mlir_value_region, [&] { - mlir::Value mlir_value = VisitExpression(node->value().value()); - CreateStmt(node, mlir_value); + AppendNewBlockAndPopulate(builder, mlir_value_region, [&] { + mlir::Value mlir_value = VisitExpression(builder, node->value().value()); + CreateStmt(builder, nullptr, mlir_value); }); } return op; } -JsirClassBodyOp AstToJsir::VisitClassBody(const JsClassBody *node) { - auto op = CreateStmt(node); +JsirClassBodyOp AstToJsir::VisitClassBody(mlir::OpBuilder &builder, const JsClassBody *node) { + auto op = CreateStmt(builder, node); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { for (const auto &element : *node->body()) { switch (element.index()) { case 0: { - VisitClassMethod(std::get<0>(element).get()); + VisitClassMethod(builder, std::get<0>(element).get()); break; } case 1: { - VisitClassPrivateMethod(std::get<1>(element).get()); + VisitClassPrivateMethod(builder, std::get<1>(element).get()); break; } case 2: { - VisitClassProperty(std::get<2>(element).get()); + VisitClassProperty(builder, std::get<2>(element).get()); break; } case 3: { - VisitClassPrivateProperty(std::get<3>(element).get()); + VisitClassPrivateProperty(builder, std::get<3>(element).get()); break; } default: @@ -1096,93 +1096,93 @@ JsirClassBodyOp AstToJsir::VisitClassBody(const JsClassBody *node) { return op; } -JsirClassDeclarationOp AstToJsir::VisitClassDeclaration(const JsClassDeclaration *node) { +JsirClassDeclarationOp AstToJsir::VisitClassDeclaration(mlir::OpBuilder &builder, const JsClassDeclaration *node) { mlir::Value mlir_super_class; if (node->super_class().has_value()) { - mlir_super_class = VisitExpression(node->super_class().value()); + mlir_super_class = VisitExpression(builder, node->super_class().value()); } JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } - auto op = CreateStmt(node, mlir_super_class, mlir_id); + auto op = CreateStmt(builder, node, mlir_super_class, mlir_id); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitClassBody(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitClassBody(builder, node->body()); }); return op; } -JsirClassExpressionOp AstToJsir::VisitClassExpression(const JsClassExpression *node) { +JsirClassExpressionOp AstToJsir::VisitClassExpression(mlir::OpBuilder &builder, const JsClassExpression *node) { mlir::Value mlir_super_class; if (node->super_class().has_value()) { - mlir_super_class = VisitExpression(node->super_class().value()); + mlir_super_class = VisitExpression(builder, node->super_class().value()); } JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } - auto op = CreateExpr(node, mlir_super_class, mlir_id); + auto op = CreateExpr(builder, node, mlir_super_class, mlir_id); mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, [&] { - VisitClassBody(node->body()); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitClassBody(builder, node->body()); }); return op; } -JsirMetaPropertyOp AstToJsir::VisitMetaProperty(const JsMetaProperty *node) { - JsirIdentifierAttr mlir_meta = VisitIdentifierAttr(node->meta()); - JsirIdentifierAttr mlir_property = VisitIdentifierAttr(node->property()); - return CreateExpr(node, mlir_meta, mlir_property); +JsirMetaPropertyOp AstToJsir::VisitMetaProperty(mlir::OpBuilder &builder, const JsMetaProperty *node) { + JsirIdentifierAttr mlir_meta = VisitIdentifierAttr(builder, node->meta()); + JsirIdentifierAttr mlir_property = VisitIdentifierAttr(builder, node->property()); + return CreateExpr(builder, node, mlir_meta, mlir_property); } -JsirModuleDeclarationOpInterface AstToJsir::VisitModuleDeclaration(const JsModuleDeclaration *node) { +JsirModuleDeclarationOpInterface AstToJsir::VisitModuleDeclaration(mlir::OpBuilder &builder, const JsModuleDeclaration *node) { if (auto *import_declaration = dynamic_cast(node)) { - return VisitImportDeclaration(import_declaration); + return VisitImportDeclaration(builder, import_declaration); } if (auto *export_named_declaration = dynamic_cast(node)) { - return VisitExportNamedDeclaration(export_named_declaration); + return VisitExportNamedDeclaration(builder, export_named_declaration); } if (auto *export_default_declaration = dynamic_cast(node)) { - return VisitExportDefaultDeclaration(export_default_declaration); + return VisitExportDefaultDeclaration(builder, export_default_declaration); } if (auto *export_all_declaration = dynamic_cast(node)) { - return VisitExportAllDeclaration(export_all_declaration); + return VisitExportAllDeclaration(builder, export_all_declaration); } LOG(FATAL) << "Unreachable code."; } -JsirModuleSpecifierAttrInterface AstToJsir::VisitModuleSpecifierAttr(const JsModuleSpecifier *node) { +JsirModuleSpecifierAttrInterface AstToJsir::VisitModuleSpecifierAttr(mlir::OpBuilder &builder, const JsModuleSpecifier *node) { if (auto *import_specifier = dynamic_cast(node)) { - return VisitImportSpecifierAttr(import_specifier); + return VisitImportSpecifierAttr(builder, import_specifier); } if (auto *import_default_specifier = dynamic_cast(node)) { - return VisitImportDefaultSpecifierAttr(import_default_specifier); + return VisitImportDefaultSpecifierAttr(builder, import_default_specifier); } if (auto *import_namespace_specifier = dynamic_cast(node)) { - return VisitImportNamespaceSpecifierAttr(import_namespace_specifier); + return VisitImportNamespaceSpecifierAttr(builder, import_namespace_specifier); } if (auto *export_specifier = dynamic_cast(node)) { - return VisitExportSpecifierAttr(export_specifier); + return VisitExportSpecifierAttr(builder, export_specifier); } LOG(FATAL) << "Unreachable code."; } -JsirImportDeclarationOp AstToJsir::VisitImportDeclaration(const JsImportDeclaration *node) { +JsirImportDeclarationOp AstToJsir::VisitImportDeclaration(mlir::OpBuilder &builder, const JsImportDeclaration *node) { std::vector mlir_specifiers_data; for (const auto &element : *node->specifiers()) { mlir::Attribute mlir_element; switch (element.index()) { case 0: { - mlir_element = VisitImportSpecifierAttr(std::get<0>(element).get()); + mlir_element = VisitImportSpecifierAttr(builder, std::get<0>(element).get()); break; } case 1: { - mlir_element = VisitImportDefaultSpecifierAttr(std::get<1>(element).get()); + mlir_element = VisitImportDefaultSpecifierAttr(builder, std::get<1>(element).get()); break; } case 2: { - mlir_element = VisitImportNamespaceSpecifierAttr(std::get<2>(element).get()); + mlir_element = VisitImportNamespaceSpecifierAttr(builder, std::get<2>(element).get()); break; } default: @@ -1190,57 +1190,57 @@ JsirImportDeclarationOp AstToJsir::VisitImportDeclaration(const JsImportDeclarat } mlir_specifiers_data.push_back(std::move(mlir_element)); } - auto mlir_specifiers = builder_.getArrayAttr(mlir_specifiers_data); - JsirStringLiteralAttr mlir_source = VisitStringLiteralAttr(node->source()); + auto mlir_specifiers = builder.getArrayAttr(mlir_specifiers_data); + JsirStringLiteralAttr mlir_source = VisitStringLiteralAttr(builder, node->source()); JsirImportAttributeAttr mlir_assertions; if (node->assertions().has_value()) { - mlir_assertions = VisitImportAttributeAttr(node->assertions().value()); + mlir_assertions = VisitImportAttributeAttr(builder, node->assertions().value()); } - return CreateStmt(node, mlir_specifiers, mlir_source, mlir_assertions); + return CreateStmt(builder, node, mlir_specifiers, mlir_source, mlir_assertions); } -JsirExportNamedDeclarationOp AstToJsir::VisitExportNamedDeclaration(const JsExportNamedDeclaration *node) { +JsirExportNamedDeclarationOp AstToJsir::VisitExportNamedDeclaration(mlir::OpBuilder &builder, const JsExportNamedDeclaration *node) { std::vector mlir_specifiers_data; for (const auto &element : *node->specifiers()) { - JsirExportSpecifierAttr mlir_element = VisitExportSpecifierAttr(element.get()); + JsirExportSpecifierAttr mlir_element = VisitExportSpecifierAttr(builder, element.get()); mlir_specifiers_data.push_back(std::move(mlir_element)); } - auto mlir_specifiers = builder_.getArrayAttr(mlir_specifiers_data); + auto mlir_specifiers = builder.getArrayAttr(mlir_specifiers_data); JsirStringLiteralAttr mlir_source; if (node->source().has_value()) { - mlir_source = VisitStringLiteralAttr(node->source().value()); + mlir_source = VisitStringLiteralAttr(builder, node->source().value()); } mlir::ArrayAttr mlir_assertions; if (node->assertions().has_value()) { std::vector mlir_assertions_data; for (const auto &element : *node->assertions().value()) { - JsirImportAttributeAttr mlir_element = VisitImportAttributeAttr(element.get()); + JsirImportAttributeAttr mlir_element = VisitImportAttributeAttr(builder, element.get()); mlir_assertions_data.push_back(std::move(mlir_element)); } - mlir_assertions = builder_.getArrayAttr(mlir_assertions_data); + mlir_assertions = builder.getArrayAttr(mlir_assertions_data); } - auto op = CreateStmt(node, mlir_specifiers, mlir_source, mlir_assertions); + auto op = CreateStmt(builder, node, mlir_specifiers, mlir_source, mlir_assertions); if (node->declaration().has_value()) { mlir::Region &mlir_declaration_region = op.getDeclaration(); - AppendNewBlockAndPopulate(mlir_declaration_region, [&] { - VisitDeclaration(node->declaration().value()); + AppendNewBlockAndPopulate(builder, mlir_declaration_region, [&] { + VisitDeclaration(builder, node->declaration().value()); }); } return op; } -JsirExportAllDeclarationOp AstToJsir::VisitExportAllDeclaration(const JsExportAllDeclaration *node) { - JsirStringLiteralAttr mlir_source = VisitStringLiteralAttr(node->source()); +JsirExportAllDeclarationOp AstToJsir::VisitExportAllDeclaration(mlir::OpBuilder &builder, const JsExportAllDeclaration *node) { + JsirStringLiteralAttr mlir_source = VisitStringLiteralAttr(builder, node->source()); mlir::ArrayAttr mlir_assertions; if (node->assertions().has_value()) { std::vector mlir_assertions_data; for (const auto &element : *node->assertions().value()) { - JsirImportAttributeAttr mlir_element = VisitImportAttributeAttr(element.get()); + JsirImportAttributeAttr mlir_element = VisitImportAttributeAttr(builder, element.get()); mlir_assertions_data.push_back(std::move(mlir_element)); } - mlir_assertions = builder_.getArrayAttr(mlir_assertions_data); + mlir_assertions = builder.getArrayAttr(mlir_assertions_data); } - return CreateStmt(node, mlir_source, mlir_assertions); + return CreateStmt(builder, node, mlir_source, mlir_assertions); } // clang-format on diff --git a/maldoca/js/ir/conversion/ast_to_jsir.h b/maldoca/js/ir/conversion/ast_to_jsir.h index 24bbcaf..d2e34a6 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.h +++ b/maldoca/js/ir/conversion/ast_to_jsir.h @@ -15,12 +15,8 @@ #ifndef MALDOCA_JS_IR_CONVERSION_AST_TO_JSIR_H_ #define MALDOCA_JS_IR_CONVERSION_AST_TO_JSIR_H_ -#include #include -#include -#include #include -#include #include "mlir/IR/Attributes.h" #include "mlir/IR/Builders.h" @@ -37,31 +33,36 @@ namespace maldoca { class AstToJsir { public: - explicit AstToJsir(mlir::OpBuilder &builder) : builder_(builder) {} - // Example: // -// JsirFileOp VisitFile(const JsFile *node); -#define DECLARE_CIR_OP_VISIT_FUNCTION(TYPE) \ - Jsir##TYPE##Op Visit##TYPE(const Js##TYPE *node); +// static JsirFileOp VisitFile(mlir::OpBuilder &builder, const JsFile *node); +#define DECLARE_CIR_OP_VISIT_FUNCTION(TYPE) \ + static Jsir##TYPE##Op Visit##TYPE(mlir::OpBuilder& builder, \ + const Js##TYPE* node); // Example: // -// JshirBlockStatementOp VisitBlockStatement(const JsBlockStatement *node); -#define DECLARE_HIR_OP_VISIT_FUNCTION(TYPE) \ - Jshir##TYPE##Op Visit##TYPE(const Js##TYPE *node); +// 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: // -// JsirIdentifierRefOp VisitIdentifierRef(const JsIdentifier *node); -#define DECLARE_REF_OP_VISIT_FUNCTION(TYPE) \ - Jsir##TYPE##RefOp Visit##TYPE##Ref(const Js##TYPE *node); +// static JsirIdentifierRefOp VisitIdentifierRef(mlir::OpBuilder &builder, const +// JsIdentifier *node); +#define DECLARE_REF_OP_VISIT_FUNCTION(TYPE) \ + static Jsir##TYPE##RefOp Visit##TYPE##Ref(mlir::OpBuilder& builder, \ + const Js##TYPE* node); // Example: // -// JsirIdentifierAttr VisitIdentifierAttr(const JsIdentifier *node); -#define DECLARE_ATTRIB_VISIT_FUNCTION(TYPE) \ - Jsir##TYPE##Attr Visit##TYPE##Attr(const Js##TYPE *node); +// static JsirIdentifierAttr VisitIdentifierAttr(mlir::OpBuilder &builder, const +// JsIdentifier *node); +#define DECLARE_ATTRIB_VISIT_FUNCTION(TYPE) \ + static Jsir##TYPE##Attr Visit##TYPE##Attr(mlir::OpBuilder& builder, \ + const Js##TYPE* node); FOR_EACH_JSIR_CLASS(DECLARE_CIR_OP_VISIT_FUNCTION, DECLARE_HIR_OP_VISIT_FUNCTION, @@ -73,57 +74,72 @@ class AstToJsir { #undef DECLARE_HIR_OP_VISIT_FUNCTION #undef DECLARE_ATTRIB_VISIT_FUNCTION - JsirProgramBodyElementOpInterface VisitProgramBodyElement( - const JsProgramBodyElement* node); + static JsirProgramBodyElementOpInterface VisitProgramBodyElement( + mlir::OpBuilder& builder, const JsProgramBodyElement* node); - JsirLiteralOpInterface VisitLiteral(const JsLiteral *node); + static JsirLiteralOpInterface VisitLiteral(mlir::OpBuilder& builder, + const JsLiteral* node); - JsirStatementOpInterface VisitStatement(const JsStatement *node); + static JsirStatementOpInterface VisitStatement(mlir::OpBuilder& builder, + const JsStatement* node); - JsirExpressionOpInterface VisitExpression(const JsExpression *node); + static JsirExpressionOpInterface VisitExpression(mlir::OpBuilder& builder, + const JsExpression* node); - JsirLValRefOpInterface VisitLValRef(const JsLVal *node); + static JsirLValRefOpInterface VisitLValRef(mlir::OpBuilder& builder, + const JsLVal* node); - JsirDeclarationOpInterface VisitDeclaration(const JsDeclaration *node); + static JsirDeclarationOpInterface VisitDeclaration(mlir::OpBuilder& builder, + const JsDeclaration* node); - JsirPatternRefOpInterface VisitPatternRef(const JsPattern *node); + static JsirPatternRefOpInterface VisitPatternRef(mlir::OpBuilder& builder, + const JsPattern* node); - JsirModuleSpecifierAttrInterface VisitModuleSpecifierAttr( - const JsModuleSpecifier *node); + static JsirModuleSpecifierAttrInterface VisitModuleSpecifierAttr( + mlir::OpBuilder& builder, const JsModuleSpecifier* node); - JsirModuleDeclarationOpInterface VisitModuleDeclaration( - const JsModuleDeclaration *node); + static JsirModuleDeclarationOpInterface VisitModuleDeclaration( + mlir::OpBuilder& builder, const JsModuleDeclaration* node); private: - JsirCommentAttrInterface VisitCommentAttr(const JsComment *node); + static JsirCommentAttrInterface VisitCommentAttr(mlir::OpBuilder& builder, + const JsComment* node); template - T CreateExpr(const JsNode *node, Args &&...args) { - CHECK(node != nullptr) << "Node cannot be null."; - mlir::MLIRContext *context = builder_.getContext(); - return builder_.create(GetJsirTriviaAttr(context, *node), - std::forward(args)...); + static T CreateExpr(mlir::OpBuilder& builder, const JsNode* node, + Args&&... args) { + mlir::MLIRContext* context = builder.getContext(); + mlir::Location trivia_attr = + (node != nullptr) ? GetJsirTriviaAttr(context, *node) + : builder.getUnknownLoc(); + return T::create(builder, trivia_attr, + std::forward(args)...); } // Overloads `CreateExpr` when the input does not implement `JsNode`. template - T CreateExpr(const JsTemplateElementValue *node, Args &&...args) { + static T CreateExpr(mlir::OpBuilder& builder, + const JsTemplateElementValue* node, Args&&... args) { CHECK(node != nullptr) << "Node cannot be null."; - return builder_.create(builder_.getUnknownLoc(), - std::forward(args)...); + return T::create(builder, builder.getUnknownLoc(), + std::forward(args)...); } template - T CreateStmt(const JsNode *node, Args &&...args) { - CHECK(node != nullptr) << "Node cannot be null."; - mlir::MLIRContext *context = builder_.getContext(); - return builder_.create(GetJsirTriviaAttr(context, *node), - mlir::TypeRange(), std::forward(args)...); + static T CreateStmt(mlir::OpBuilder& builder, const JsNode* node, + Args&&... args) { + mlir::MLIRContext* context = builder.getContext(); + mlir::Location trivia_attr = + (node != nullptr) ? GetJsirTriviaAttr(context, *node) + : builder.getUnknownLoc(); + return T::create(builder, trivia_attr, + mlir::TypeRange(), std::forward(args)...); } - void AppendNewBlockAndPopulate(mlir::Region ®ion, - std::function populate); + static void AppendNewBlockAndPopulate(mlir::OpBuilder& builder, + mlir::Region& region, + std::function populate); // The key of an object property. // @@ -156,22 +172,23 @@ class AstToJsir { // If computed == true: // ObjectPropertyKey::literal is null. // ObjectPropertyKey::computed is non-null. - ObjectPropertyKey GetObjectPropertyKey(const JsExpression *node, - bool computed); + static ObjectPropertyKey GetObjectPropertyKey(mlir::OpBuilder& builder, + const JsExpression* node, + bool computed); - mlir::Value VisitMemberExpressionObject( - std::variant object); + static mlir::Value VisitMemberExpressionObject( + mlir::OpBuilder& builder, + std::variant object); struct MemberExpressionProperty { mlir::Attribute literal; mlir::Value computed; }; - MemberExpressionProperty VisitMemberExpressionProperty( - std::variant property, + static MemberExpressionProperty VisitMemberExpressionProperty( + mlir::OpBuilder& builder, + std::variant property, bool computed); - - mlir::OpBuilder &builder_; }; } // namespace maldoca diff --git a/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc b/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc index eea2b6b..1f801e7 100644 --- a/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc +++ b/maldoca/js/ir/conversion/ast_to_jsir.handwritten.cc @@ -33,18 +33,17 @@ #include "absl/log/log.h" #include "absl/status/status.h" #include "absl/strings/str_cat.h" -#include "absl/types/optional.h" -#include "absl/types/variant.h" #include "maldoca/js/ast/ast.generated.h" #include "maldoca/js/ir/ir.h" #include "maldoca/js/ir/trivia.h" namespace maldoca { -JsirCommentAttrInterface AstToJsir::VisitCommentAttr(const JsComment *node) { +JsirCommentAttrInterface AstToJsir::VisitCommentAttr(mlir::OpBuilder& builder, + const JsComment* node) { JsirLocationAttr loc = nullptr; if (node->loc().has_value()) { - loc = GetJsirLocationAttr(builder_.getContext(), node->loc().value(), + loc = GetJsirLocationAttr(builder.getContext(), node->loc().value(), node->start(), node->end(), /*scope_uid=*/std::nullopt); } @@ -52,174 +51,178 @@ JsirCommentAttrInterface AstToJsir::VisitCommentAttr(const JsComment *node) { switch (node->comment_type()) { case JsCommentType::kCommentLine: return JsirCommentLineAttr::get( - builder_.getContext(), loc, - mlir::StringAttr::get(builder_.getContext(), node->value())); + builder.getContext(), loc, + mlir::StringAttr::get(builder.getContext(), node->value())); case JsCommentType::kCommentBlock: return JsirCommentBlockAttr::get( - builder_.getContext(), loc, - mlir::StringAttr::get(builder_.getContext(), node->value())); + builder.getContext(), loc, + mlir::StringAttr::get(builder.getContext(), node->value())); } } JsirInterpreterDirectiveAttr AstToJsir::VisitInterpreterDirectiveAttr( - const JsInterpreterDirective *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); - return JsirInterpreterDirectiveAttr::get(builder_.getContext(), loc, + mlir::OpBuilder& builder, const JsInterpreterDirective* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); + return JsirInterpreterDirectiveAttr::get(builder.getContext(), loc, mlir_value); } JsirDirectiveLiteralExtraAttr AstToJsir::VisitDirectiveLiteralExtraAttr( - const JsDirectiveLiteralExtra *node) { - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - mlir::StringAttr mlir_raw_value = builder_.getStringAttr(node->raw_value()); - return JsirDirectiveLiteralExtraAttr::get(builder_.getContext(), mlir_raw, + mlir::OpBuilder& builder, const JsDirectiveLiteralExtra* node) { + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + mlir::StringAttr mlir_raw_value = builder.getStringAttr(node->raw_value()); + return JsirDirectiveLiteralExtraAttr::get(builder.getContext(), mlir_raw, mlir_raw_value); } -JsirIdentifierAttr AstToJsir::VisitIdentifierAttr(const JsIdentifier *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - mlir::StringAttr mlir_name = builder_.getStringAttr(node->name()); - return JsirIdentifierAttr::get(builder_.getContext(), loc, mlir_name); +JsirIdentifierAttr AstToJsir::VisitIdentifierAttr(mlir::OpBuilder& builder, + const JsIdentifier* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + mlir::StringAttr mlir_name = builder.getStringAttr(node->name()); + return JsirIdentifierAttr::get(builder.getContext(), loc, mlir_name); } -JsirPrivateNameAttr AstToJsir::VisitPrivateNameAttr(const JsPrivateName *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - JsirIdentifierAttr mlir_id = VisitIdentifierAttr(node->id()); - return JsirPrivateNameAttr::get(builder_.getContext(), loc, mlir_id); +JsirPrivateNameAttr AstToJsir::VisitPrivateNameAttr(mlir::OpBuilder& builder, + const JsPrivateName* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + JsirIdentifierAttr mlir_id = VisitIdentifierAttr(builder, node->id()); + return JsirPrivateNameAttr::get(builder.getContext(), loc, mlir_id); } JsirRegExpLiteralExtraAttr AstToJsir::VisitRegExpLiteralExtraAttr( - const JsRegExpLiteralExtra *node) { - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - return JsirRegExpLiteralExtraAttr::get(builder_.getContext(), mlir_raw); + mlir::OpBuilder& builder, const JsRegExpLiteralExtra* node) { + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + return JsirRegExpLiteralExtraAttr::get(builder.getContext(), mlir_raw); } JsirStringLiteralExtraAttr AstToJsir::VisitStringLiteralExtraAttr( - const JsStringLiteralExtra *node) { - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - mlir::StringAttr mlir_raw_value = builder_.getStringAttr(node->raw_value()); - return JsirStringLiteralExtraAttr::get(builder_.getContext(), mlir_raw, + mlir::OpBuilder& builder, const JsStringLiteralExtra* node) { + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + mlir::StringAttr mlir_raw_value = builder.getStringAttr(node->raw_value()); + return JsirStringLiteralExtraAttr::get(builder.getContext(), mlir_raw, mlir_raw_value); } JsirStringLiteralAttr AstToJsir::VisitStringLiteralAttr( - const JsStringLiteral *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); + mlir::OpBuilder& builder, const JsStringLiteral* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); JsirStringLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitStringLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitStringLiteralExtraAttr(builder, node->extra().value()); } - return JsirStringLiteralAttr::get(builder_.getContext(), loc, mlir_value, + return JsirStringLiteralAttr::get(builder.getContext(), loc, mlir_value, mlir_extra); } JsirNumericLiteralExtraAttr AstToJsir::VisitNumericLiteralExtraAttr( - const JsNumericLiteralExtra *node) { - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - mlir::FloatAttr mlir_raw_value = builder_.getF64FloatAttr(node->raw_value()); - return JsirNumericLiteralExtraAttr::get(builder_.getContext(), mlir_raw, + mlir::OpBuilder& builder, const JsNumericLiteralExtra* node) { + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + mlir::FloatAttr mlir_raw_value = builder.getF64FloatAttr(node->raw_value()); + return JsirNumericLiteralExtraAttr::get(builder.getContext(), mlir_raw, mlir_raw_value); } JsirNumericLiteralAttr AstToJsir::VisitNumericLiteralAttr( - const JsNumericLiteral *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - mlir::FloatAttr mlir_value = builder_.getF64FloatAttr(node->value()); + mlir::OpBuilder& builder, const JsNumericLiteral* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + mlir::FloatAttr mlir_value = builder.getF64FloatAttr(node->value()); JsirNumericLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitNumericLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitNumericLiteralExtraAttr(builder, node->extra().value()); } - return JsirNumericLiteralAttr::get(builder_.getContext(), loc, mlir_value, + return JsirNumericLiteralAttr::get(builder.getContext(), loc, mlir_value, mlir_extra); } JsirBigIntLiteralExtraAttr AstToJsir::VisitBigIntLiteralExtraAttr( - const JsBigIntLiteralExtra *node) { - mlir::StringAttr mlir_raw = builder_.getStringAttr(node->raw()); - mlir::StringAttr mlir_raw_value = builder_.getStringAttr(node->raw_value()); - return JsirBigIntLiteralExtraAttr::get(builder_.getContext(), mlir_raw, + mlir::OpBuilder& builder, const JsBigIntLiteralExtra* node) { + mlir::StringAttr mlir_raw = builder.getStringAttr(node->raw()); + mlir::StringAttr mlir_raw_value = builder.getStringAttr(node->raw_value()); + return JsirBigIntLiteralExtraAttr::get(builder.getContext(), mlir_raw, mlir_raw_value); } JsirBigIntLiteralAttr AstToJsir::VisitBigIntLiteralAttr( - const JsBigIntLiteral *node) { - mlir::StringAttr mlir_value = builder_.getStringAttr(node->value()); + mlir::OpBuilder& builder, const JsBigIntLiteral* node) { + mlir::StringAttr mlir_value = builder.getStringAttr(node->value()); JsirBigIntLiteralExtraAttr mlir_extra; if (node->extra().has_value()) { - mlir_extra = VisitBigIntLiteralExtraAttr(node->extra().value()); + mlir_extra = VisitBigIntLiteralExtraAttr(builder, node->extra().value()); } - return JsirBigIntLiteralAttr::get(builder_.getContext(), mlir_value, + return JsirBigIntLiteralAttr::get(builder.getContext(), mlir_value, mlir_extra); } JshirBreakStatementOp AstToJsir::VisitBreakStatement( - const JsBreakStatement *node) { + mlir::OpBuilder& builder, const JsBreakStatement* node) { JsirIdentifierAttr mlir_label; if (node->label().has_value()) { - mlir_label = VisitIdentifierAttr(node->label().value()); + mlir_label = VisitIdentifierAttr(builder, node->label().value()); } - return CreateStmt(node, mlir_label); + return CreateStmt(builder, node, mlir_label); } JshirContinueStatementOp AstToJsir::VisitContinueStatement( - const JsContinueStatement *node) { + mlir::OpBuilder& builder, const JsContinueStatement* node) { JsirIdentifierAttr mlir_label; if (node->label().has_value()) { - mlir_label = VisitIdentifierAttr(node->label().value()); + mlir_label = VisitIdentifierAttr(builder, node->label().value()); } - return CreateStmt(node, mlir_label); + return CreateStmt(builder, node, mlir_label); } -JshirForStatementOp AstToJsir::VisitForStatement(const JsForStatement *node) { - auto op = CreateStmt(node); - mlir::Region &init_region = op.getInit(); +JshirForStatementOp 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(init_region, [&] { + AppendNewBlockAndPopulate(builder, init_region, [&] { auto init = node->init().value(); - if (std::holds_alternative(init)) { - auto *init_variable_declaration = - std::get(init); - VisitVariableDeclaration(init_variable_declaration); - } else if (std::holds_alternative(init)) { - auto *init_expression = std::get(init); - mlir::Value mlir_init = VisitExpression(init_expression); - CreateStmt(init_expression, mlir_init); + if (std::holds_alternative(init)) { + auto* init_variable_declaration = + std::get(init); + VisitVariableDeclaration(builder, init_variable_declaration); + } else if (std::holds_alternative(init)) { + auto* init_expression = std::get(init); + mlir::Value mlir_init = VisitExpression(builder, init_expression); + CreateStmt(builder, nullptr, mlir_init); } }); } - mlir::Region &test_region = op.getTest(); + mlir::Region& test_region = op.getTest(); if (node->test().has_value()) { - const JsExpression *test = node->test().value(); - AppendNewBlockAndPopulate(test_region, [&] { - mlir::Value mlir_test = VisitExpression(test); - CreateStmt(test, mlir_test); + const JsExpression* test = node->test().value(); + AppendNewBlockAndPopulate(builder, test_region, [&] { + mlir::Value mlir_test = VisitExpression(builder, test); + CreateStmt(builder, nullptr, mlir_test); }); } - mlir::Region &update_region = op.getUpdate(); + mlir::Region& update_region = op.getUpdate(); if (node->update().has_value()) { - const JsExpression *update = node->update().value(); - AppendNewBlockAndPopulate(update_region, [&] { - mlir::Value mlir_update = VisitExpression(update); - CreateStmt(update, mlir_update); + const JsExpression* update = node->update().value(); + AppendNewBlockAndPopulate(builder, update_region, [&] { + mlir::Value mlir_update = VisitExpression(builder, update); + CreateStmt(builder, nullptr, mlir_update); }); } - mlir::Region &body_region = op.getBody(); - AppendNewBlockAndPopulate(body_region, [&] { VisitStatement(node->body()); }); + mlir::Region& body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, body_region, + [&] { VisitStatement(builder, node->body()); }); return op; } struct ForInOfLeft { std::optional declaration_attr; - const JsLVal *lval; + const JsLVal* lval; }; static absl::StatusOr GetForInOfLeft( - mlir::MLIRContext *context, - std::variant left) { - if (std::holds_alternative(left)) { - auto *left_lval = std::get(left); + mlir::MLIRContext* context, + std::variant left) { + if (std::holds_alternative(left)) { + auto* left_lval = std::get(left); return ForInOfLeft{ .declaration_attr = std::nullopt, @@ -227,16 +230,16 @@ static absl::StatusOr GetForInOfLeft( }; } - CHECK(std::holds_alternative(left)) + CHECK(std::holds_alternative(left)) << "Exhausted std::variant case."; - auto *left_declaration = std::get(left); + auto* left_declaration = std::get(left); - auto *declarators = left_declaration->declarations(); + auto* declarators = left_declaration->declarations(); if (auto num_declarators = declarators->size(); num_declarators != 1) { return absl::InvalidArgumentError(absl::StrCat( "Expected exactly 1 declarator, got ", num_declarators, ".")); } - JsVariableDeclarator *declarator = declarators->front().get(); + JsVariableDeclarator* declarator = declarators->front().get(); return ForInOfLeft{ .declaration_attr = JsirForInOfDeclarationAttr::get( @@ -249,74 +252,77 @@ static absl::StatusOr GetForInOfLeft( } JshirForInStatementOp AstToJsir::VisitForInStatement( - const JsForInStatement *node) { - auto left = GetForInOfLeft(builder_.getContext(), node->left()); + mlir::OpBuilder& builder, const JsForInStatement* node) { + auto left = GetForInOfLeft(builder.getContext(), node->left()); if (!left.ok()) { - mlir::emitError(GetJsirTriviaAttr(builder_.getContext(), *node), + mlir::emitError(GetJsirTriviaAttr(builder.getContext(), *node), left.status().ToString()); return nullptr; } - mlir::Value mlir_left = VisitLValRef(left->lval); + mlir::Value mlir_left = VisitLValRef(builder, left->lval); - mlir::Value mlir_right = VisitExpression(node->right()); + mlir::Value mlir_right = VisitExpression(builder, node->right()); auto op = CreateStmt( - node, left->declaration_attr.value_or(nullptr), mlir_left, mlir_right); + builder, node, left->declaration_attr.value_or(nullptr), mlir_left, + mlir_right); - mlir::Region &body_region = op.getBody(); - AppendNewBlockAndPopulate(body_region, [&] { VisitStatement(node->body()); }); + mlir::Region& body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, body_region, + [&] { VisitStatement(builder, node->body()); }); return op; } JshirForOfStatementOp AstToJsir::VisitForOfStatement( - const JsForOfStatement *node) { - auto left = GetForInOfLeft(builder_.getContext(), node->left()); + mlir::OpBuilder& builder, const JsForOfStatement* node) { + auto left = GetForInOfLeft(builder.getContext(), node->left()); if (!left.ok()) { - mlir::emitError(GetJsirTriviaAttr(builder_.getContext(), *node), + mlir::emitError(GetJsirTriviaAttr(builder.getContext(), *node), left.status().ToString()); return nullptr; } - mlir::BoolAttr mlir_await = builder_.getBoolAttr(node->await()); + mlir::BoolAttr mlir_await = builder.getBoolAttr(node->await()); - mlir::Value mlir_left = VisitLValRef(left->lval); + mlir::Value mlir_left = VisitLValRef(builder, left->lval); - mlir::Value mlir_right = VisitExpression(node->right()); + mlir::Value mlir_right = VisitExpression(builder, node->right()); auto op = CreateStmt( - node, left->declaration_attr.value_or(nullptr), mlir_left, mlir_right, - mlir_await); + builder, node, left->declaration_attr.value_or(nullptr), mlir_left, + mlir_right, mlir_await); - mlir::Region &body_region = op.getBody(); - AppendNewBlockAndPopulate(body_region, [&] { VisitStatement(node->body()); }); + mlir::Region& body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, body_region, + [&] { VisitStatement(builder, node->body()); }); return op; } JsirArrowFunctionExpressionOp AstToJsir::VisitArrowFunctionExpression( - const JsArrowFunctionExpression *node) { + mlir::OpBuilder& builder, const JsArrowFunctionExpression* node) { mlir::Value mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierRef(node->id().value()); + mlir_id = VisitIdentifierRef(builder, node->id().value()); } std::vector mlir_params; - for (const auto ¶m : *node->params()) { - mlir::Value mlir_param = VisitPatternRef(param.get()); + for (const auto& param : *node->params()) { + mlir::Value mlir_param = VisitPatternRef(builder, param.get()); mlir_params.push_back(mlir_param); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); auto op = CreateExpr( - node, mlir_id, mlir_params, mlir_generator, mlir_async); - mlir::Region &body_region = op.getBody(); - AppendNewBlockAndPopulate(body_region, [&] { - if (std::holds_alternative(node->body())) { - auto *body = std::get(node->body()); - VisitBlockStatement(body); - } else if (std::holds_alternative(node->body())) { - auto *body = std::get(node->body()); - mlir::Value mlir_body = VisitExpression(body); - CreateStmt(body, mlir_body); + builder, node, mlir_id, mlir_params, mlir_generator, mlir_async); + mlir::Region& body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, body_region, [&] { + if (std::holds_alternative(node->body())) { + auto* body = std::get(node->body()); + VisitBlockStatement(builder, body); + } else if (std::holds_alternative(node->body())) { + auto* body = std::get(node->body()); + mlir::Value mlir_body = VisitExpression(builder, body); + CreateStmt(builder, nullptr, mlir_body); } else { LOG(FATAL) << "Unreachable code."; } @@ -325,81 +331,85 @@ JsirArrowFunctionExpressionOp AstToJsir::VisitArrowFunctionExpression( } JsirObjectPropertyOp AstToJsir::VisitObjectProperty( - const JsObjectProperty *node) { - auto mlir_key = GetObjectPropertyKey(node->key(), node->computed()); - mlir::BoolAttr mlir_shorthand = builder_.getBoolAttr(node->shorthand()); - CHECK(std::holds_alternative(node->value())); + mlir::OpBuilder& builder, const JsObjectProperty* node) { + auto mlir_key = GetObjectPropertyKey(builder, node->key(), node->computed()); + mlir::BoolAttr mlir_shorthand = builder.getBoolAttr(node->shorthand()); + CHECK(std::holds_alternative(node->value())); mlir::Value mlir_value = - VisitExpression(std::get(node->value())); - return CreateExpr( - node, mlir_key.literal, mlir_key.computed, mlir_shorthand, mlir_value); + VisitExpression(builder, std::get(node->value())); + return CreateExpr(builder, node, mlir_key.literal, + mlir_key.computed, mlir_shorthand, + mlir_value); } JsirObjectPropertyRefOp AstToJsir::VisitObjectPropertyRef( - const JsObjectProperty *node) { - auto mlir_key = GetObjectPropertyKey(node->key(), node->computed()); - mlir::BoolAttr mlir_shorthand = builder_.getBoolAttr(node->shorthand()); - const JsPattern *value_pattern; - if (std::holds_alternative(node->value())) { - const auto *value_expression = - std::get(node->value()); - CHECK(value_pattern = dynamic_cast(value_expression)); + mlir::OpBuilder& builder, const JsObjectProperty* node) { + auto mlir_key = GetObjectPropertyKey(builder, node->key(), node->computed()); + mlir::BoolAttr mlir_shorthand = builder.getBoolAttr(node->shorthand()); + const JsPattern* value_pattern; + if (std::holds_alternative(node->value())) { + const auto* value_expression = std::get(node->value()); + CHECK(value_pattern = dynamic_cast(value_expression)); } else { - value_pattern = std::get(node->value()); + value_pattern = std::get(node->value()); } - mlir::Value mlir_value = VisitPatternRef(value_pattern); - return CreateExpr( - node, mlir_key.literal, mlir_key.computed, mlir_shorthand, mlir_value); + mlir::Value mlir_value = VisitPatternRef(builder, value_pattern); + return CreateExpr(builder, node, mlir_key.literal, + mlir_key.computed, mlir_shorthand, + mlir_value); } -JsirObjectMethodOp AstToJsir::VisitObjectMethod(const JsObjectMethod *node) { - auto mlir_key = GetObjectPropertyKey(node->key(), node->computed()); +JsirObjectMethodOp AstToJsir::VisitObjectMethod(mlir::OpBuilder& builder, + const JsObjectMethod* node) { + auto mlir_key = GetObjectPropertyKey(builder, node->key(), node->computed()); JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } std::vector mlir_params; - for (const auto ¶m : *node->params()) { - mlir::Value mlir_param = VisitPatternRef(param.get()); + for (const auto& param : *node->params()) { + mlir::Value mlir_param = VisitPatternRef(builder, param.get()); mlir_params.push_back(mlir_param); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); - mlir::StringAttr mlir_kind = builder_.getStringAttr(node->kind()); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); + mlir::StringAttr mlir_kind = builder.getStringAttr(node->kind()); auto op = CreateExpr( - node, mlir_key.literal, mlir_key.computed, mlir_id, mlir_params, + builder, node, mlir_key.literal, mlir_key.computed, mlir_id, mlir_params, mlir_generator, mlir_async, mlir_kind); - mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, - [&] { VisitBlockStatement(node->body()); }); + mlir::Region& mlir_body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); + }); return op; } JsirObjectExpressionOp AstToJsir::VisitObjectExpression( - const JsObjectExpression *node) { - auto op = CreateExpr(node); - mlir::Region &mlir_properties_region = op.getRegion(); - AppendNewBlockAndPopulate(mlir_properties_region, [&] { + mlir::OpBuilder& builder, const JsObjectExpression* node) { + auto op = CreateExpr(builder, node); + mlir::Region& mlir_properties_region = op.getRegion(); + AppendNewBlockAndPopulate(builder, mlir_properties_region, [&] { std::vector mlir_properties; - for (const auto &property : *node->properties_()) { + for (const auto& property : *node->properties_()) { mlir::Value mlir_property; switch (property.index()) { case 0: { - const JsObjectProperty *property_object_property = + const JsObjectProperty* property_object_property = std::get<0>(property).get(); - mlir_property = VisitObjectProperty(property_object_property); + mlir_property = + VisitObjectProperty(builder, property_object_property); break; } case 1: { - const JsObjectMethod *property_object_method = + const JsObjectMethod* property_object_method = std::get<1>(property).get(); - mlir_property = VisitObjectMethod(property_object_method); + mlir_property = VisitObjectMethod(builder, property_object_method); break; } case 2: { - const JsSpreadElement *property_spread_element = + const JsSpreadElement* property_spread_element = std::get<2>(property).get(); - mlir_property = VisitSpreadElement(property_spread_element); + mlir_property = VisitSpreadElement(builder, property_spread_element); break; } default: @@ -407,261 +417,274 @@ JsirObjectExpressionOp AstToJsir::VisitObjectExpression( } mlir_properties.push_back(mlir_property); } - CreateStmt(node, mlir_properties); + CreateStmt(builder, nullptr, mlir_properties); }); return op; } mlir::Value AstToJsir::VisitMemberExpressionObject( - std::variant object) { - if (std::holds_alternative(object)) { - auto *object_expression = std::get(object); - return VisitExpression(object_expression); - } else if (std::holds_alternative(object)) { - auto *object_super = std::get(object); - return VisitSuper(object_super); + mlir::OpBuilder& builder, + std::variant object) { + if (std::holds_alternative(object)) { + auto* object_expression = std::get(object); + return VisitExpression(builder, object_expression); + } else if (std::holds_alternative(object)) { + auto* object_super = std::get(object); + return VisitSuper(builder, object_super); } else { LOG(FATAL) << "Unreachable code."; } } AstToJsir::MemberExpressionProperty AstToJsir::VisitMemberExpressionProperty( - std::variant property, + mlir::OpBuilder& builder, + std::variant property, bool computed) { if (computed) { // The op corresponds to a computed (`a[b]`) member expression and // `property` is an `Expression`. - CHECK(std::holds_alternative(property)); - auto *property_expression = std::get(property); - mlir::Value mlir_property = VisitExpression(property_expression); + CHECK(std::holds_alternative(property)); + auto* property_expression = std::get(property); + mlir::Value mlir_property = VisitExpression(builder, property_expression); return {.literal = nullptr, .computed = mlir_property}; } else { mlir::Attribute mlir_property; // The op corresponds to a static (`a.b`) member expression and `property` // is an `Identifier` or a `PrivateName`. - if (std::holds_alternative(property)) { - auto *property_expression = std::get(property); - auto *property_identifier = - dynamic_cast(property_expression); + if (std::holds_alternative(property)) { + auto* property_expression = std::get(property); + auto* property_identifier = + dynamic_cast(property_expression); CHECK(property_identifier != nullptr) << "If computed == false, then `property` can only be Identifier or " "PrivateName."; - mlir_property = VisitIdentifierAttr(property_identifier); - } else if (std::holds_alternative(property)) { - auto *property_private_name = std::get(property); - mlir_property = VisitPrivateNameAttr(property_private_name); + mlir_property = VisitIdentifierAttr(builder, property_identifier); + } else if (std::holds_alternative(property)) { + auto* property_private_name = std::get(property); + mlir_property = VisitPrivateNameAttr(builder, property_private_name); } return {.literal = mlir_property, .computed = nullptr}; } } JsirMemberExpressionOp AstToJsir::VisitMemberExpression( - const JsMemberExpression *node) { - mlir::Value mlir_object = VisitMemberExpressionObject(node->object()); - MemberExpressionProperty mlir_property = - VisitMemberExpressionProperty(node->property(), node->computed()); - return CreateExpr( - node, mlir_object, mlir_property.literal, mlir_property.computed); + mlir::OpBuilder& builder, const JsMemberExpression* node) { + mlir::Value mlir_object = + VisitMemberExpressionObject(builder, node->object()); + MemberExpressionProperty mlir_property = VisitMemberExpressionProperty( + builder, node->property(), node->computed()); + return CreateExpr(builder, node, mlir_object, + mlir_property.literal, + mlir_property.computed); } JsirMemberExpressionRefOp AstToJsir::VisitMemberExpressionRef( - const JsMemberExpression *node) { - mlir::Value mlir_object = VisitMemberExpressionObject(node->object()); - MemberExpressionProperty mlir_property = - VisitMemberExpressionProperty(node->property(), node->computed()); - return CreateExpr( - node, mlir_object, mlir_property.literal, mlir_property.computed); + mlir::OpBuilder& builder, const JsMemberExpression* node) { + mlir::Value mlir_object = + VisitMemberExpressionObject(builder, node->object()); + MemberExpressionProperty mlir_property = VisitMemberExpressionProperty( + builder, node->property(), node->computed()); + return CreateExpr(builder, node, mlir_object, + mlir_property.literal, + mlir_property.computed); } JsirOptionalMemberExpressionOp AstToJsir::VisitOptionalMemberExpression( - const JsOptionalMemberExpression *node) { - mlir::Value mlir_object = VisitMemberExpressionObject(node->object()); - MemberExpressionProperty mlir_property = - VisitMemberExpressionProperty(node->property(), node->computed()); - mlir::BoolAttr mlir_optional = builder_.getBoolAttr(node->optional()); + mlir::OpBuilder& builder, const JsOptionalMemberExpression* node) { + mlir::Value mlir_object = + VisitMemberExpressionObject(builder, node->object()); + MemberExpressionProperty mlir_property = VisitMemberExpressionProperty( + builder, node->property(), node->computed()); + mlir::BoolAttr mlir_optional = builder.getBoolAttr(node->optional()); return CreateExpr( - node, mlir_object, mlir_property.literal, mlir_property.computed, + builder, node, mlir_object, mlir_property.literal, mlir_property.computed, mlir_optional); } JsirParenthesizedExpressionOp AstToJsir::VisitParenthesizedExpression( - const JsParenthesizedExpression *node) { - mlir::Value mlir_expression = VisitExpression(node->expression()); - return CreateExpr(node, mlir_expression); + mlir::OpBuilder& builder, const JsParenthesizedExpression* node) { + mlir::Value mlir_expression = VisitExpression(builder, node->expression()); + return CreateExpr(builder, node, + mlir_expression); } JsirParenthesizedExpressionRefOp AstToJsir::VisitParenthesizedExpressionRef( - const JsParenthesizedExpression *node) { + mlir::OpBuilder& builder, const JsParenthesizedExpression* node) { mlir::Value mlir_expression = [&]() -> mlir::Value { - if (auto *lval = dynamic_cast(node->expression())) { - return VisitLValRef(lval); + if (auto* lval = dynamic_cast(node->expression())) { + return VisitLValRef(builder, lval); } else { // TODO(b/293174026): Disallow this. - mlir::emitError(GetJsirTriviaAttr(builder_.getContext(), *node), + mlir::emitError(GetJsirTriviaAttr(builder.getContext(), *node), "lvalue expected"); - return VisitExpression(node->expression()); + return VisitExpression(builder, node->expression()); } }(); - return CreateExpr(node, mlir_expression); + return CreateExpr(builder, node, + mlir_expression); } -JsirClassMethodOp AstToJsir::VisitClassMethod(const JsClassMethod *node) { +JsirClassMethodOp AstToJsir::VisitClassMethod(mlir::OpBuilder& builder, + const JsClassMethod* node) { JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } std::vector mlir_params; - for (const auto ¶m : *node->params()) { - mlir::Value mlir_param = VisitPatternRef(param.get()); + for (const auto& param : *node->params()) { + mlir::Value mlir_param = VisitPatternRef(builder, param.get()); mlir_params.push_back(mlir_param); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); - auto mlir_key = GetObjectPropertyKey(node->key(), node->computed()); - mlir::StringAttr mlir_kind = builder_.getStringAttr(node->kind()); - mlir::BoolAttr mlir_static = builder_.getBoolAttr(node->static_()); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); + auto mlir_key = GetObjectPropertyKey(builder, node->key(), node->computed()); + mlir::StringAttr mlir_kind = builder.getStringAttr(node->kind()); + mlir::BoolAttr mlir_static = builder.getBoolAttr(node->static_()); auto op = CreateStmt( - node, mlir_id, mlir_params, mlir_generator, mlir_async, mlir_key.literal, - mlir_key.computed, mlir_kind, mlir_static); - mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, - [&] { VisitBlockStatement(node->body()); }); + builder, node, mlir_id, mlir_params, mlir_generator, mlir_async, + mlir_key.literal, mlir_key.computed, mlir_kind, mlir_static); + mlir::Region& mlir_body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); + }); return op; } JsirClassPrivateMethodOp AstToJsir::VisitClassPrivateMethod( - const JsClassPrivateMethod *node) { + mlir::OpBuilder& builder, const JsClassPrivateMethod* node) { JsirIdentifierAttr mlir_id; if (node->id().has_value()) { - mlir_id = VisitIdentifierAttr(node->id().value()); + mlir_id = VisitIdentifierAttr(builder, node->id().value()); } std::vector mlir_params; - for (const auto ¶m : *node->params()) { - mlir::Value mlir_param = VisitPatternRef(param.get()); + for (const auto& param : *node->params()) { + mlir::Value mlir_param = VisitPatternRef(builder, param.get()); mlir_params.push_back(mlir_param); } - mlir::BoolAttr mlir_generator = builder_.getBoolAttr(node->generator()); - mlir::BoolAttr mlir_async = builder_.getBoolAttr(node->async()); - JsirPrivateNameAttr mlir_key = VisitPrivateNameAttr(node->key()); - mlir::StringAttr mlir_kind = builder_.getStringAttr(node->kind()); - mlir::BoolAttr mlir_static = builder_.getBoolAttr(node->static_()); + mlir::BoolAttr mlir_generator = builder.getBoolAttr(node->generator()); + mlir::BoolAttr mlir_async = builder.getBoolAttr(node->async()); + JsirPrivateNameAttr mlir_key = VisitPrivateNameAttr(builder, node->key()); + mlir::StringAttr mlir_kind = builder.getStringAttr(node->kind()); + mlir::BoolAttr mlir_static = builder.getBoolAttr(node->static_()); auto op = CreateStmt( - node, mlir_id, mlir_params, mlir_generator, mlir_async, mlir_key, + builder, node, mlir_id, mlir_params, mlir_generator, mlir_async, mlir_key, mlir_kind, mlir_static); - mlir::Region &mlir_body_region = op.getBody(); - AppendNewBlockAndPopulate(mlir_body_region, - [&] { VisitBlockStatement(node->body()); }); + mlir::Region& mlir_body_region = op.getBody(); + AppendNewBlockAndPopulate(builder, mlir_body_region, [&] { + VisitBlockStatement(builder, node->body()); + }); return op; } -JsirClassPropertyOp AstToJsir::VisitClassProperty(const JsClassProperty *node) { - auto mlir_key = GetObjectPropertyKey(node->key(), node->computed()); - mlir::BoolAttr mlir_static = builder_.getBoolAttr(node->static_()); - auto op = CreateStmt(node, mlir_key.literal, +JsirClassPropertyOp AstToJsir::VisitClassProperty(mlir::OpBuilder& builder, + const JsClassProperty* node) { + auto mlir_key = GetObjectPropertyKey(builder, node->key(), node->computed()); + mlir::BoolAttr mlir_static = builder.getBoolAttr(node->static_()); + auto op = CreateStmt(builder, node, mlir_key.literal, mlir_key.computed, mlir_static); if (node->value().has_value()) { - AppendNewBlockAndPopulate(op.getValue(), [&] { - mlir::Value mlir_value = VisitExpression(node->value().value()); - CreateStmt(node->value().value(), mlir_value); + AppendNewBlockAndPopulate(builder, op.getValue(), [&] { + mlir::Value mlir_value = VisitExpression(builder, node->value().value()); + CreateStmt(builder, nullptr, + mlir_value); }); } return op; } JsirImportSpecifierAttr AstToJsir::VisitImportSpecifierAttr( - const JsImportSpecifier *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); + mlir::OpBuilder& builder, const JsImportSpecifier* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); mlir::Attribute mlir_imported; - if (std::holds_alternative(node->imported())) { - auto *imported = std::get(node->imported()); - mlir_imported = VisitIdentifierAttr(imported); - } else if (std::holds_alternative( - node->imported())) { - auto *imported = std::get(node->imported()); - mlir_imported = VisitStringLiteralAttr(imported); + if (std::holds_alternative(node->imported())) { + auto* imported = std::get(node->imported()); + mlir_imported = VisitIdentifierAttr(builder, imported); + } else if (std::holds_alternative(node->imported())) { + auto* imported = std::get(node->imported()); + mlir_imported = VisitStringLiteralAttr(builder, imported); } else { LOG(FATAL) << "Unreachable code."; } - JsirIdentifierAttr mlir_local = VisitIdentifierAttr(node->local()); - return JsirImportSpecifierAttr::get(builder_.getContext(), loc, mlir_imported, + JsirIdentifierAttr mlir_local = VisitIdentifierAttr(builder, node->local()); + return JsirImportSpecifierAttr::get(builder.getContext(), loc, mlir_imported, mlir_local); } JsirImportDefaultSpecifierAttr AstToJsir::VisitImportDefaultSpecifierAttr( - const JsImportDefaultSpecifier *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - JsirIdentifierAttr mlir_local = VisitIdentifierAttr(node->local()); - return JsirImportDefaultSpecifierAttr::get(builder_.getContext(), loc, + mlir::OpBuilder& builder, const JsImportDefaultSpecifier* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + JsirIdentifierAttr mlir_local = VisitIdentifierAttr(builder, node->local()); + return JsirImportDefaultSpecifierAttr::get(builder.getContext(), loc, mlir_local); } JsirImportNamespaceSpecifierAttr AstToJsir::VisitImportNamespaceSpecifierAttr( - const JsImportNamespaceSpecifier *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); - JsirIdentifierAttr mlir_local = VisitIdentifierAttr(node->local()); - return JsirImportNamespaceSpecifierAttr::get(builder_.getContext(), loc, + mlir::OpBuilder& builder, const JsImportNamespaceSpecifier* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); + JsirIdentifierAttr mlir_local = VisitIdentifierAttr(builder, node->local()); + return JsirImportNamespaceSpecifierAttr::get(builder.getContext(), loc, mlir_local); } JsirImportAttributeAttr AstToJsir::VisitImportAttributeAttr( - const JsImportAttribute *node) { - JsirIdentifierAttr mlir_key = VisitIdentifierAttr(node->key()); - JsirStringLiteralAttr mlir_value = VisitStringLiteralAttr(node->value()); - return JsirImportAttributeAttr::get(builder_.getContext(), mlir_key, + mlir::OpBuilder& builder, const JsImportAttribute* node) { + JsirIdentifierAttr mlir_key = VisitIdentifierAttr(builder, node->key()); + JsirStringLiteralAttr mlir_value = + VisitStringLiteralAttr(builder, node->value()); + return JsirImportAttributeAttr::get(builder.getContext(), mlir_key, mlir_value); } JsirExportSpecifierAttr AstToJsir::VisitExportSpecifierAttr( - const JsExportSpecifier *node) { - auto loc = GetJsirTriviaAttr(builder_.getContext(), *node); + mlir::OpBuilder& builder, const JsExportSpecifier* node) { + auto loc = GetJsirTriviaAttr(builder.getContext(), *node); mlir::Attribute mlir_exported; - if (std::holds_alternative(node->exported())) { - auto *exported = std::get(node->exported()); - mlir_exported = VisitIdentifierAttr(exported); - } else if (std::holds_alternative( - node->exported())) { - auto *exported = std::get(node->exported()); - mlir_exported = VisitStringLiteralAttr(exported); + if (std::holds_alternative(node->exported())) { + auto* exported = std::get(node->exported()); + mlir_exported = VisitIdentifierAttr(builder, exported); + } else if (std::holds_alternative(node->exported())) { + auto* exported = std::get(node->exported()); + mlir_exported = VisitStringLiteralAttr(builder, exported); } else { LOG(FATAL) << "Unreachable code."; } mlir::Attribute mlir_local; if (node->local().has_value()) { auto local_variant = node->local().value(); - if (std::holds_alternative(local_variant)) { - auto *local = std::get(local_variant); - mlir_local = VisitIdentifierAttr(local); - } else if (std::holds_alternative(local_variant)) { - auto *local = std::get(local_variant); - mlir_local = VisitStringLiteralAttr(local); + if (std::holds_alternative(local_variant)) { + auto* local = std::get(local_variant); + mlir_local = VisitIdentifierAttr(builder, local); + } else if (std::holds_alternative(local_variant)) { + auto* local = std::get(local_variant); + mlir_local = VisitStringLiteralAttr(builder, local); } else { LOG(FATAL) << "Unreachable code."; } } - return JsirExportSpecifierAttr::get(builder_.getContext(), loc, mlir_exported, + return JsirExportSpecifierAttr::get(builder.getContext(), loc, mlir_exported, mlir_local); } JsirExportDefaultDeclarationOp AstToJsir::VisitExportDefaultDeclaration( - const JsExportDefaultDeclaration *node) { - auto op = CreateStmt(node); - mlir::Region &mlir_declaration_region = op.getDeclaration(); - AppendNewBlockAndPopulate(mlir_declaration_region, [&] { - if (std::holds_alternative( + mlir::OpBuilder& builder, const JsExportDefaultDeclaration* node) { + auto op = CreateStmt(builder, node); + mlir::Region& mlir_declaration_region = op.getDeclaration(); + AppendNewBlockAndPopulate(builder, mlir_declaration_region, [&] { + if (std::holds_alternative( node->declaration())) { - auto *declaration = - std::get(node->declaration()); - VisitFunctionDeclaration(declaration); - } else if (std::holds_alternative( + auto* declaration = + std::get(node->declaration()); + VisitFunctionDeclaration(builder, declaration); + } else if (std::holds_alternative( node->declaration())) { - auto *declaration = - std::get(node->declaration()); - VisitClassDeclaration(declaration); - } else if (std::holds_alternative( + auto* declaration = + std::get(node->declaration()); + VisitClassDeclaration(builder, declaration); + } else if (std::holds_alternative( node->declaration())) { - auto *declaration = std::get(node->declaration()); - mlir::Value mlir_declaration = VisitExpression(declaration); - CreateStmt(declaration, mlir_declaration); + auto* declaration = std::get(node->declaration()); + mlir::Value mlir_declaration = VisitExpression(builder, declaration); + CreateStmt(builder, nullptr, mlir_declaration); } else { LOG(FATAL) << "Unreachable code."; } @@ -669,39 +692,40 @@ JsirExportDefaultDeclarationOp AstToJsir::VisitExportDefaultDeclaration( return op; } -void AstToJsir::AppendNewBlockAndPopulate(mlir::Region ®ion, +void AstToJsir::AppendNewBlockAndPopulate(mlir::OpBuilder& builder, + mlir::Region& region, std::function populate) { // Save insertion point. // Will revert at the end. - mlir::OpBuilder::InsertionGuard insertion_guard(builder_); + mlir::OpBuilder::InsertionGuard insertion_guard(builder); // Insert new block and point builder to it. - mlir::Block &block = region.emplaceBlock(); - builder_.setInsertionPointToStart(&block); + mlir::Block& block = region.emplaceBlock(); + builder.setInsertionPointToStart(&block); populate(); } AstToJsir::ObjectPropertyKey AstToJsir::GetObjectPropertyKey( - const JsExpression *node, bool computed) { + mlir::OpBuilder& builder, const JsExpression* node, bool computed) { if (!computed) { mlir::Attribute attr; - if (auto *identifier = dynamic_cast(node)) { - attr = VisitIdentifierAttr(identifier); - } else if (auto *string_literal = - dynamic_cast(node)) { - attr = VisitStringLiteralAttr(string_literal); - } else if (auto *numeric_literal = - dynamic_cast(node)) { - attr = VisitNumericLiteralAttr(numeric_literal); - } else if (auto *big_int_literal = - dynamic_cast(node)) { - attr = VisitBigIntLiteralAttr(big_int_literal); + if (auto* identifier = dynamic_cast(node)) { + attr = VisitIdentifierAttr(builder, identifier); + } else if (auto* string_literal = + dynamic_cast(node)) { + attr = VisitStringLiteralAttr(builder, string_literal); + } else if (auto* numeric_literal = + dynamic_cast(node)) { + attr = VisitNumericLiteralAttr(builder, numeric_literal); + } else if (auto* big_int_literal = + dynamic_cast(node)) { + attr = VisitBigIntLiteralAttr(builder, big_int_literal); } else { LOG(FATAL) << "Invalid property name."; } return ObjectPropertyKey{.literal = attr, .computed = nullptr}; } else { - JsirExpressionOpInterface op = VisitExpression(node); + JsirExpressionOpInterface op = VisitExpression(builder, node); return ObjectPropertyKey{.literal = nullptr, .computed = op}; } } diff --git a/maldoca/js/ir/conversion/jsir_to_ast.generated.cc b/maldoca/js/ir/conversion/jsir_to_ast.generated.cc index 7df775c..4e826c6 100644 --- a/maldoca/js/ir/conversion/jsir_to_ast.generated.cc +++ b/maldoca/js/ir/conversion/jsir_to_ast.generated.cc @@ -48,6 +48,7 @@ #include "absl/strings/str_cat.h" #include "absl/types/optional.h" #include "absl/types/variant.h" +#include "maldoca/astgen/ir_to_ast_util.h" #include "maldoca/base/status_macros.h" #include "maldoca/js/ast/ast.generated.h" #include "maldoca/js/ir/ir.h" @@ -140,11 +141,22 @@ JsirToAst::VisitProgramBodyElement(JsirProgramBodyElementOpInterface op) { absl::StatusOr> JsirToAst::VisitDirectiveLiteral(JsirDirectiveLiteralOp op) { - std::string value = op.getValueAttr().str(); - std::optional> extra; - if (op.getExtraAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(extra, VisitDirectiveLiteralExtraAttr(op.getExtraAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValueAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto extra, + Convert( + op.getExtraAttr(), + Nullable( + ToAttrConverter(VisitDirectiveLiteralExtraAttr) + ) + ) + ); return Create( op, std::move(value), @@ -153,13 +165,13 @@ JsirToAst::VisitDirectiveLiteral(JsirDirectiveLiteralOp op) { absl::StatusOr> JsirToAst::VisitDirective(JsirDirectiveOp op) { - auto value_op = llvm::dyn_cast(op.getValue().getDefiningOp()); - if (value_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirDirectiveLiteralOp, got ", - op.getValue().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr value, VisitDirectiveLiteral(value_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValue(), + ToOpConverter(VisitDirectiveLiteral) + ) + ); return Create( op, std::move(value)); @@ -167,31 +179,44 @@ JsirToAst::VisitDirective(JsirDirectiveOp op) { absl::StatusOr> JsirToAst::VisitProgram(JsirProgramOp op) { - std::optional> interpreter; - if (op.getInterpreterAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(interpreter, VisitInterpreterDirectiveAttr(op.getInterpreterAttr())); - } - std::string source_type = op.getSourceTypeAttr().str(); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_block, GetStmtsRegionBlock(op.getBody())); - std::vector> body; - for (mlir::Operation& mlir_body_element_unchecked : *mlir_body_block) { - auto body_element_op = llvm::dyn_cast(mlir_body_element_unchecked); - if (body_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body_element, VisitProgramBodyElement(body_element_op)); - body.push_back(std::move(body_element)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_directives_block, GetStmtsRegionBlock(op.getDirectives())); - std::vector> directives; - for (mlir::Operation& mlir_directives_element_unchecked : *mlir_directives_block) { - auto directives_element_op = llvm::dyn_cast(mlir_directives_element_unchecked); - if (directives_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr directives_element, VisitDirective(directives_element_op)); - directives.push_back(std::move(directives_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto interpreter, + Convert( + op.getInterpreterAttr(), + Nullable( + ToAttrConverter(VisitInterpreterDirectiveAttr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto source_type, + Convert( + op.getSourceTypeAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtsRegion( + List( + ToOpConverter(VisitProgramBodyElement) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto directives, + Convert( + op.getDirectives(), + StmtsRegion( + List( + ToOpConverter(VisitDirective) + ) + ) + ) + ); return Create( op, std::move(interpreter), @@ -202,27 +227,26 @@ JsirToAst::VisitProgram(JsirProgramOp op) { absl::StatusOr> JsirToAst::VisitFile(JsirFileOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_program_operation, GetStmtRegionOperation(op.getProgram())); - auto program_op = llvm::dyn_cast(mlir_program_operation); - if (program_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirProgramOp, got ", - mlir_program_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr program, VisitProgram(program_op)); - std::optional>> comments; - if (op.getCommentsAttr() != nullptr) { - std::vector> comments_value; - for (mlir::Attribute mlir_comments_element_unchecked : op.getCommentsAttr().getValue()) { - auto comments_element_attr = llvm::dyn_cast(mlir_comments_element_unchecked); - if (comments_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr comments_element, VisitCommentAttr(comments_element_attr)); - comments_value.push_back(std::move(comments_element)); - } - comments = std::move(comments_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto program, + Convert( + op.getProgram(), + StmtRegion( + ToOpConverter(VisitProgram) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto comments, + Convert( + op.getCommentsAttr(), + Nullable( + List( + ToAttrConverter(VisitCommentAttr) + ) + ) + ) + ); return Create( op, std::move(program), @@ -393,7 +417,13 @@ JsirToAst::VisitLValRef(JsirLValRefOpInterface op) { absl::StatusOr> JsirToAst::VisitIdentifier(JsirIdentifierOp op) { - std::string name = op.getNameAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto name, + Convert( + op.getNameAttr(), + ToString() + ) + ); return Create( op, std::move(name)); @@ -401,7 +431,13 @@ JsirToAst::VisitIdentifier(JsirIdentifierOp op) { absl::StatusOr> JsirToAst::VisitIdentifierRef(JsirIdentifierRefOp op) { - std::string name = op.getNameAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto name, + Convert( + op.getNameAttr(), + ToString() + ) + ); return Create( op, std::move(name)); @@ -409,7 +445,13 @@ JsirToAst::VisitIdentifierRef(JsirIdentifierRefOp op) { absl::StatusOr> JsirToAst::VisitPrivateName(JsirPrivateNameOp op) { - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr id, VisitIdentifierAttr(op.getIdAttr())); + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getIdAttr(), + ToAttrConverter(VisitIdentifierAttr) + ) + ); return Create( op, std::move(id)); @@ -444,12 +486,29 @@ JsirToAst::VisitLiteral(JsirLiteralOpInterface op) { absl::StatusOr> JsirToAst::VisitRegExpLiteral(JsirRegExpLiteralOp op) { - std::string pattern = op.getPatternAttr().str(); - std::string flags = op.getFlagsAttr().str(); - std::optional> extra; - if (op.getExtraAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(extra, VisitRegExpLiteralExtraAttr(op.getExtraAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto pattern, + Convert( + op.getPatternAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto flags, + Convert( + op.getFlagsAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto extra, + Convert( + op.getExtraAttr(), + Nullable( + ToAttrConverter(VisitRegExpLiteralExtraAttr) + ) + ) + ); return Create( op, std::move(pattern), @@ -465,11 +524,22 @@ JsirToAst::VisitNullLiteral(JsirNullLiteralOp op) { absl::StatusOr> JsirToAst::VisitStringLiteral(JsirStringLiteralOp op) { - std::string value = op.getValueAttr().str(); - std::optional> extra; - if (op.getExtraAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(extra, VisitStringLiteralExtraAttr(op.getExtraAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValueAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto extra, + Convert( + op.getExtraAttr(), + Nullable( + ToAttrConverter(VisitStringLiteralExtraAttr) + ) + ) + ); return Create( op, std::move(value), @@ -478,7 +548,13 @@ JsirToAst::VisitStringLiteral(JsirStringLiteralOp op) { absl::StatusOr> JsirToAst::VisitBooleanLiteral(JsirBooleanLiteralOp op) { - bool value = op.getValueAttr().getValue(); + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValueAttr(), + ToBool() + ) + ); return Create( op, std::move(value)); @@ -486,11 +562,22 @@ JsirToAst::VisitBooleanLiteral(JsirBooleanLiteralOp op) { absl::StatusOr> JsirToAst::VisitNumericLiteral(JsirNumericLiteralOp op) { - double value = op.getValueAttr().getValueAsDouble(); - std::optional> extra; - if (op.getExtraAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(extra, VisitNumericLiteralExtraAttr(op.getExtraAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValueAttr(), + ToDouble() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto extra, + Convert( + op.getExtraAttr(), + Nullable( + ToAttrConverter(VisitNumericLiteralExtraAttr) + ) + ) + ); return Create( op, std::move(value), @@ -499,11 +586,22 @@ JsirToAst::VisitNumericLiteral(JsirNumericLiteralOp op) { absl::StatusOr> JsirToAst::VisitBigIntLiteral(JsirBigIntLiteralOp op) { - std::string value = op.getValueAttr().str(); - std::optional> extra; - if (op.getExtraAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(extra, VisitBigIntLiteralExtraAttr(op.getExtraAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValueAttr(), + ToString() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto extra, + Convert( + op.getExtraAttr(), + Nullable( + ToAttrConverter(VisitBigIntLiteralExtraAttr) + ) + ) + ); return Create( op, std::move(value), @@ -584,26 +682,28 @@ JsirToAst::VisitStatement(JsirStatementOpInterface op) { absl::StatusOr> JsirToAst::VisitBlockStatement(JshirBlockStatementOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_block, GetStmtsRegionBlock(op.getBody())); - std::vector> body; - for (mlir::Operation& mlir_body_element_unchecked : *mlir_body_block) { - auto body_element_op = llvm::dyn_cast(mlir_body_element_unchecked); - if (body_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body_element, VisitStatement(body_element_op)); - body.push_back(std::move(body_element)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_directives_block, GetStmtsRegionBlock(op.getDirectives())); - std::vector> directives; - for (mlir::Operation& mlir_directives_element_unchecked : *mlir_directives_block) { - auto directives_element_op = llvm::dyn_cast(mlir_directives_element_unchecked); - if (directives_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr directives_element, VisitDirective(directives_element_op)); - directives.push_back(std::move(directives_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtsRegion( + List( + ToOpConverter(VisitStatement) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto directives, + Convert( + op.getDirectives(), + StmtsRegion( + List( + ToOpConverter(VisitDirective) + ) + ) + ) + ); return Create( op, std::move(body), @@ -612,13 +712,13 @@ JsirToAst::VisitBlockStatement(JshirBlockStatementOp op) { absl::StatusOr> JsirToAst::VisitExpressionStatement(JsirExpressionStatementOp op) { - auto expression_op = llvm::dyn_cast(op.getExpression().getDefiningOp()); - if (expression_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getExpression().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr expression, VisitExpression(expression_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto expression, + Convert( + op.getExpression(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(expression)); @@ -638,21 +738,22 @@ JsirToAst::VisitDebuggerStatement(JsirDebuggerStatementOp op) { absl::StatusOr> JsirToAst::VisitWithStatement(JshirWithStatementOp op) { - auto object_op = llvm::dyn_cast(op.getObject().getDefiningOp()); - if (object_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getObject().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr object, VisitExpression(object_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto object, + Convert( + op.getObject(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ); return Create( op, std::move(object), @@ -661,16 +762,15 @@ JsirToAst::VisitWithStatement(JshirWithStatementOp op) { absl::StatusOr> JsirToAst::VisitReturnStatement(JsirReturnStatementOp op) { - std::optional> argument; - if (op.getArgument() != nullptr) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(argument, VisitExpression(argument_op)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(argument)); @@ -678,15 +778,22 @@ JsirToAst::VisitReturnStatement(JsirReturnStatementOp op) { absl::StatusOr> JsirToAst::VisitLabeledStatement(JshirLabeledStatementOp op) { - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr label, VisitIdentifierAttr(op.getLabelAttr())); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto label, + Convert( + op.getLabelAttr(), + ToAttrConverter(VisitIdentifierAttr) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ); return Create( op, std::move(label), @@ -695,32 +802,33 @@ JsirToAst::VisitLabeledStatement(JshirLabeledStatementOp op) { absl::StatusOr> JsirToAst::VisitIfStatement(JshirIfStatementOp op) { - auto test_op = llvm::dyn_cast(op.getTest().getDefiningOp()); - if (test_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getTest().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr test, VisitExpression(test_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_consequent_operation, GetStmtRegionOperation(op.getConsequent())); - auto consequent_op = llvm::dyn_cast(mlir_consequent_operation); - if (consequent_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_consequent_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr consequent, VisitStatement(consequent_op)); - std::optional> alternate; - if (!op.getAlternate().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_alternate_operation, GetStmtRegionOperation(op.getAlternate())); - auto alternate_op = llvm::dyn_cast(mlir_alternate_operation); - if (alternate_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_alternate_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(alternate, VisitStatement(alternate_op)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto test, + Convert( + op.getTest(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto consequent, + Convert( + op.getConsequent(), + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto alternate, + Convert( + op.getAlternate(), + Nullable( + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ) + ); return Create( op, std::move(test), @@ -730,27 +838,28 @@ JsirToAst::VisitIfStatement(JshirIfStatementOp op) { absl::StatusOr> JsirToAst::VisitSwitchCase(JshirSwitchCaseOp op) { - std::optional> test; - if (!op.getTest().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_test_value, GetExprRegionValue(op.getTest())); - auto test_op = llvm::dyn_cast(mlir_test_value.getDefiningOp()); - if (test_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_test_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(test, VisitExpression(test_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_consequent_block, GetStmtsRegionBlock(op.getConsequent())); - std::vector> consequent; - for (mlir::Operation& mlir_consequent_element_unchecked : *mlir_consequent_block) { - auto consequent_element_op = llvm::dyn_cast(mlir_consequent_element_unchecked); - if (consequent_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr consequent_element, VisitStatement(consequent_element_op)); - consequent.push_back(std::move(consequent_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto test, + Convert( + op.getTest(), + Nullable( + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto consequent, + Convert( + op.getConsequent(), + StmtsRegion( + List( + ToOpConverter(VisitStatement) + ) + ) + ) + ); return Create( op, std::move(test), @@ -759,23 +868,24 @@ JsirToAst::VisitSwitchCase(JshirSwitchCaseOp op) { absl::StatusOr> JsirToAst::VisitSwitchStatement(JshirSwitchStatementOp op) { - auto discriminant_op = llvm::dyn_cast(op.getDiscriminant().getDefiningOp()); - if (discriminant_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getDiscriminant().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr discriminant, VisitExpression(discriminant_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_cases_block, GetStmtsRegionBlock(op.getCases())); - std::vector> cases; - for (mlir::Operation& mlir_cases_element_unchecked : *mlir_cases_block) { - auto cases_element_op = llvm::dyn_cast(mlir_cases_element_unchecked); - if (cases_element_op == nullptr) { - continue; - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr cases_element, VisitSwitchCase(cases_element_op)); - cases.push_back(std::move(cases_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto discriminant, + Convert( + op.getDiscriminant(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto cases, + Convert( + op.getCases(), + StmtsRegion( + List( + ToOpConverter(VisitSwitchCase) + ) + ) + ) + ); return Create( op, std::move(discriminant), @@ -784,13 +894,13 @@ JsirToAst::VisitSwitchStatement(JshirSwitchStatementOp op) { absl::StatusOr> JsirToAst::VisitThrowStatement(JsirThrowStatementOp op) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr argument, VisitExpression(argument_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(argument)); @@ -798,24 +908,24 @@ JsirToAst::VisitThrowStatement(JsirThrowStatementOp op) { absl::StatusOr> JsirToAst::VisitCatchClause(JshirCatchClauseOp op) { - std::optional> param; - if (op.getParam() != nullptr) { - auto param_op = llvm::dyn_cast(op.getParam().getDefiningOp()); - if (param_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirPatternRefOpInterface, got ", - op.getParam().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(param, VisitPatternRef(param_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirBlockStatementOp, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitBlockStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto param, + Convert( + op.getParam(), + Nullable( + ToOpConverter(VisitPatternRef) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitBlockStatement) + ) + ) + ); return Create( op, std::move(param), @@ -824,36 +934,37 @@ JsirToAst::VisitCatchClause(JshirCatchClauseOp op) { absl::StatusOr> JsirToAst::VisitTryStatement(JshirTryStatementOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_block_operation, GetStmtRegionOperation(op.getBlock())); - auto block_op = llvm::dyn_cast(mlir_block_operation); - if (block_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirBlockStatementOp, got ", - mlir_block_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr block, VisitBlockStatement(block_op)); - std::optional> handler; - if (!op.getHandler().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_handler_operation, GetStmtRegionOperation(op.getHandler())); - auto handler_op = llvm::dyn_cast(mlir_handler_operation); - if (handler_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirCatchClauseOp, got ", - mlir_handler_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(handler, VisitCatchClause(handler_op)); - } - std::optional> finalizer; - if (!op.getFinalizer().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_finalizer_operation, GetStmtRegionOperation(op.getFinalizer())); - auto finalizer_op = llvm::dyn_cast(mlir_finalizer_operation); - if (finalizer_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirBlockStatementOp, got ", - mlir_finalizer_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(finalizer, VisitBlockStatement(finalizer_op)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto block, + Convert( + op.getBlock(), + StmtRegion( + ToOpConverter(VisitBlockStatement) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto handler, + Convert( + op.getHandler(), + Nullable( + StmtRegion( + ToOpConverter(VisitCatchClause) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto finalizer, + Convert( + op.getFinalizer(), + Nullable( + StmtRegion( + ToOpConverter(VisitBlockStatement) + ) + ) + ) + ); return Create( op, std::move(block), @@ -863,22 +974,24 @@ JsirToAst::VisitTryStatement(JshirTryStatementOp op) { absl::StatusOr> JsirToAst::VisitWhileStatement(JshirWhileStatementOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_test_value, GetExprRegionValue(op.getTest())); - auto test_op = llvm::dyn_cast(mlir_test_value.getDefiningOp()); - if (test_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_test_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr test, VisitExpression(test_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto test, + Convert( + op.getTest(), + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ); return Create( op, std::move(test), @@ -887,22 +1000,24 @@ JsirToAst::VisitWhileStatement(JshirWhileStatementOp op) { absl::StatusOr> JsirToAst::VisitDoWhileStatement(JshirDoWhileStatementOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirStatementOpInterface, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitStatement(body_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_test_value, GetExprRegionValue(op.getTest())); - auto test_op = llvm::dyn_cast(mlir_test_value.getDefiningOp()); - if (test_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_test_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr test, VisitExpression(test_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitStatement) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto test, + Convert( + op.getTest(), + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(body), @@ -929,23 +1044,22 @@ JsirToAst::VisitDeclaration(JsirDeclarationOpInterface op) { absl::StatusOr> JsirToAst::VisitVariableDeclarator(JsirVariableDeclaratorOp op) { - auto id_op = llvm::dyn_cast(op.getId().getDefiningOp()); - if (id_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirLValRefOpInterface, got ", - op.getId().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr id, VisitLValRef(id_op)); - std::optional> init; - if (op.getInit() != nullptr) { - auto init_op = llvm::dyn_cast(op.getInit().getDefiningOp()); - if (init_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getInit().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(init, VisitExpression(init_op)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getId(), + ToOpConverter(VisitLValRef) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto init, + Convert( + op.getInit(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(id), @@ -954,19 +1068,24 @@ JsirToAst::VisitVariableDeclarator(JsirVariableDeclaratorOp op) { absl::StatusOr> JsirToAst::VisitVariableDeclaration(JsirVariableDeclarationOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_declarations_values, GetExprsRegionValues(op.getDeclarations())); - std::vector> declarations; - for (mlir::Value mlir_declarations_element_unchecked : mlir_declarations_values) { - auto declarations_element_op = llvm::dyn_cast(mlir_declarations_element_unchecked.getDefiningOp()); - if (declarations_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirVariableDeclaratorOp, got ", - mlir_declarations_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr declarations_element, VisitVariableDeclarator(declarations_element_op)); - declarations.push_back(std::move(declarations_element)); - } - std::string kind = op.getKindAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto declarations, + Convert( + op.getDeclarations(), + ExprsRegion( + List( + ToOpConverter(VisitVariableDeclarator) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto kind, + Convert( + op.getKindAttr(), + ToString() + ) + ); return Create( op, std::move(declarations), @@ -975,32 +1094,49 @@ JsirToAst::VisitVariableDeclaration(JsirVariableDeclarationOp op) { absl::StatusOr> JsirToAst::VisitFunctionDeclaration(JsirFunctionDeclarationOp op) { - std::optional> id; - if (op.getIdAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(id, VisitIdentifierAttr(op.getIdAttr())); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_params_values, GetExprsRegionValues(op.getParams())); - std::vector> params; - for (mlir::Value mlir_params_element_unchecked : mlir_params_values) { - auto params_element_op = llvm::dyn_cast(mlir_params_element_unchecked.getDefiningOp()); - if (params_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirPatternRefOpInterface, got ", - mlir_params_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr params_element, VisitPatternRef(params_element_op)); - params.push_back(std::move(params_element)); - } - bool generator = op.getGeneratorAttr().getValue(); - bool async = op.getAsyncAttr().getValue(); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirBlockStatementOp, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitBlockStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getIdAttr(), + Nullable( + ToAttrConverter(VisitIdentifierAttr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto params, + Convert( + op.getParams(), + ExprsRegion( + List( + ToOpConverter(VisitPatternRef) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto generator, + Convert( + op.getGeneratorAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto async, + Convert( + op.getAsyncAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitBlockStatement) + ) + ) + ); return Create( op, std::move(id), @@ -1030,17 +1166,22 @@ JsirToAst::VisitThisExpression(JsirThisExpressionOp op) { absl::StatusOr> JsirToAst::VisitYieldExpression(JsirYieldExpressionOp op) { - std::optional> argument; - if (op.getArgument() != nullptr) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(argument, VisitExpression(argument_op)); - } - bool delegate = op.getDelegateAttr().getValue(); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto delegate, + Convert( + op.getDelegateAttr(), + ToBool() + ) + ); return Create( op, std::move(argument), @@ -1049,16 +1190,15 @@ JsirToAst::VisitYieldExpression(JsirYieldExpressionOp op) { absl::StatusOr> JsirToAst::VisitAwaitExpression(JsirAwaitExpressionOp op) { - std::optional> argument; - if (op.getArgument() != nullptr) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(argument, VisitExpression(argument_op)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(argument)); @@ -1066,13 +1206,13 @@ JsirToAst::VisitAwaitExpression(JsirAwaitExpressionOp op) { absl::StatusOr> JsirToAst::VisitSpreadElement(JsirSpreadElementOp op) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr argument, VisitExpression(argument_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(argument)); @@ -1080,20 +1220,20 @@ JsirToAst::VisitSpreadElement(JsirSpreadElementOp op) { absl::StatusOr> JsirToAst::VisitArrayExpression(JsirArrayExpressionOp op) { - std::vector, std::unique_ptr>>> elements; - for (mlir::Value mlir_elements_element_unchecked : op.getElements()) { - std::optional, std::unique_ptr>> elements_element; - if (!llvm::isa(mlir_elements_element_unchecked.getDefiningOp())) { - if (auto mlir_elements_element = llvm::dyn_cast(mlir_elements_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(elements_element, VisitExpression(mlir_elements_element)); - } else if (auto mlir_elements_element = llvm::dyn_cast(mlir_elements_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(elements_element, VisitSpreadElement(mlir_elements_element)); - } else { - return absl::InvalidArgumentError("mlir_elements_element_unchecked.getDefiningOp() has invalid type."); - } - } - elements.push_back(std::move(elements_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto elements, + Convert( + op.getElements(), + List( + Nullable( + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSpreadElement) + ) + ) + ) + ) + ); return Create( op, std::move(elements)); @@ -1101,32 +1241,49 @@ JsirToAst::VisitArrayExpression(JsirArrayExpressionOp op) { absl::StatusOr> JsirToAst::VisitFunctionExpression(JsirFunctionExpressionOp op) { - std::optional> id; - if (op.getIdAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(id, VisitIdentifierAttr(op.getIdAttr())); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_params_values, GetExprsRegionValues(op.getParams())); - std::vector> params; - for (mlir::Value mlir_params_element_unchecked : mlir_params_values) { - auto params_element_op = llvm::dyn_cast(mlir_params_element_unchecked.getDefiningOp()); - if (params_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirPatternRefOpInterface, got ", - mlir_params_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr params_element, VisitPatternRef(params_element_op)); - params.push_back(std::move(params_element)); - } - bool generator = op.getGeneratorAttr().getValue(); - bool async = op.getAsyncAttr().getValue(); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JshirBlockStatementOp, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitBlockStatement(body_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getIdAttr(), + Nullable( + ToAttrConverter(VisitIdentifierAttr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto params, + Convert( + op.getParams(), + ExprsRegion( + List( + ToOpConverter(VisitPatternRef) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto generator, + Convert( + op.getGeneratorAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto async, + Convert( + op.getAsyncAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitBlockStatement) + ) + ) + ); return Create( op, std::move(id), @@ -1138,15 +1295,27 @@ JsirToAst::VisitFunctionExpression(JsirFunctionExpressionOp op) { absl::StatusOr> JsirToAst::VisitUnaryExpression(JsirUnaryExpressionOp op) { - MALDOCA_ASSIGN_OR_RETURN(JsUnaryOperator operator_, StringToJsUnaryOperator(op.getOperator_Attr().str())); - bool prefix = op.getPrefixAttr().getValue(); - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr argument, VisitExpression(argument_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto operator_, + Convert( + op.getOperator_Attr(), + Enum(StringToJsUnaryOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto prefix, + Convert( + op.getPrefixAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(operator_), @@ -1156,15 +1325,27 @@ JsirToAst::VisitUnaryExpression(JsirUnaryExpressionOp op) { absl::StatusOr> JsirToAst::VisitUpdateExpression(JsirUpdateExpressionOp op) { - MALDOCA_ASSIGN_OR_RETURN(JsUpdateOperator operator_, StringToJsUpdateOperator(op.getOperator_Attr().str())); - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirLValRefOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr argument, VisitLValRef(argument_op)); - bool prefix = op.getPrefixAttr().getValue(); + MALDOCA_ASSIGN_OR_RETURN( + auto operator_, + Convert( + op.getOperator_Attr(), + Enum(StringToJsUpdateOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + ToOpConverter(VisitLValRef) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto prefix, + Convert( + op.getPrefixAttr(), + ToBool() + ) + ); return Create( op, std::move(operator_), @@ -1174,22 +1355,30 @@ JsirToAst::VisitUpdateExpression(JsirUpdateExpressionOp op) { absl::StatusOr> JsirToAst::VisitBinaryExpression(JsirBinaryExpressionOp op) { - MALDOCA_ASSIGN_OR_RETURN(JsBinaryOperator operator_, StringToJsBinaryOperator(op.getOperator_Attr().str())); - std::variant, std::unique_ptr> left; - if (auto mlir_left = llvm::dyn_cast(op.getLeft().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(left, VisitExpression(mlir_left)); - } else if (auto mlir_left = llvm::dyn_cast(op.getLeft().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(left, VisitPrivateName(mlir_left)); - } else { - return absl::InvalidArgumentError("op.getLeft().getDefiningOp() has invalid type."); - } - auto right_op = llvm::dyn_cast(op.getRight().getDefiningOp()); - if (right_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getRight().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr right, VisitExpression(right_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto operator_, + Convert( + op.getOperator_Attr(), + Enum(StringToJsBinaryOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto left, + Convert( + op.getLeft(), + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitPrivateName) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto right, + Convert( + op.getRight(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(operator_), @@ -1199,21 +1388,27 @@ JsirToAst::VisitBinaryExpression(JsirBinaryExpressionOp op) { absl::StatusOr> JsirToAst::VisitAssignmentExpression(JsirAssignmentExpressionOp op) { - MALDOCA_ASSIGN_OR_RETURN(JsAssignmentOperator operator_, StringToJsAssignmentOperator(op.getOperator_Attr().str())); - auto left_op = llvm::dyn_cast(op.getLeft().getDefiningOp()); - if (left_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirLValRefOpInterface, got ", - op.getLeft().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr left, VisitLValRef(left_op)); - auto right_op = llvm::dyn_cast(op.getRight().getDefiningOp()); - if (right_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getRight().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr right, VisitExpression(right_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto operator_, + Convert( + op.getOperator_Attr(), + Enum(StringToJsAssignmentOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto left, + Convert( + op.getLeft(), + ToOpConverter(VisitLValRef) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto right, + Convert( + op.getRight(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(operator_), @@ -1223,22 +1418,29 @@ JsirToAst::VisitAssignmentExpression(JsirAssignmentExpressionOp op) { absl::StatusOr> JsirToAst::VisitLogicalExpression(JshirLogicalExpressionOp op) { - MALDOCA_ASSIGN_OR_RETURN(JsLogicalOperator operator_, StringToJsLogicalOperator(op.getOperator_Attr().str())); - auto left_op = llvm::dyn_cast(op.getLeft().getDefiningOp()); - if (left_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getLeft().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr left, VisitExpression(left_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_right_value, GetExprRegionValue(op.getRight())); - auto right_op = llvm::dyn_cast(mlir_right_value.getDefiningOp()); - if (right_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_right_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr right, VisitExpression(right_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto operator_, + Convert( + op.getOperator_Attr(), + Enum(StringToJsLogicalOperator) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto left, + Convert( + op.getLeft(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto right, + Convert( + op.getRight(), + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(operator_), @@ -1248,29 +1450,31 @@ JsirToAst::VisitLogicalExpression(JshirLogicalExpressionOp op) { absl::StatusOr> JsirToAst::VisitConditionalExpression(JshirConditionalExpressionOp op) { - auto test_op = llvm::dyn_cast(op.getTest().getDefiningOp()); - if (test_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getTest().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr test, VisitExpression(test_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_alternate_value, GetExprRegionValue(op.getAlternate())); - auto alternate_op = llvm::dyn_cast(mlir_alternate_value.getDefiningOp()); - if (alternate_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_alternate_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr alternate, VisitExpression(alternate_op)); - MALDOCA_ASSIGN_OR_RETURN(auto mlir_consequent_value, GetExprRegionValue(op.getConsequent())); - auto consequent_op = llvm::dyn_cast(mlir_consequent_value.getDefiningOp()); - if (consequent_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_consequent_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr consequent, VisitExpression(consequent_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto test, + Convert( + op.getTest(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto alternate, + Convert( + op.getAlternate(), + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto consequent, + Convert( + op.getConsequent(), + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(test), @@ -1280,28 +1484,29 @@ JsirToAst::VisitConditionalExpression(JshirConditionalExpressionOp op) { absl::StatusOr> JsirToAst::VisitCallExpression(JsirCallExpressionOp op) { - std::variant, std::unique_ptr, std::unique_ptr> callee; - if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitExpression(mlir_callee)); - } else if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitSuper(mlir_callee)); - } else if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitImport(mlir_callee)); - } else { - return absl::InvalidArgumentError("op.getCallee().getDefiningOp() has invalid type."); - } - std::vector, std::unique_ptr>> arguments; - for (mlir::Value mlir_arguments_element_unchecked : op.getArguments()) { - std::variant, std::unique_ptr> arguments_element; - if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitExpression(mlir_arguments_element)); - } else if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitSpreadElement(mlir_arguments_element)); - } else { - return absl::InvalidArgumentError("mlir_arguments_element_unchecked.getDefiningOp() has invalid type."); - } - arguments.push_back(std::move(arguments_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto callee, + Convert( + op.getCallee(), + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSuper), + ToOpConverter(VisitImport) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto arguments, + Convert( + op.getArguments(), + List( + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSpreadElement) + ) + ) + ) + ); return Create( op, std::move(callee), @@ -1310,26 +1515,32 @@ JsirToAst::VisitCallExpression(JsirCallExpressionOp op) { absl::StatusOr> JsirToAst::VisitOptionalCallExpression(JsirOptionalCallExpressionOp op) { - auto callee_op = llvm::dyn_cast(op.getCallee().getDefiningOp()); - if (callee_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getCallee().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr callee, VisitExpression(callee_op)); - std::vector, std::unique_ptr>> arguments; - for (mlir::Value mlir_arguments_element_unchecked : op.getArguments()) { - std::variant, std::unique_ptr> arguments_element; - if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitExpression(mlir_arguments_element)); - } else if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitSpreadElement(mlir_arguments_element)); - } else { - return absl::InvalidArgumentError("mlir_arguments_element_unchecked.getDefiningOp() has invalid type."); - } - arguments.push_back(std::move(arguments_element)); - } - bool optional = op.getOptionalAttr().getValue(); + MALDOCA_ASSIGN_OR_RETURN( + auto callee, + Convert( + op.getCallee(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto arguments, + Convert( + op.getArguments(), + List( + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSpreadElement) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto optional, + Convert( + op.getOptionalAttr(), + ToBool() + ) + ); return Create( op, std::move(callee), @@ -1339,28 +1550,29 @@ JsirToAst::VisitOptionalCallExpression(JsirOptionalCallExpressionOp op) { absl::StatusOr> JsirToAst::VisitNewExpression(JsirNewExpressionOp op) { - std::variant, std::unique_ptr, std::unique_ptr> callee; - if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitExpression(mlir_callee)); - } else if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitSuper(mlir_callee)); - } else if (auto mlir_callee = llvm::dyn_cast(op.getCallee().getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(callee, VisitImport(mlir_callee)); - } else { - return absl::InvalidArgumentError("op.getCallee().getDefiningOp() has invalid type."); - } - std::vector, std::unique_ptr>> arguments; - for (mlir::Value mlir_arguments_element_unchecked : op.getArguments()) { - std::variant, std::unique_ptr> arguments_element; - if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitExpression(mlir_arguments_element)); - } else if (auto mlir_arguments_element = llvm::dyn_cast(mlir_arguments_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(arguments_element, VisitSpreadElement(mlir_arguments_element)); - } else { - return absl::InvalidArgumentError("mlir_arguments_element_unchecked.getDefiningOp() has invalid type."); - } - arguments.push_back(std::move(arguments_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto callee, + Convert( + op.getCallee(), + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSuper), + ToOpConverter(VisitImport) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto arguments, + Convert( + op.getArguments(), + List( + OpVariant( + ToOpConverter(VisitExpression), + ToOpConverter(VisitSpreadElement) + ) + ) + ) + ); return Create( op, std::move(callee), @@ -1369,17 +1581,15 @@ JsirToAst::VisitNewExpression(JsirNewExpressionOp op) { absl::StatusOr> JsirToAst::VisitSequenceExpression(JsirSequenceExpressionOp op) { - std::vector> expressions; - for (mlir::Value mlir_expressions_element_unchecked : op.getExpressions()) { - auto expressions_element_op = llvm::dyn_cast(mlir_expressions_element_unchecked.getDefiningOp()); - if (expressions_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_expressions_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr expressions_element, VisitExpression(expressions_element_op)); - expressions.push_back(std::move(expressions_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto expressions, + Convert( + op.getExpressions(), + List( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(expressions)); @@ -1387,11 +1597,22 @@ JsirToAst::VisitSequenceExpression(JsirSequenceExpressionOp op) { absl::StatusOr> JsirToAst::VisitTemplateElementValue(JsirTemplateElementValueOp op) { - std::optional cooked; - if (op.getCookedAttr() != nullptr) { - cooked = op.getCookedAttr().str(); - } - std::string raw = op.getRawAttr().str(); + MALDOCA_ASSIGN_OR_RETURN( + auto cooked, + Convert( + op.getCookedAttr(), + Nullable( + ToString() + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto raw, + Convert( + op.getRawAttr(), + ToString() + ) + ); return Create( op, std::move(cooked), @@ -1400,14 +1621,20 @@ JsirToAst::VisitTemplateElementValue(JsirTemplateElementValueOp op) { absl::StatusOr> JsirToAst::VisitTemplateElement(JsirTemplateElementOp op) { - bool tail = op.getTailAttr().getValue(); - auto value_op = llvm::dyn_cast(op.getValue().getDefiningOp()); - if (value_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirTemplateElementValueOp, got ", - op.getValue().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr value, VisitTemplateElementValue(value_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto tail, + Convert( + op.getTailAttr(), + ToBool() + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValue(), + ToOpConverter(VisitTemplateElementValue) + ) + ); return Create( op, std::move(tail), @@ -1416,28 +1643,24 @@ JsirToAst::VisitTemplateElement(JsirTemplateElementOp op) { absl::StatusOr> JsirToAst::VisitTemplateLiteral(JsirTemplateLiteralOp op) { - std::vector> quasis; - for (mlir::Value mlir_quasis_element_unchecked : op.getQuasis()) { - auto quasis_element_op = llvm::dyn_cast(mlir_quasis_element_unchecked.getDefiningOp()); - if (quasis_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirTemplateElementOp, got ", - mlir_quasis_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr quasis_element, VisitTemplateElement(quasis_element_op)); - quasis.push_back(std::move(quasis_element)); - } - std::vector> expressions; - for (mlir::Value mlir_expressions_element_unchecked : op.getExpressions()) { - auto expressions_element_op = llvm::dyn_cast(mlir_expressions_element_unchecked.getDefiningOp()); - if (expressions_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_expressions_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr expressions_element, VisitExpression(expressions_element_op)); - expressions.push_back(std::move(expressions_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto quasis, + Convert( + op.getQuasis(), + List( + ToOpConverter(VisitTemplateElement) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto expressions, + Convert( + op.getExpressions(), + List( + ToOpConverter(VisitExpression) + ) + ) + ); return Create( op, std::move(quasis), @@ -1446,20 +1669,20 @@ JsirToAst::VisitTemplateLiteral(JsirTemplateLiteralOp op) { absl::StatusOr> JsirToAst::VisitTaggedTemplateExpression(JsirTaggedTemplateExpressionOp op) { - auto tag_op = llvm::dyn_cast(op.getTag().getDefiningOp()); - if (tag_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getTag().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr tag, VisitExpression(tag_op)); - auto quasi_op = llvm::dyn_cast(op.getQuasi().getDefiningOp()); - if (quasi_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirTemplateLiteralOp, got ", - op.getQuasi().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr quasi, VisitTemplateLiteral(quasi_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto tag, + Convert( + op.getTag(), + ToOpConverter(VisitExpression) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto quasi, + Convert( + op.getQuasi(), + ToOpConverter(VisitTemplateLiteral) + ) + ); return Create( op, std::move(tag), @@ -1468,13 +1691,13 @@ JsirToAst::VisitTaggedTemplateExpression(JsirTaggedTemplateExpressionOp op) { absl::StatusOr> JsirToAst::VisitRestElementRef(JsirRestElementRefOp op) { - auto argument_op = llvm::dyn_cast(op.getArgument().getDefiningOp()); - if (argument_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirLValRefOpInterface, got ", - op.getArgument().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr argument, VisitLValRef(argument_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto argument, + Convert( + op.getArgument(), + ToOpConverter(VisitLValRef) + ) + ); return Create( op, std::move(argument)); @@ -1482,19 +1705,20 @@ JsirToAst::VisitRestElementRef(JsirRestElementRefOp op) { absl::StatusOr> JsirToAst::VisitObjectPatternRef(JsirObjectPatternRefOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_properties_values, GetExprsRegionValues(op.getProperties_())); - std::vector, std::unique_ptr>> properties_; - for (mlir::Value mlir_properties_element_unchecked : mlir_properties_values) { - std::variant, std::unique_ptr> properties_element; - if (auto mlir_properties_element = llvm::dyn_cast(mlir_properties_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, VisitObjectPropertyRef(mlir_properties_element)); - } else if (auto mlir_properties_element = llvm::dyn_cast(mlir_properties_element_unchecked.getDefiningOp())) { - MALDOCA_ASSIGN_OR_RETURN(properties_element, VisitRestElementRef(mlir_properties_element)); - } else { - return absl::InvalidArgumentError("mlir_properties_element_unchecked.getDefiningOp() has invalid type."); - } - properties_.push_back(std::move(properties_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto properties_, + Convert( + op.getProperties_(), + ExprsRegion( + List( + OpVariant( + ToOpConverter(VisitObjectPropertyRef), + ToOpConverter(VisitRestElementRef) + ) + ) + ) + ) + ); return Create( op, std::move(properties_)); @@ -1502,20 +1726,17 @@ JsirToAst::VisitObjectPatternRef(JsirObjectPatternRefOp op) { absl::StatusOr> JsirToAst::VisitArrayPatternRef(JsirArrayPatternRefOp op) { - std::vector>> elements; - for (mlir::Value mlir_elements_element_unchecked : op.getElements()) { - std::optional> elements_element; - if (!llvm::isa(mlir_elements_element_unchecked.getDefiningOp())) { - auto elements_element_op = llvm::dyn_cast(mlir_elements_element_unchecked.getDefiningOp()); - if (elements_element_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirPatternRefOpInterface, got ", - mlir_elements_element_unchecked.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(elements_element, VisitPatternRef(elements_element_op)); - } - elements.push_back(std::move(elements_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto elements, + Convert( + op.getElements(), + List( + Nullable( + ToOpConverter(VisitPatternRef) + ) + ) + ) + ); return Create( op, std::move(elements)); @@ -1523,20 +1744,20 @@ JsirToAst::VisitArrayPatternRef(JsirArrayPatternRefOp op) { absl::StatusOr> JsirToAst::VisitAssignmentPatternRef(JsirAssignmentPatternRefOp op) { - auto left_op = llvm::dyn_cast(op.getLeft().getDefiningOp()); - if (left_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirPatternRefOpInterface, got ", - op.getLeft().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr left, VisitPatternRef(left_op)); - auto right_op = llvm::dyn_cast(op.getRight().getDefiningOp()); - if (right_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getRight().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr right, VisitExpression(right_op)); + MALDOCA_ASSIGN_OR_RETURN( + auto left, + Convert( + op.getLeft(), + ToOpConverter(VisitPatternRef) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto right, + Convert( + op.getRight(), + ToOpConverter(VisitExpression) + ) + ); return Create( op, std::move(left), @@ -1545,19 +1766,31 @@ JsirToAst::VisitAssignmentPatternRef(JsirAssignmentPatternRefOp op) { absl::StatusOr> JsirToAst::VisitClassPrivateProperty(JsirClassPrivatePropertyOp op) { - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr key, VisitPrivateNameAttr(op.getKeyAttr())); - std::optional> value; - if (!op.getValue().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_value_value, GetExprRegionValue(op.getValue())); - auto value_op = llvm::dyn_cast(mlir_value_value.getDefiningOp()); - if (value_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - mlir_value_value.getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(value, VisitExpression(value_op)); - } - bool static_ = op.getStatic_Attr().getValue(); + MALDOCA_ASSIGN_OR_RETURN( + auto key, + Convert( + op.getKeyAttr(), + ToAttrConverter(VisitPrivateNameAttr) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto value, + Convert( + op.getValue(), + Nullable( + ExprRegion( + ToOpConverter(VisitExpression) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto static_, + Convert( + op.getStatic_Attr(), + ToBool() + ) + ); return Create( op, std::move(key), @@ -1567,23 +1800,22 @@ JsirToAst::VisitClassPrivateProperty(JsirClassPrivatePropertyOp op) { absl::StatusOr> JsirToAst::VisitClassBody(JsirClassBodyOp op) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_block, GetStmtsRegionBlock(op.getBody())); - std::vector, std::unique_ptr, std::unique_ptr, std::unique_ptr>> body; - for (mlir::Operation& mlir_body_element_unchecked : *mlir_body_block) { - std::variant, std::unique_ptr, std::unique_ptr, std::unique_ptr> body_element; - if (auto mlir_body_element = llvm::dyn_cast(mlir_body_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, VisitClassMethod(mlir_body_element)); - } else if (auto mlir_body_element = llvm::dyn_cast(mlir_body_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, VisitClassPrivateMethod(mlir_body_element)); - } else if (auto mlir_body_element = llvm::dyn_cast(mlir_body_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, VisitClassProperty(mlir_body_element)); - } else if (auto mlir_body_element = llvm::dyn_cast(mlir_body_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(body_element, VisitClassPrivateProperty(mlir_body_element)); - } else { - continue; - } - body.push_back(std::move(body_element)); - } + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtsRegion( + List( + OpVariant( + ToOpConverter(VisitClassMethod), + ToOpConverter(VisitClassPrivateMethod), + ToOpConverter(VisitClassProperty), + ToOpConverter(VisitClassPrivateProperty) + ) + ) + ) + ) + ); return Create( op, std::move(body)); @@ -1591,28 +1823,33 @@ JsirToAst::VisitClassBody(JsirClassBodyOp op) { absl::StatusOr> JsirToAst::VisitClassDeclaration(JsirClassDeclarationOp op) { - std::optional> super_class; - if (op.getSuperClass() != nullptr) { - auto super_class_op = llvm::dyn_cast(op.getSuperClass().getDefiningOp()); - if (super_class_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getSuperClass().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(super_class, VisitExpression(super_class_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirClassBodyOp, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitClassBody(body_op)); - std::optional> id; - if (op.getIdAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(id, VisitIdentifierAttr(op.getIdAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto super_class, + Convert( + op.getSuperClass(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitClassBody) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getIdAttr(), + Nullable( + ToAttrConverter(VisitIdentifierAttr) + ) + ) + ); return Create( op, std::move(super_class), @@ -1622,28 +1859,33 @@ JsirToAst::VisitClassDeclaration(JsirClassDeclarationOp op) { absl::StatusOr> JsirToAst::VisitClassExpression(JsirClassExpressionOp op) { - std::optional> super_class; - if (op.getSuperClass() != nullptr) { - auto super_class_op = llvm::dyn_cast(op.getSuperClass().getDefiningOp()); - if (super_class_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirExpressionOpInterface, got ", - op.getSuperClass().getDefiningOp()->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(super_class, VisitExpression(super_class_op)); - } - MALDOCA_ASSIGN_OR_RETURN(auto mlir_body_operation, GetStmtRegionOperation(op.getBody())); - auto body_op = llvm::dyn_cast(mlir_body_operation); - if (body_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirClassBodyOp, got ", - mlir_body_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr body, VisitClassBody(body_op)); - std::optional> id; - if (op.getIdAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(id, VisitIdentifierAttr(op.getIdAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto super_class, + Convert( + op.getSuperClass(), + Nullable( + ToOpConverter(VisitExpression) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto body, + Convert( + op.getBody(), + StmtRegion( + ToOpConverter(VisitClassBody) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto id, + Convert( + op.getIdAttr(), + Nullable( + ToAttrConverter(VisitIdentifierAttr) + ) + ) + ); return Create( op, std::move(super_class), @@ -1653,8 +1895,20 @@ JsirToAst::VisitClassExpression(JsirClassExpressionOp op) { absl::StatusOr> JsirToAst::VisitMetaProperty(JsirMetaPropertyOp op) { - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr meta, VisitIdentifierAttr(op.getMetaAttr())); - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr property, VisitIdentifierAttr(op.getPropertyAttr())); + MALDOCA_ASSIGN_OR_RETURN( + auto meta, + Convert( + op.getMetaAttr(), + ToAttrConverter(VisitIdentifierAttr) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto property, + Convert( + op.getPropertyAttr(), + ToAttrConverter(VisitIdentifierAttr) + ) + ); return Create( op, std::move(meta), @@ -1705,25 +1959,35 @@ JsirToAst::VisitModuleSpecifierAttr(JsirModuleSpecifierAttrInterface attr) { absl::StatusOr> JsirToAst::VisitImportDeclaration(JsirImportDeclarationOp op) { - std::vector, std::unique_ptr, std::unique_ptr>> specifiers; - for (mlir::Attribute mlir_specifiers_element_unchecked : op.getSpecifiersAttr().getValue()) { - std::variant, std::unique_ptr, std::unique_ptr> specifiers_element; - if (auto mlir_specifiers_element = llvm::dyn_cast(mlir_specifiers_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, VisitImportSpecifierAttr(mlir_specifiers_element)); - } else if (auto mlir_specifiers_element = llvm::dyn_cast(mlir_specifiers_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, VisitImportDefaultSpecifierAttr(mlir_specifiers_element)); - } else if (auto mlir_specifiers_element = llvm::dyn_cast(mlir_specifiers_element_unchecked)) { - MALDOCA_ASSIGN_OR_RETURN(specifiers_element, VisitImportNamespaceSpecifierAttr(mlir_specifiers_element)); - } else { - return absl::InvalidArgumentError("mlir_specifiers_element_unchecked has invalid type."); - } - specifiers.push_back(std::move(specifiers_element)); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr source, VisitStringLiteralAttr(op.getSourceAttr())); - std::optional> assertions; - if (op.getAssertionsAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(assertions, VisitImportAttributeAttr(op.getAssertionsAttr())); - } + MALDOCA_ASSIGN_OR_RETURN( + auto specifiers, + Convert( + op.getSpecifiersAttr(), + List( + AttrVariant( + ToAttrConverter(VisitImportSpecifierAttr), + ToAttrConverter(VisitImportDefaultSpecifierAttr), + ToAttrConverter(VisitImportNamespaceSpecifierAttr) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto source, + Convert( + op.getSourceAttr(), + ToAttrConverter(VisitStringLiteralAttr) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto assertions, + Convert( + op.getAssertionsAttr(), + Nullable( + ToAttrConverter(VisitImportAttributeAttr) + ) + ) + ); return Create( op, std::move(specifiers), @@ -1733,43 +1997,46 @@ JsirToAst::VisitImportDeclaration(JsirImportDeclarationOp op) { absl::StatusOr> JsirToAst::VisitExportNamedDeclaration(JsirExportNamedDeclarationOp op) { - std::optional> declaration; - if (!op.getDeclaration().empty()) { - MALDOCA_ASSIGN_OR_RETURN(auto mlir_declaration_operation, GetStmtRegionOperation(op.getDeclaration())); - auto declaration_op = llvm::dyn_cast(mlir_declaration_operation); - if (declaration_op == nullptr) { - return absl::InvalidArgumentError( - absl::StrCat("Expected JsirDeclarationOpInterface, got ", - mlir_declaration_operation->getName().getStringRef().str(), ".")); - } - MALDOCA_ASSIGN_OR_RETURN(declaration, VisitDeclaration(declaration_op)); - } - std::vector> specifiers; - for (mlir::Attribute mlir_specifiers_element_unchecked : op.getSpecifiersAttr().getValue()) { - auto specifiers_element_attr = llvm::dyn_cast(mlir_specifiers_element_unchecked); - if (specifiers_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr specifiers_element, VisitExportSpecifierAttr(specifiers_element_attr)); - specifiers.push_back(std::move(specifiers_element)); - } - std::optional> source; - if (op.getSourceAttr() != nullptr) { - MALDOCA_ASSIGN_OR_RETURN(source, VisitStringLiteralAttr(op.getSourceAttr())); - } - std::optional>> assertions; - if (op.getAssertionsAttr() != nullptr) { - std::vector> assertions_value; - for (mlir::Attribute mlir_assertions_element_unchecked : op.getAssertionsAttr().getValue()) { - auto assertions_element_attr = llvm::dyn_cast(mlir_assertions_element_unchecked); - if (assertions_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr assertions_element, VisitImportAttributeAttr(assertions_element_attr)); - assertions_value.push_back(std::move(assertions_element)); - } - assertions = std::move(assertions_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto declaration, + Convert( + op.getDeclaration(), + Nullable( + StmtRegion( + ToOpConverter(VisitDeclaration) + ) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto specifiers, + Convert( + op.getSpecifiersAttr(), + List( + ToAttrConverter(VisitExportSpecifierAttr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto source, + Convert( + op.getSourceAttr(), + Nullable( + ToAttrConverter(VisitStringLiteralAttr) + ) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto assertions, + Convert( + op.getAssertionsAttr(), + Nullable( + List( + ToAttrConverter(VisitImportAttributeAttr) + ) + ) + ) + ); return Create( op, std::move(declaration), @@ -1780,20 +2047,24 @@ JsirToAst::VisitExportNamedDeclaration(JsirExportNamedDeclarationOp op) { absl::StatusOr> JsirToAst::VisitExportAllDeclaration(JsirExportAllDeclarationOp op) { - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr source, VisitStringLiteralAttr(op.getSourceAttr())); - std::optional>> assertions; - if (op.getAssertionsAttr() != nullptr) { - std::vector> assertions_value; - for (mlir::Attribute mlir_assertions_element_unchecked : op.getAssertionsAttr().getValue()) { - auto assertions_element_attr = llvm::dyn_cast(mlir_assertions_element_unchecked); - if (assertions_element_attr == nullptr) { - return absl::InvalidArgumentError("Invalid attribute."); - } - MALDOCA_ASSIGN_OR_RETURN(std::unique_ptr assertions_element, VisitImportAttributeAttr(assertions_element_attr)); - assertions_value.push_back(std::move(assertions_element)); - } - assertions = std::move(assertions_value); - } + MALDOCA_ASSIGN_OR_RETURN( + auto source, + Convert( + op.getSourceAttr(), + ToAttrConverter(VisitStringLiteralAttr) + ) + ); + MALDOCA_ASSIGN_OR_RETURN( + auto assertions, + Convert( + op.getAssertionsAttr(), + Nullable( + List( + ToAttrConverter(VisitImportAttributeAttr) + ) + ) + ) + ); return Create( op, std::move(source), diff --git a/maldoca/js/ir/conversion/jsir_to_ast.h b/maldoca/js/ir/conversion/jsir_to_ast.h index 3979949..d064536 100644 --- a/maldoca/js/ir/conversion/jsir_to_ast.h +++ b/maldoca/js/ir/conversion/jsir_to_ast.h @@ -51,30 +51,32 @@ class JsirToAst { // Example: // // absl::StatusOr> VisitFile(JsirFileOp op); -#define DECLARE_CIR_OP_VISIT_FUNCTION(TYPE) \ - absl::StatusOr> Visit##TYPE(Jsir##TYPE##Op op); +#define DECLARE_CIR_OP_VISIT_FUNCTION(TYPE) \ + static absl::StatusOr> Visit##TYPE( \ + Jsir##TYPE##Op op); // Example: // // absl::StatusOr> // VisitBlockStatement(JshirBlockStatementOp op); -#define DECLARE_HIR_OP_VISIT_FUNCTION(TYPE) \ - absl::StatusOr> Visit##TYPE(Jshir##TYPE##Op op); +#define DECLARE_HIR_OP_VISIT_FUNCTION(TYPE) \ + static absl::StatusOr> Visit##TYPE( \ + Jshir##TYPE##Op op); // Example: // // absl::StatusOr> // VisitIdentifierRef(JsirIdentifierRefOp op); -#define DECLARE_REF_OP_VISIT_FUNCTION(TYPE) \ - absl::StatusOr> Visit##TYPE##Ref( \ +#define DECLARE_REF_OP_VISIT_FUNCTION(TYPE) \ + static absl::StatusOr> Visit##TYPE##Ref( \ Jsir##TYPE##RefOp op); // Example: // // absl::StatusOr> // VisitIdentifierAttr(JsirIdentifierAttr attr); -#define DECLARE_ATTRIB_VISIT_FUNCTION(TYPE) \ - absl::StatusOr> Visit##TYPE##Attr( \ +#define DECLARE_ATTRIB_VISIT_FUNCTION(TYPE) \ + static absl::StatusOr> Visit##TYPE##Attr( \ Jsir##TYPE##Attr attr); FOR_EACH_JSIR_CLASS(DECLARE_CIR_OP_VISIT_FUNCTION, @@ -87,28 +89,28 @@ class JsirToAst { #undef DECLARE_HIR_OP_VISIT_FUNCTION #undef DECLARE_ATTRIB_VISIT_FUNCTION - absl::StatusOr> VisitProgramBodyElement( - JsirProgramBodyElementOpInterface op); + static absl::StatusOr> + VisitProgramBodyElement(JsirProgramBodyElementOpInterface op); - absl::StatusOr> VisitStatement( + static absl::StatusOr> VisitStatement( JsirStatementOpInterface op); - absl::StatusOr> VisitModuleDeclaration( - JsirModuleDeclarationOpInterface op); + static absl::StatusOr> + VisitModuleDeclaration(JsirModuleDeclarationOpInterface op); - absl::StatusOr> VisitExpression( + static absl::StatusOr> VisitExpression( JsirExpressionOpInterface op); - absl::StatusOr> VisitPatternRef( + static absl::StatusOr> VisitPatternRef( JsirPatternRefOpInterface op); - absl::StatusOr> VisitLValRef( + static absl::StatusOr> VisitLValRef( JsirLValRefOpInterface op); - absl::StatusOr> VisitLiteral( + static absl::StatusOr> VisitLiteral( JsirLiteralOpInterface op); - absl::StatusOr> VisitDeclaration( + static absl::StatusOr> VisitDeclaration( JsirDeclarationOpInterface op); struct JsForInOfStatementFields { @@ -119,21 +121,21 @@ class JsirToAst { std::unique_ptr body; }; - absl::StatusOr VisitForInOfStatement( + static absl::StatusOr VisitForInOfStatement( std::optional left_declaration, - mlir::Value left_lval, mlir::Value right, mlir::Region &body_region); + mlir::Value left_lval, mlir::Value right, mlir::Region& body_region); - absl::StatusOr> VisitModuleSpecifierAttr( - JsirModuleSpecifierAttrInterface attr); + static absl::StatusOr> + VisitModuleSpecifierAttr(JsirModuleSpecifierAttrInterface attr); - absl::StatusOr> VisitCommentAttr( + static absl::StatusOr> VisitCommentAttr( JsirCommentAttrInterface attr); private: template >, typename... Args> - std::unique_ptr Create(IrT op, Args &&...args) { + static std::unique_ptr Create(IrT op, Args&&... args) { CHECK(op != nullptr) << "Op cannot be null."; JsTrivia trivia = GetJsTrivia(op); return CreateJsNodeWithTrivia(std::move(trivia), @@ -144,21 +146,21 @@ class JsirToAst { typename = std::enable_if_t>, typename = void, // deduplication typename... Args> - std::unique_ptr Create(IrT op, Args &&...args) { + static std::unique_ptr Create(IrT op, Args&&... args) { CHECK(op != nullptr) << "Op cannot be null."; return absl::make_unique(std::forward(args)...); } - absl::StatusOr>> - VisitStatementRegion(mlir::Region ®ion) { + static absl::StatusOr>> + VisitStatementRegion(mlir::Region& region) { if (!region.hasOneBlock()) { return absl::InvalidArgumentError( "Region should have exactly one block."); } - mlir::Block &block = region.getBlocks().front(); + mlir::Block& block = region.getBlocks().front(); std::vector> statements; - for (mlir::Operation &op : block) { + for (mlir::Operation& op : block) { if (!llvm::isa(op)) { continue; } @@ -175,7 +177,7 @@ class JsirToAst { bool computed; }; - absl::StatusOr GetObjectPropertyKey( + static absl::StatusOr GetObjectPropertyKey( mlir::Value computed_key, std::optional literal_key); struct MemberExpressionProperty { @@ -184,25 +186,24 @@ class JsirToAst { bool computed; }; - absl::StatusOr GetMemberExpressionProperty( + static absl::StatusOr GetMemberExpressionProperty( mlir::Value computed_property, std::optional literal_property); - absl::StatusOr< + static absl::StatusOr< std::variant, std::unique_ptr>> GetMemberExpressionObject(mlir::Value); - absl::StatusOr, - std::unique_ptr>> + static absl::StatusOr, + std::unique_ptr>> GetIdentifierOrStringLiteral(mlir::Attribute attr); template - using VisitFunc = - absl::StatusOr> (JsirToAst::*)(OpType); + using VisitFunc = absl::StatusOr> (*)(OpType); template - absl::StatusOr> VisitExprRegion( - mlir::Region ®ion, VisitFunc visit) { + static absl::StatusOr> VisitExprRegion( + mlir::Region& region, VisitFunc visit) { MALDOCA_ASSIGN_OR_RETURN(mlir::Value mlir_value, GetExprRegionValue(region)); auto mlir_op = llvm::dyn_cast(mlir_value.getDefiningOp()); @@ -210,15 +211,15 @@ class JsirToAst { return absl::InvalidArgumentError( absl::StrCat("Must be ", __PRETTY_FUNCTION__)); } - return (this->*visit)(mlir_op); + return visit(mlir_op); } - absl::StatusOr GetExprRegionValue(mlir::Region ®ion) { + static absl::StatusOr GetExprRegionValue(mlir::Region& region) { if (!region.hasOneBlock()) { return absl::InvalidArgumentError( "Region should have exactly one block."); } - mlir::Block &block = region.front(); + mlir::Block& block = region.front(); if (block.empty()) { return absl::InvalidArgumentError("Block cannot be empty."); } @@ -230,12 +231,13 @@ class JsirToAst { return expr_region_end.getArgument(); } - absl::StatusOr GetExprsRegionValues(mlir::Region ®ion) { + static absl::StatusOr GetExprsRegionValues( + mlir::Region& region) { if (!region.hasOneBlock()) { return absl::InvalidArgumentError( "Region should have exactly one block."); } - mlir::Block &block = region.front(); + mlir::Block& block = region.front(); if (block.empty()) { return absl::InvalidArgumentError("Block cannot be empty."); } @@ -247,13 +249,13 @@ class JsirToAst { return exprs_region_end.getArguments(); } - absl::StatusOr GetStmtRegionOperation( - mlir::Region ®ion) { + static absl::StatusOr GetStmtRegionOperation( + mlir::Region& region) { if (!region.hasOneBlock()) { return absl::InvalidArgumentError( "Region should have exactly one block."); } - mlir::Block &block = region.front(); + mlir::Block& block = region.front(); if (block.empty()) { return absl::InvalidArgumentError("Block cannot be empty."); } @@ -261,8 +263,8 @@ class JsirToAst { } template - absl::StatusOr> VisitStmtRegion( - mlir::Region ®ion, VisitFunc visit) { + static absl::StatusOr> VisitStmtRegion( + mlir::Region& region, VisitFunc visit) { MALDOCA_ASSIGN_OR_RETURN(mlir::Operation * mlir_operation, GetStmtRegionOperation(region)); auto mlir_op = llvm::dyn_cast(mlir_operation); @@ -270,32 +272,34 @@ class JsirToAst { return absl::InvalidArgumentError( absl::StrCat("Must be ", __PRETTY_FUNCTION__)); } - return (this->*visit)(mlir_op); + return visit(mlir_op); } - absl::StatusOr GetStmtsRegionBlock(mlir::Region ®ion) { + static absl::StatusOr GetStmtsRegionBlock( + mlir::Region& region) { if (!region.hasOneBlock()) { return absl::InvalidArgumentError( "Region should have exactly one block."); } - mlir::Block &block = region.front(); + mlir::Block& block = region.front(); return █ } template - absl::StatusOr, std::unique_ptr>> - VisitStmtOrExprRegion(mlir::Region ®ion, + static absl::StatusOr< + std::variant, std::unique_ptr>> + VisitStmtOrExprRegion(mlir::Region& region, VisitFunc visit_stmt, VisitFunc visit_expr) { MALDOCA_ASSIGN_OR_RETURN(auto mlir_end, GetStmtRegionOperation(region)); if (auto mlir_stmt_op = llvm::dyn_cast(mlir_end)) { - return (this->*visit_stmt)(mlir_stmt_op); + return visit_stmt(mlir_stmt_op); } else if (auto mlir_end_op = llvm::dyn_cast(mlir_end)) { auto mlir_expr_value = mlir_end_op.getArgument(); auto mlir_expr_op = llvm::dyn_cast(mlir_expr_value.getDefiningOp()); - return (this->*visit_expr)(mlir_expr_op); + return visit_expr(mlir_expr_op); } else { return absl::InvalidArgumentError("Invalid op type."); } diff --git a/maldoca/js/ir/conversion/tests/BUILD.template.bzl b/maldoca/js/ir/conversion/tests/BUILD.template.bzl index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/BUILD.template.bzl +++ b/maldoca/js/ir/conversion/tests/BUILD.template.bzl @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/array_expression/BUILD b/maldoca/js/ir/conversion/tests/array_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/array_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/array_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/array_pattern/BUILD b/maldoca/js/ir/conversion/tests/array_pattern/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/array_pattern/BUILD +++ b/maldoca/js/ir/conversion/tests/array_pattern/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD b/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/arrow_function_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/binary_expression/BUILD b/maldoca/js/ir/conversion/tests/binary_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/binary_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/binary_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/block_statement/BUILD b/maldoca/js/ir/conversion/tests/block_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/block_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/block_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/break/BUILD b/maldoca/js/ir/conversion/tests/break/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/break/BUILD +++ b/maldoca/js/ir/conversion/tests/break/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/call_expression/BUILD b/maldoca/js/ir/conversion/tests/call_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/call_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/call_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/class_declaration/BUILD b/maldoca/js/ir/conversion/tests/class_declaration/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/class_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/class_declaration/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/class_expression/BUILD b/maldoca/js/ir/conversion/tests/class_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/class_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/class_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/comment/BUILD b/maldoca/js/ir/conversion/tests/comment/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/comment/BUILD +++ b/maldoca/js/ir/conversion/tests/comment/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/conditional_expression/BUILD b/maldoca/js/ir/conversion/tests/conditional_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/conditional_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/conditional_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/continue_statement/BUILD b/maldoca/js/ir/conversion/tests/continue_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/continue_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/continue_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/debugger_statement/BUILD b/maldoca/js/ir/conversion/tests/debugger_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/debugger_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/debugger_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/directive_literal/BUILD b/maldoca/js/ir/conversion/tests/directive_literal/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/directive_literal/BUILD +++ b/maldoca/js/ir/conversion/tests/directive_literal/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/do_while_statement/BUILD b/maldoca/js/ir/conversion/tests/do_while_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/do_while_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/do_while_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/empty_statement/BUILD b/maldoca/js/ir/conversion/tests/empty_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/empty_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/empty_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/export_declaration/BUILD b/maldoca/js/ir/conversion/tests/export_declaration/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/export_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/export_declaration/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/for_in_statement/BUILD b/maldoca/js/ir/conversion/tests/for_in_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/for_in_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_in_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/for_of_statement/BUILD b/maldoca/js/ir/conversion/tests/for_of_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/for_of_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_of_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/for_statement/BUILD b/maldoca/js/ir/conversion/tests/for_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/for_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/for_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/function_declaration/BUILD b/maldoca/js/ir/conversion/tests/function_declaration/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/function_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/function_declaration/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/if_statement/BUILD b/maldoca/js/ir/conversion/tests/if_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/if_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/if_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/import_declaration/BUILD b/maldoca/js/ir/conversion/tests/import_declaration/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/import_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/import_declaration/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD b/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD +++ b/maldoca/js/ir/conversion/tests/interpreter_directive/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/labeled_statement/BUILD b/maldoca/js/ir/conversion/tests/labeled_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/labeled_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/labeled_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/literal/BUILD b/maldoca/js/ir/conversion/tests/literal/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/literal/BUILD +++ b/maldoca/js/ir/conversion/tests/literal/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD b/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD +++ b/maldoca/js/ir/conversion/tests/load_store_identifier/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/logical_expression/BUILD b/maldoca/js/ir/conversion/tests/logical_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/logical_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/logical_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/member_expression/BUILD b/maldoca/js/ir/conversion/tests/member_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/member_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/member_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/meta_property/BUILD b/maldoca/js/ir/conversion/tests/meta_property/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/meta_property/BUILD +++ b/maldoca/js/ir/conversion/tests/meta_property/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/new_expression/BUILD b/maldoca/js/ir/conversion/tests/new_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/new_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/new_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/object_expression/BUILD b/maldoca/js/ir/conversion/tests/object_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/object_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/object_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/object_pattern/BUILD b/maldoca/js/ir/conversion/tests/object_pattern/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/object_pattern/BUILD +++ b/maldoca/js/ir/conversion/tests/object_pattern/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD b/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/optional_member_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD b/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/parenthesized_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/switch_statement/BUILD b/maldoca/js/ir/conversion/tests/switch_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/switch_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/switch_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/tagged_template/BUILD b/maldoca/js/ir/conversion/tests/tagged_template/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/tagged_template/BUILD +++ b/maldoca/js/ir/conversion/tests/tagged_template/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/template/BUILD b/maldoca/js/ir/conversion/tests/template/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/template/BUILD +++ b/maldoca/js/ir/conversion/tests/template/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/throw_statement/BUILD b/maldoca/js/ir/conversion/tests/throw_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/throw_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/throw_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/try_statement/BUILD b/maldoca/js/ir/conversion/tests/try_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/try_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/try_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/unary_expression/BUILD b/maldoca/js/ir/conversion/tests/unary_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/unary_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/unary_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/update_expression/BUILD b/maldoca/js/ir/conversion/tests/update_expression/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/update_expression/BUILD +++ b/maldoca/js/ir/conversion/tests/update_expression/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/variable_declaration/BUILD b/maldoca/js/ir/conversion/tests/variable_declaration/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/variable_declaration/BUILD +++ b/maldoca/js/ir/conversion/tests/variable_declaration/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/while_statement/BUILD b/maldoca/js/ir/conversion/tests/while_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/while_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/while_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/tests/with_statement/BUILD b/maldoca/js/ir/conversion/tests/with_statement/BUILD index 44c720a..51e32be 100644 --- a/maldoca/js/ir/conversion/tests/with_statement/BUILD +++ b/maldoca/js/ir/conversion/tests/with_statement/BUILD @@ -18,13 +18,21 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) -glob_lit_tests( - name = "all_tests", - data = [ +filegroup( + name = "test_files", + srcs = [ "ast.json", "input.js", "jshir.mlir", "output.js", + ], + tags = ["ignore_srcs"], +) + +glob_lit_tests( + name = "all_tests", + data = [ + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/conversion/utils.cc b/maldoca/js/ir/conversion/utils.cc index 8bd8ca7..31f7ca6 100644 --- a/maldoca/js/ir/conversion/utils.cc +++ b/maldoca/js/ir/conversion/utils.cc @@ -15,6 +15,7 @@ #include "maldoca/js/ir/conversion/utils.h" #include +#include #include "mlir/Dialect/ControlFlow/IR/ControlFlow.h" #include "mlir/Dialect/Func/IR/FuncOps.h" @@ -40,17 +41,15 @@ absl::StatusOr> AstToJshirFile( nullptr); mlir::OpBuilder builder(&context); - AstToJsir ast_to_jsir(builder); - mlir::OwningOpRef hir_file = ast_to_jsir.VisitFile(&ast); + mlir::OwningOpRef hir_file = AstToJsir::VisitFile(builder, &ast); MALDOCA_RET_CHECK(mlir::verify(*hir_file).succeeded()); - return hir_file; + return std::move(hir_file); } absl::StatusOr> JshirFileToAst(JsirFileOp hir_file) { - JsirToAst jsir_to_ast; - return jsir_to_ast.VisitFile(hir_file); + return JsirToAst::VisitFile(hir_file); } void LoadNecessaryDialects(mlir::MLIRContext &context) { diff --git a/maldoca/js/ir/ir.cc b/maldoca/js/ir/ir.cc index 058c730..66644ae 100644 --- a/maldoca/js/ir/ir.cc +++ b/maldoca/js/ir/ir.cc @@ -14,6 +14,8 @@ #include "maldoca/js/ir/ir.h" +#include + // IWYU pragma: begin_keep #include "llvm/ADT/APSInt.h" @@ -32,6 +34,8 @@ #include "mlir/IR/OpDefinition.h" #include "mlir/IR/OpImplementation.h" #include "mlir/IR/Region.h" +#include "maldoca/js/quickjs/quickjs.h" +#include "quickjs/quickjs.h" // IWYU pragma: end_keep @@ -57,6 +61,10 @@ void maldoca::JsirDialect::initialize() { #define GET_ATTRDEF_LIST #include "maldoca/js/ir/jsir_attrs.cc.inc" >(); + + qjs_runtime = std::unique_ptr(JS_NewRuntime()); + qjs_context = std::unique_ptr( + JS_NewContext(qjs_runtime.get())); } void maldoca::JshirDialect::initialize() { @@ -75,21 +83,21 @@ void maldoca::JshirDialect::initialize() { mlir::Operation *maldoca::JsirDialect::materializeConstant( mlir::OpBuilder &builder, mlir::Attribute value, mlir::Type type, mlir::Location loc) { - return llvm::TypeSwitch(value) + return llvm::TypeSwitch(value) .Case([&](mlir::BoolAttr value) { - return builder.create(loc, value); + return JsirBooleanLiteralOp::create(builder, loc, value); }) .Case([&](mlir::FloatAttr value) { - return builder.create(loc, value, - /*extra=*/nullptr); + return JsirNumericLiteralOp::create(builder, loc, value, + /*extra=*/nullptr); }) .Case([&](mlir::StringAttr value) { - return builder.create(loc, value, - /*extra=*/nullptr); + return JsirStringLiteralOp::create(builder, loc, value, + /*extra=*/nullptr); }) .Case([&](JsirBigIntLiteralAttr value) { - return builder.create(loc, value.getValue(), - value.getExtra()); + return JsirBigIntLiteralOp::create(builder, loc, value.getValue(), + value.getExtra()); }) .Default([](mlir::Attribute value) { return nullptr; }); } diff --git a/maldoca/js/ir/jsir_dialect.td b/maldoca/js/ir/jsir_dialect.td index 9192f33..b14d0f2 100644 --- a/maldoca/js/ir/jsir_dialect.td +++ b/maldoca/js/ir/jsir_dialect.td @@ -25,6 +25,10 @@ def Jsir_Dialect : Dialect { let hasConstantMaterializer = 1; let useDefaultAttributePrinterParser = 1; let useDefaultTypePrinterParser = 1; + let extraClassDeclaration = [{ + std::unique_ptr qjs_runtime; + std::unique_ptr qjs_context; + }]; } // Base class for JSIR dialect types. diff --git a/maldoca/js/ir/jsir_gen.cc b/maldoca/js/ir/jsir_gen.cc index 2510dc1..8078edd 100644 --- a/maldoca/js/ir/jsir_gen.cc +++ b/maldoca/js/ir/jsir_gen.cc @@ -45,7 +45,7 @@ #include "maldoca/js/quickjs_babel/quickjs_babel.h" // Maps pass string to enum. -static auto *kStringToPassKind = +static auto* kStringToPassKind = new absl::flat_hash_map{ {"source2ast", maldoca::JsirPassKind::kSourceToAst}, {"ast2hir", maldoca::JsirPassKind::kAstToJshir}, @@ -75,7 +75,7 @@ ABSL_FLAG( std::vector, passes, {}, absl::StrCat("The passes to run. Available passes: ", []() -> std::string { std::vector available_passes; - for (const auto &[pass, pass_kind] : *kStringToPassKind) { + for (const auto& [pass, pass_kind] : *kStringToPassKind) { available_passes.push_back(pass); } return absl::StrJoin(available_passes, ", "); @@ -86,10 +86,11 @@ ABSL_FLAG(std::string, dynamic_prelude_path, "", "constant propagation."); ABSL_FLAG(std::vector, dynamic_prelude_functions, {}, "A list of functions to treat as builtins in the dynamic prelude."); +ABSL_FLAG(std::string, output_type, "", + "The output type. Can be '', 'ir', or 'analysis'."); namespace maldoca { - static JsirAnalysisConfig::DynamicConstantPropagation GetJsirDynamicConstantPropagationConfig() { std::string dynamic_prelude_path = absl::GetFlag(FLAGS_dynamic_prelude_path); @@ -114,7 +115,7 @@ GetJsirDynamicConstantPropagationConfig() { static std::optional StringToJsirAnalysisKind( absl::string_view kind) { - static const auto *kMap = + static const auto* kMap = new absl::flat_hash_map{ {"constant_propagation", JsirAnalysisConfig::kConstantPropagation}, }; @@ -160,7 +161,7 @@ static JsirAnalysisConfig GetJsirAnalysisConfig() { } // namespace maldoca -int main(int argc, char *argv[]) { +int main(int argc, char* argv[]) { absl::ParseCommandLine(argc, argv); auto input_file = absl::GetFlag(FLAGS_input_file); @@ -200,16 +201,19 @@ int main(int argc, char *argv[]) { std::cerr << output.status().ToString() << std::endl; return 1; } - - std::string output_file = absl::GetFlag(FLAGS_output_file); - if (!output_file.empty()) { - CHECK_OK(maldoca::SetFileContents(output_file, output->repr)); - } else { - std::cout << output->repr << std::endl; + auto type = absl::GetFlag(FLAGS_output_type); + if (type == "" || type == "ir") { + std::string output_file = absl::GetFlag(FLAGS_output_file); + if (!output_file.empty()) { + CHECK_OK(maldoca::SetFileContents(output_file, output->repr)); + } else { + std::cout << output->repr << std::endl; + } } - - for (const auto &analysis_output : output->analysis_outputs.outputs()) { - std::cout << DumpJsAnalysisOutput(*input, analysis_output) << std::endl; + if (type == "" || type == "analysis") { + for (const auto& analysis_output : output->analysis_outputs.outputs()) { + std::cout << DumpJsAnalysisOutput(*input, analysis_output) << std::endl; + } } return 0; diff --git a/maldoca/js/ir/jsir_gen_lib.cc b/maldoca/js/ir/jsir_gen_lib.cc index abe2d46..3820aa7 100644 --- a/maldoca/js/ir/jsir_gen_lib.cc +++ b/maldoca/js/ir/jsir_gen_lib.cc @@ -41,7 +41,7 @@ namespace maldoca { namespace { std::string DumpJsAstAnalysisResult(absl::string_view original_source, - const JsAstAnalysisResult &result) { + const JsAstAnalysisResult& result) { switch (result.kind_case()) { case JsAstAnalysisResult::KIND_NOT_SET: return ""; @@ -56,7 +56,7 @@ std::string DumpJsAstAnalysisResult(absl::string_view original_source, } std::string DumpJsirAnalysisResult(absl::string_view original_source, - const JsirAnalysisResult &result) { + const JsirAnalysisResult& result) { switch (result.kind_case()) { case JsirAnalysisResult::KIND_NOT_SET: return ""; @@ -68,7 +68,7 @@ std::string DumpJsirAnalysisResult(absl::string_view original_source, using ComputedConstant = JsirAnalysisResult::DynamicConstantPropagation::ComputedConstant; - auto formatter = [&](std::string *out, const ComputedConstant &constant) { + auto formatter = [&](std::string* out, const ComputedConstant& constant) { absl::StrAppendFormat( out, "From [%d, %d): `%s` -> `", constant.start_offset(), constant.end_offset(), @@ -122,7 +122,7 @@ std::string DumpJsirAnalysisResult(absl::string_view original_source, } // namespace std::string DumpJsAnalysisOutput(absl::string_view original_source, - const JsAnalysisOutput &output) { + const JsAnalysisOutput& output) { switch (output.kind_case()) { case JsAnalysisOutput::KIND_NOT_SET: LOG(FATAL) << "JsAnalysisOutput::KIND_NOT_SET"; @@ -134,9 +134,9 @@ std::string DumpJsAnalysisOutput(absl::string_view original_source, } absl::StatusOr JsirGen( - Babel &babel, absl::string_view source, - const std::vector &passes, JsirAnalysisConfig analysis_config, - const std::vector &transform_configs) { + Babel& babel, absl::string_view source, + const std::vector& passes, JsirAnalysisConfig analysis_config, + const std::vector& transform_configs) { mlir::MLIRContext mlir_context; LoadNecessaryDialects(mlir_context); @@ -307,11 +307,11 @@ absl::StatusOr JsirGen( } case JsirPassKind::kDynamicConstantPropagation: { - auto it = absl::c_find_if(transform_configs, [](const auto &config) { + auto it = absl::c_find_if(transform_configs, [](const auto& config) { return config.has_dynamic_constant_propagation(); }); MALDOCA_RET_CHECK(it != transform_configs.end()); - const JsirTransformConfig &transform = *it; + const JsirTransformConfig& transform = *it; *pass_configs.add_passes()->mutable_jsir_transform() = std::move(transform); @@ -350,9 +350,9 @@ absl::StatusOr JsirGen( } absl::StatusOr JsirGenHermetic( - absl::string_view source, const std::vector &passes, + absl::string_view source, const std::vector& passes, JsirAnalysisConfig analysis_config, - const std::vector &transform_configs) { + const std::vector& transform_configs) { QuickJsBabel babel; return maldoca::JsirGen(babel, source, passes, analysis_config, diff --git a/maldoca/js/ir/jsir_ops.cc b/maldoca/js/ir/jsir_ops.cc index 436772f..da8be7f 100644 --- a/maldoca/js/ir/jsir_ops.cc +++ b/maldoca/js/ir/jsir_ops.cc @@ -191,23 +191,23 @@ std::optional EmulateBinOp(std::string op, mlir::MLIRContext *context, mlir::Attribute mlir_left, mlir::Attribute mlir_right) { - std::unique_ptr qjs_runtime{JS_NewRuntime()}; - std::unique_ptr qjs_context{ - JS_NewContext(qjs_runtime.get())}; - auto left = MlirAttributeToQuickJsValue(qjs_context.get(), mlir_left); - auto right = MlirAttributeToQuickJsValue(qjs_context.get(), mlir_right); + JsirDialect* dialect = context->getOrLoadDialect(); + JSContext* qjs_context = dialect->qjs_context.get(); + + auto left = MlirAttributeToQuickJsValue(qjs_context, mlir_left); + auto right = MlirAttributeToQuickJsValue(qjs_context, mlir_right); if (!left.has_value() || !right.has_value()) { return std::nullopt; } - QjsValue bin_op_result = EmulateBinOp(qjs_context.get(), op, *left, *right); + QjsValue bin_op_result = EmulateBinOp(qjs_context, op, *left, *right); if (JS_IsException(bin_op_result.get())) { LOG(ERROR) << "evaluate_bin_op returned an exception?"; return std::nullopt; } - return QuickJsValueToMlirAttribute(qjs_context.get(), context, + return QuickJsValueToMlirAttribute(qjs_context, context, bin_op_result.get()); } @@ -241,33 +241,32 @@ QjsValue EmulateUnaryOp(JSContext *qjs_context, std::string op, std::optional EmulateUnaryOp(std::string op, mlir::MLIRContext *context, mlir::Attribute mlir_operand) { - std::unique_ptr qjs_runtime{JS_NewRuntime()}; - std::unique_ptr qjs_context{ - JS_NewContext(qjs_runtime.get())}; + JsirDialect* dialect = context->getOrLoadDialect(); + JSContext* qjs_context = dialect->qjs_context.get(); - auto expr = MlirAttributeToQuickJsValue(qjs_context.get(), mlir_operand); + auto expr = MlirAttributeToQuickJsValue(qjs_context, mlir_operand); if (!expr.has_value()) { return std::nullopt; } - QjsValue unary_op_result = EmulateUnaryOp(qjs_context.get(), op, *expr); + QjsValue unary_op_result = EmulateUnaryOp(qjs_context, op, *expr); if (JS_IsException(unary_op_result.get())) { LOG(ERROR) << "evaluate_unary_op returned an exception?"; return std::nullopt; } - return QuickJsValueToMlirAttribute(qjs_context.get(), context, + return QuickJsValueToMlirAttribute(qjs_context, context, unary_op_result.get()); } std::optional EmulateMemberAccessOp(mlir::MLIRContext *context, mlir::Attribute mlir_obj, mlir::Attribute mlir_key) { - std::unique_ptr qjs_runtime{JS_NewRuntime()}; - std::unique_ptr qjs_context{ - JS_NewContext(qjs_runtime.get())}; - QjsValue global{qjs_context.get(), JS_GetGlobalObject(qjs_context.get())}; + JsirDialect* dialect = context->getOrLoadDialect(); + JSContext* qjs_context = dialect->qjs_context.get(); + + QjsValue global{qjs_context, JS_GetGlobalObject(qjs_context)}; static constexpr absl::string_view kSource = R"js( function evaluate_member_access(a, b) { @@ -277,25 +276,25 @@ std::optional EmulateMemberAccessOp(mlir::MLIRContext *context, )js"; QjsValue evaluate_member_access{ - qjs_context.get(), - JS_Eval(qjs_context.get(), kSource.data(), kSource.length(), + qjs_context, + JS_Eval(qjs_context, kSource.data(), kSource.length(), "evaluate_member_access.js", JS_EVAL_TYPE_GLOBAL), }; - if (!JS_IsFunction(qjs_context.get(), evaluate_member_access.get())) { + if (!JS_IsFunction(qjs_context, evaluate_member_access.get())) { LOG(FATAL) << "evaluate_member_access is not a function?"; return std::nullopt; } - auto obj = MlirAttributeToQuickJsValue(qjs_context.get(), mlir_obj); - auto key = MlirAttributeToQuickJsValue(qjs_context.get(), mlir_key); + auto obj = MlirAttributeToQuickJsValue(qjs_context, mlir_obj); + auto key = MlirAttributeToQuickJsValue(qjs_context, mlir_key); if (!obj.has_value() || !key.has_value()) { return std::nullopt; } std::vector args = {obj->get(), key->get()}; QjsValue member_access_result{ - qjs_context.get(), - JS_Call(qjs_context.get(), evaluate_member_access.get(), global.get(), + qjs_context, + JS_Call(qjs_context, evaluate_member_access.get(), global.get(), args.size(), args.data()), }; @@ -304,7 +303,7 @@ std::optional EmulateMemberAccessOp(mlir::MLIRContext *context, return std::nullopt; } - return QuickJsValueToMlirAttribute(qjs_context.get(), context, + return QuickJsValueToMlirAttribute(qjs_context, context, member_access_result.get()); } diff --git a/maldoca/js/ir/transforms/constant_propagation/pass.cc b/maldoca/js/ir/transforms/constant_propagation/pass.cc index e295364..8269321 100644 --- a/maldoca/js/ir/transforms/constant_propagation/pass.cc +++ b/maldoca/js/ir/transforms/constant_propagation/pass.cc @@ -168,8 +168,8 @@ mlir::ChangeResult TransformInlineCall( param_values.push_back(param_value); } - call_expr_op->replaceAllUsesWith(builder.create( - call_expr_op.getLoc(), callee_value, param_values)); + call_expr_op->replaceAllUsesWith(JsirCallExpressionOp::create( + builder, call_expr_op.getLoc(), callee_value, param_values)); return mlir::ChangeResult::Change; } diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/BUILD.template b/maldoca/js/ir/transforms/constant_propagation/tests/BUILD.template index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/BUILD.template +++ b/maldoca/js/ir/transforms/constant_propagation/tests/BUILD.template @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/if/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/if_join/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/if_join/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/simple/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/simple_symbol/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/string_member_expression/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/void_0/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/void_0/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/constant_propagation/tests/while/BUILD b/maldoca/js/ir/transforms/constant_propagation/tests/while/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/constant_propagation/tests/while/BUILD +++ b/maldoca/js/ir/transforms/constant_propagation/tests/while/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ 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 b0b70b2..ffda4bd 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 @@ -316,7 +316,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0xacf810", 1834, 1843, 8, "_0xacf810">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0xacf810", 1834, 1843, 8, "_0xacf810">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -394,7 +394,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x29c472", 1988, 1997, 10, "_0x29c472">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x29c472", 1988, 1997, 10, "_0x29c472">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -527,7 +527,7 @@ // SOURCE-NEXT: // %105 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %106 = jsir.identifier {"_0x29c472"} -// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir_builtin, 3.010000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir_builtin, 3.010000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %107 = jsir.numeric_literal {#jsir, 7.290000e+02 : f64} // SOURCE-NEXT: // %107 = 7.290000e+02 : f64 @@ -618,7 +618,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x24d832", 2437, 2446, 13, "_0x24d832">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x24d832", 2437, 2446, 13, "_0x24d832">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -645,7 +645,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %134 = jsir.identifier {"_0x29c472"} -// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir_builtin, 3.010000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir_builtin, 3.010000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %135 = jsir.identifier {"_0x5a8af9"} // SOURCE-NEXT: // %135 = @@ -709,7 +709,7 @@ // SOURCE-NEXT: // %121 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %122 = jsir.identifier {"_0x24d832"} -// SOURCE-NEXT: // %122 = #jsir_builtin, #jsir_builtin, 3.630000e+02 : f64, "-">, #jsir_builtin, 4.090000e+02 : f64, "-">, #jsir, #jsir_builtin, #jsir_builtin, "-">>> +// SOURCE-NEXT: // %122 = #jsir_builtin, #jsir_builtin, 3.630000e+02 : f64, "-">, #jsir_builtin, 4.090000e+02 : f64, "-">, #jsir, #jsir_builtin, #jsir_builtin, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %123 = jsir.numeric_literal {#jsir, 5.880000e+02 : f64} // SOURCE-NEXT: // %123 = 5.880000e+02 : f64 @@ -824,7 +824,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x15f3bc", 2842, 2851, 16, "_0x15f3bc">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x15f3bc", 2842, 2851, 16, "_0x15f3bc">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -851,7 +851,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %146 = jsir.identifier {"_0x24d832"} -// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir_builtin, 3.630000e+02 : f64, "-">, #jsir_builtin, 4.090000e+02 : f64, "-">, #jsir, #jsir_builtin, #jsir_builtin, "-">>> +// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir_builtin, 3.630000e+02 : f64, "-">, #jsir_builtin, 4.090000e+02 : f64, "-">, #jsir, #jsir_builtin, #jsir_builtin, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %147 = jsir.identifier {"_0x4c796c"} // SOURCE-NEXT: // %147 = @@ -918,7 +918,7 @@ // SOURCE-NEXT: // %152 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %153 = jsir.identifier {"_0x15f3bc"} -// SOURCE-NEXT: // %153 = #jsir_builtin, #jsir_builtin, 1.756000e+03 : f64, "-">, #jsir, #jsir_builtin, 5.400000e+01 : f64, "-">, #jsir_builtin, 4.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %153 = #jsir_builtin, #jsir_builtin, 1.756000e+03 : f64, "-">, #jsir, #jsir_builtin, 5.400000e+01 : f64, "-">, #jsir_builtin, 4.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %154 = jsir.numeric_literal {#jsir, 1.195000e+03 : f64} // SOURCE-NEXT: // %154 = 1.195000e+03 : f64 @@ -1132,7 +1132,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %118 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %119 = jsir.object_property (%118) {#jsir, , 3459, 3466, 19, "syuJq", "'syuJq'", "syuJq">, false} +// SOURCE-NEXT: %119 = jsir.object_property (%118) {#jsir, , 3459, 3466, 19, "syuJq", "'syuJq'", "syuJq">, false} // SOURCE-NEXT: // %119 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.function_expression {false, false} ({ @@ -1175,17 +1175,17 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %120 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %121 = jsir.object_property (%120) {#jsir, , 3581, 3588, 19, "nZJPO", "'nZJPO'", "nZJPO">, false} +// SOURCE-NEXT: %121 = jsir.object_property (%120) {#jsir, , 3581, 3588, 19, "nZJPO", "'nZJPO'", "nZJPO">, false} // SOURCE-NEXT: // %121 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %122 = jsir.string_literal {#jsir, "ajsZf"} // SOURCE-NEXT: // %122 = "ajsZf" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %123 = jsir.object_property (%122) {#jsir, , 3705, 3712, 19, "iQdRz", "'iQdRz'", "iQdRz">, false} +// SOURCE-NEXT: %123 = jsir.object_property (%122) {#jsir, , 3705, 3712, 19, "iQdRz", "'iQdRz'", "iQdRz">, false} // SOURCE-NEXT: // %123 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %124 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %124 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %124 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %125 = jsir.numeric_literal {#jsir, 5.170000e+02 : f64} // SOURCE-NEXT: // %125 = 5.170000e+02 : f64 @@ -1202,7 +1202,7 @@ // SOURCE-NEXT: %129 = jsir.call_expression (%124, %125, %126, %127, %128) // SOURCE-NEXT: // %129 = "LVBjR" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %130 = jsir.object_property (%129) {#jsir, , 3737, 3744, 19, "IPWWb", "'IPWWb'", "IPWWb">, false} +// SOURCE-NEXT: %130 = jsir.object_property (%129) {#jsir, , 3737, 3744, 19, "IPWWb", "'IPWWb'", "IPWWb">, false} // SOURCE-NEXT: // %130 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %131 = jsir.function_expression {false, false} ({ @@ -1245,7 +1245,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %131 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %132 = jsir.object_property (%131) {#jsir, , 3799, 3806, 19, "JqNej", "'JqNej'", "JqNej">, false} +// SOURCE-NEXT: %132 = jsir.object_property (%131) {#jsir, , 3799, 3806, 19, "JqNej", "'JqNej'", "JqNej">, false} // SOURCE-NEXT: // %132 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %133 = jsir.function_expression {false, false} ({ @@ -1288,11 +1288,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %133 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %134 = jsir.object_property (%133) {#jsir, , 3920, 3927, 19, "RxDWL", "'RxDWL'", "RxDWL">, false} +// SOURCE-NEXT: %134 = jsir.object_property (%133) {#jsir, , 3920, 3927, 19, "RxDWL", "'RxDWL'", "RxDWL">, false} // SOURCE-NEXT: // %134 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %135 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %136 = jsir.numeric_literal {#jsir, 9.490000e+02 : f64} // SOURCE-NEXT: // %136 = 9.490000e+02 : f64 @@ -1310,7 +1310,7 @@ // SOURCE-NEXT: // %140 = "return (fu" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %141 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %141 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %141 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %142 = jsir.numeric_literal {#jsir, 8.890000e+02 : f64} // SOURCE-NEXT: // %142 = 8.890000e+02 : f64 @@ -1330,14 +1330,14 @@ // SOURCE-NEXT: %147 = jsir.binary_expression (%140, %146) {"+"} // SOURCE-NEXT: // %147 = "return (function() " // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %148 = jsir.object_property (%147) {#jsir, , 4042, 4049, 19, "ihWZS", "'ihWZS'", "ihWZS">, false} +// SOURCE-NEXT: %148 = jsir.object_property (%147) {#jsir, , 4042, 4049, 19, "ihWZS", "'ihWZS'", "ihWZS">, false} // SOURCE-NEXT: // %148 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %149 = jsir.string_literal {#jsir, "{}.constru"} // SOURCE-NEXT: // %149 = "{}.constru" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %150 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %150 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %150 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %151 = jsir.numeric_literal {#jsir, 9.400000e+02 : f64} // SOURCE-NEXT: // %151 = 9.400000e+02 : f64 @@ -1369,7 +1369,7 @@ // SOURCE-NEXT: %160 = jsir.binary_expression (%158, %159) {"+"} // SOURCE-NEXT: // %160 = "{}.constructor(\22return this\22)( )" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %161 = jsir.object_property (%160) {#jsir, , 4144, 4151, 19, "tfQnO", "'tfQnO'", "tfQnO">, false} +// SOURCE-NEXT: %161 = jsir.object_property (%160) {#jsir, , 4144, 4151, 19, "tfQnO", "'tfQnO'", "tfQnO">, false} // SOURCE-NEXT: // %161 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %162 = jsir.function_expression {false, false} ({ @@ -1412,11 +1412,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %162 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %163 = jsir.object_property (%162) {#jsir, , 4252, 4259, 19, "JCsly", "'JCsly'", "JCsly">, false} +// SOURCE-NEXT: %163 = jsir.object_property (%162) {#jsir, , 4252, 4259, 19, "JCsly", "'JCsly'", "JCsly">, false} // SOURCE-NEXT: // %163 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %164 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %164 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %164 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %165 = jsir.numeric_literal {#jsir, 4.950000e+02 : f64} // SOURCE-NEXT: // %165 = 4.950000e+02 : f64 @@ -1433,7 +1433,7 @@ // SOURCE-NEXT: %169 = jsir.call_expression (%164, %165, %166, %167, %168) // SOURCE-NEXT: // %169 = "BUbjB" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %170 = jsir.object_property (%169) {#jsir, , 4376, 4383, 19, "bfMPq", "'bfMPq'", "bfMPq">, false} +// SOURCE-NEXT: %170 = jsir.object_property (%169) {#jsir, , 4376, 4383, 19, "bfMPq", "'bfMPq'", "bfMPq">, false} // SOURCE-NEXT: // %170 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %171 = jsir.function_expression {false, false} ({ @@ -1482,11 +1482,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %171 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %172 = jsir.object_property (%171) {#jsir, , 4438, 4445, 19, "BFaCv", "'BFaCv'", "BFaCv">, false} +// SOURCE-NEXT: %172 = jsir.object_property (%171) {#jsir, , 4438, 4445, 19, "BFaCv", "'BFaCv'", "BFaCv">, false} // SOURCE-NEXT: // %172 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %173 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %173 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %173 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %174 = jsir.numeric_literal {#jsir, 8.730000e+02 : f64} // SOURCE-NEXT: // %174 = 8.730000e+02 : f64 @@ -1503,7 +1503,7 @@ // SOURCE-NEXT: %178 = jsir.call_expression (%173, %174, %175, %176, %177) // SOURCE-NEXT: // %178 = "callable" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %179 = jsir.object_property (%178) {#jsir, , 4581, 4588, 19, "IKNzV", "'IKNzV'", "IKNzV">, false} +// SOURCE-NEXT: %179 = jsir.object_property (%178) {#jsir, , 4581, 4588, 19, "IKNzV", "'IKNzV'", "IKNzV">, false} // SOURCE-NEXT: // %179 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %180 = jsir.function_expression {false, false} ({ @@ -1540,11 +1540,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %180 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %181 = jsir.object_property (%180) {#jsir, , 4643, 4650, 19, "uXNCK", "'uXNCK'", "uXNCK">, false} +// SOURCE-NEXT: %181 = jsir.object_property (%180) {#jsir, , 4643, 4650, 19, "uXNCK", "'uXNCK'", "uXNCK">, false} // SOURCE-NEXT: // %181 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %182 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %182 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %182 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %183 = jsir.numeric_literal {#jsir, 4.890000e+02 : f64} // SOURCE-NEXT: // %183 = 4.890000e+02 : f64 @@ -1561,11 +1561,11 @@ // SOURCE-NEXT: %187 = jsir.call_expression (%182, %183, %184, %185, %186) // SOURCE-NEXT: // %187 = "info" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %188 = jsir.object_property (%187) {#jsir, , 4744, 4751, 19, "HQlLe", "'HQlLe'", "HQlLe">, false} +// SOURCE-NEXT: %188 = jsir.object_property (%187) {#jsir, , 4744, 4751, 19, "HQlLe", "'HQlLe'", "HQlLe">, false} // SOURCE-NEXT: // %188 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %189 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %189 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %189 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %190 = jsir.numeric_literal {#jsir, 9.800000e+02 : f64} // SOURCE-NEXT: // %190 = 9.800000e+02 : f64 @@ -1582,11 +1582,11 @@ // SOURCE-NEXT: %194 = jsir.call_expression (%189, %190, %191, %192, %193) // SOURCE-NEXT: // %194 = "exception" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %195 = jsir.object_property (%194) {#jsir, , 4806, 4813, 19, "ZYRdl", "'ZYRdl'", "ZYRdl">, false} +// SOURCE-NEXT: %195 = jsir.object_property (%194) {#jsir, , 4806, 4813, 19, "ZYRdl", "'ZYRdl'", "ZYRdl">, false} // SOURCE-NEXT: // %195 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %196 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %196 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %196 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %197 = jsir.numeric_literal {#jsir, 5.290000e+02 : f64} // SOURCE-NEXT: // %197 = 5.290000e+02 : f64 @@ -1603,11 +1603,11 @@ // SOURCE-NEXT: %201 = jsir.call_expression (%196, %197, %198, %199, %200) // SOURCE-NEXT: // %201 = "table" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %202 = jsir.object_property (%201) {#jsir, , 4868, 4875, 19, "esErA", "'esErA'", "esErA">, false} +// SOURCE-NEXT: %202 = jsir.object_property (%201) {#jsir, , 4868, 4875, 19, "esErA", "'esErA'", "esErA">, false} // SOURCE-NEXT: // %202 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %203 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %203 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %203 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %204 = jsir.numeric_literal {#jsir, 4.870000e+02 : f64} // SOURCE-NEXT: // %204 = 4.870000e+02 : f64 @@ -1624,7 +1624,7 @@ // SOURCE-NEXT: %208 = jsir.call_expression (%203, %204, %205, %206, %207) // SOURCE-NEXT: // %208 = "trace" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %209 = jsir.object_property (%208) {#jsir, , 4930, 4937, 19, "KMrmn", "'KMrmn'", "KMrmn">, false} +// SOURCE-NEXT: %209 = jsir.object_property (%208) {#jsir, , 4930, 4937, 19, "KMrmn", "'KMrmn'", "KMrmn">, false} // SOURCE-NEXT: // %209 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %210 = jsir.function_expression {false, false} ({ @@ -1667,7 +1667,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %210 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %211 = jsir.object_property (%210) {#jsir, , 4992, 4999, 19, "meuOR", "'meuOR'", "meuOR">, false} +// SOURCE-NEXT: %211 = jsir.object_property (%210) {#jsir, , 4992, 4999, 19, "meuOR", "'meuOR'", "meuOR">, false} // SOURCE-NEXT: // %211 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %212 = jsir.function_expression {false, false} ({ @@ -1710,13 +1710,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %212 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %213 = jsir.object_property (%212) {#jsir, , 5114, 5121, 19, "LqGSe", "'LqGSe'", "LqGSe">, false} +// SOURCE-NEXT: %213 = jsir.object_property (%212) {#jsir, , 5114, 5121, 19, "LqGSe", "'LqGSe'", "LqGSe">, false} // SOURCE-NEXT: // %213 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %214 = jsir.string_literal {#jsir, "stwZs"} // SOURCE-NEXT: // %214 = "stwZs" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %215 = jsir.object_property (%214) {#jsir, , 5238, 5245, 19, "ZJayL", "'ZJayL'", "ZJayL">, false} +// SOURCE-NEXT: %215 = jsir.object_property (%214) {#jsir, , 5238, 5245, 19, "ZJayL", "'ZJayL'", "ZJayL">, false} // SOURCE-NEXT: // %215 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.exprs_region_end (%119, %121, %123, %130, %132, %134, %148, %161, %163, %170, %172, %179, %181, %188, %195, %202, %209, %211, %213, %215) @@ -1744,7 +1744,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x55557e", 5317, 5326, 30, "_0x55557e">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x55557e", 5317, 5326, 30, "_0x55557e">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1771,7 +1771,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %143 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %144 = jsir.identifier {"_0x5bb5d0"} // SOURCE-NEXT: // %144 = @@ -1819,7 +1819,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x7fdc4d", 5515, 5524, 31, "_0x7fdc4d">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x7fdc4d", 5515, 5524, 31, "_0x7fdc4d">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1846,7 +1846,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %143 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %144 = jsir.identifier {"_0x3759df"} // SOURCE-NEXT: // %144 = @@ -1892,10 +1892,10 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %118 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %118 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %118 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %119 = jsir.identifier {"_0x55557e"} -// SOURCE-NEXT: // %119 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 3.670000e+02 : f64, "-">, #jsir, #jsir_builtin, 1.110000e+02 : f64, "-">>> +// SOURCE-NEXT: // %119 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 3.670000e+02 : f64, "-">, #jsir, #jsir_builtin, 1.110000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.numeric_literal {#jsir, 3.450000e+02 : f64} // SOURCE-NEXT: // %120 = 3.450000e+02 : f64 @@ -1913,13 +1913,13 @@ // SOURCE-NEXT: // %124 = "nZJPO" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %125 = jsir.member_expression (%118, %124) -// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "===">> +// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "===">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %126 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %126 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %126 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %127 = jsir.identifier {"_0x55557e"} -// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 3.670000e+02 : f64, "-">, #jsir, #jsir_builtin, 1.110000e+02 : f64, "-">>> +// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 3.670000e+02 : f64, "-">, #jsir, #jsir_builtin, 1.110000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.numeric_literal {#jsir, 2.890000e+02 : f64} // SOURCE-NEXT: // %128 = 2.890000e+02 : f64 @@ -1940,10 +1940,10 @@ // SOURCE-NEXT: // %133 = "ajsZf" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %134 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %135 = jsir.identifier {"_0x7fdc4d"} -// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %136 = jsir.numeric_literal {#jsir, 1.228000e+03 : f64} // SOURCE-NEXT: // %136 = 1.228000e+03 : f64 @@ -2210,10 +2210,10 @@ // SOURCE-NEXT: // %144 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %145 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %145 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %145 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %146 = jsir.identifier {"_0x7fdc4d"} -// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %147 = jsir.numeric_literal {#jsir, 1.281000e+03 : f64} // SOURCE-NEXT: // %147 = 1.281000e+03 : f64 @@ -2231,16 +2231,16 @@ // SOURCE-NEXT: // %151 = "JqNej" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %152 = jsir.member_expression (%145, %151) -// SOURCE-NEXT: // %152 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %152 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %153 = jsir.identifier {"Function"} // SOURCE-NEXT: // %153 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %154 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %154 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %154 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %155 = jsir.identifier {"_0x7fdc4d"} -// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %156 = jsir.numeric_literal {#jsir, 1.289000e+03 : f64} // SOURCE-NEXT: // %156 = 1.289000e+03 : f64 @@ -2258,13 +2258,13 @@ // SOURCE-NEXT: // %160 = "RxDWL" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %161 = jsir.member_expression (%154, %160) -// SOURCE-NEXT: // %161 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %161 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %162 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %162 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %162 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %163 = jsir.identifier {"_0x7fdc4d"} -// SOURCE-NEXT: // %163 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %163 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %164 = jsir.numeric_literal {#jsir, 1.208000e+03 : f64} // SOURCE-NEXT: // %164 = 1.208000e+03 : f64 @@ -2282,13 +2282,13 @@ // SOURCE-NEXT: // %168 = "syuJq" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %169 = jsir.member_expression (%162, %168) -// SOURCE-NEXT: // %169 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %169 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %170 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %170 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %170 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %171 = jsir.identifier {"_0x7fdc4d"} -// SOURCE-NEXT: // %171 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> +// SOURCE-NEXT: // %171 = #jsir_builtin, #jsir, #jsir_builtin, 4.770000e+02 : f64, "-">, #jsir_builtin, 2.570000e+02 : f64, "-">, #jsir_builtin, 3.310000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %172 = jsir.numeric_literal {#jsir, 1.261000e+03 : f64} // SOURCE-NEXT: // %172 = 1.261000e+03 : f64 @@ -2309,7 +2309,7 @@ // SOURCE-NEXT: // %177 = "return (function() " // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %178 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %178 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %178 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %179 = jsir.string_literal {#jsir, "tfQnO"} // SOURCE-NEXT: // %179 = "tfQnO" @@ -2558,10 +2558,10 @@ // SOURCE-NEXT: // %106 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %107 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %107 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %107 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %108 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.numeric_literal {#jsir, 9.510000e+02 : f64} // SOURCE-NEXT: // %109 = 9.510000e+02 : f64 @@ -2579,7 +2579,7 @@ // SOURCE-NEXT: // %113 = "uXNCK" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %114 = jsir.member_expression (%107, %113) -// SOURCE-NEXT: // %114 = #jsir_builtin, >> +// SOURCE-NEXT: // %114 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.identifier {"_0x55cf6f"} // SOURCE-NEXT: // %115 = @@ -2594,7 +2594,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x30145a", 7316, 7325, 37, "_0x30145a">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x30145a", 7316, 7325, 37, "_0x30145a">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2659,7 +2659,7 @@ // SOURCE-NEXT: // %101 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %102 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.numeric_literal {#jsir, 9.220000e+02 : f64} // SOURCE-NEXT: // %103 = 9.220000e+02 : f64 @@ -2683,7 +2683,7 @@ // SOURCE-NEXT: // %109 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %110 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %110 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %111 = jsir.numeric_literal {#jsir, 4.730000e+02 : f64} // SOURCE-NEXT: // %111 = 4.730000e+02 : f64 @@ -2731,7 +2731,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x51073b", 7582, 7591, 38, "_0x51073b">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x51073b", 7582, 7591, 38, "_0x51073b">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -2796,7 +2796,7 @@ // SOURCE-NEXT: // %101 = "log" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %102 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.numeric_literal {#jsir, 4.840000e+02 : f64} // SOURCE-NEXT: // %103 = 4.840000e+02 : f64 @@ -2814,10 +2814,10 @@ // SOURCE-NEXT: // %107 = "warn" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %108 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.numeric_literal {#jsir, 4.750000e+02 : f64} // SOURCE-NEXT: // %110 = 4.750000e+02 : f64 @@ -2841,10 +2841,10 @@ // SOURCE-NEXT: // %116 = "error" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %117 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %117 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %117 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %118 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %118 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %118 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %119 = jsir.numeric_literal {#jsir, 9.570000e+02 : f64} // SOURCE-NEXT: // %119 = 9.570000e+02 : f64 @@ -2865,7 +2865,7 @@ // SOURCE-NEXT: // %124 = "exception" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %125 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %126 = jsir.string_literal {#jsir, "esErA"} // SOURCE-NEXT: // %126 = "esErA" @@ -2874,10 +2874,10 @@ // SOURCE-NEXT: // %127 = "table" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %129 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %130 = jsir.numeric_literal {#jsir, 8.850000e+02 : f64} // SOURCE-NEXT: // %130 = 8.850000e+02 : f64 @@ -2969,13 +2969,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %100 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %100 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %100 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %101 = jsir.string_literal {#jsir, "meuOR"} // SOURCE-NEXT: // %101 = "meuOR" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %102 = jsir.member_expression (%100, %101) -// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "<">> +// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "<">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.identifier {"_0x36145e"} // SOURCE-NEXT: // %103 = @@ -2984,7 +2984,7 @@ // SOURCE-NEXT: // %104 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %105 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %105 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %105 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %106 = jsir.numeric_literal {#jsir, 4.860000e+02 : f64} // SOURCE-NEXT: // %106 = 4.860000e+02 : f64 @@ -3030,16 +3030,16 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %100 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %100 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %100 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %101 = jsir.string_literal {#jsir, "LqGSe"} // SOURCE-NEXT: // %101 = "LqGSe" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %102 = jsir.member_expression (%100, %101) -// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "!==">> +// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "!==">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %104 = jsir.numeric_literal {#jsir, 5.080000e+02 : f64} // SOURCE-NEXT: // %104 = 5.080000e+02 : f64 @@ -3057,7 +3057,7 @@ // SOURCE-NEXT: // %108 = "thXxj" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.identifier {"_0x5464bf"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, "+">>, "nZJPO", #jsir_builtin, #jsir, "===">>, "iQdRz", "ajsZf", "IPWWb", #jsir_builtin, 5.170000e+02 : f64, 5.020000e+02 : f64, 5.410000e+02 : f64, 4.950000e+02 : f64>, "JqNej", #jsir_builtin, #jsir>>, "RxDWL", #jsir_builtin, #jsir, "+">>, "ihWZS", #jsir_builtin, 9.490000e+02 : f64, 9.980000e+02 : f64, 9.270000e+02 : f64, 9.600000e+02 : f64>, #jsir_builtin, 8.890000e+02 : f64, 9.050000e+02 : f64, 9.300000e+02 : f64, 9.070000e+02 : f64>, "+">, "tfQnO", #jsir_builtin, 9.400000e+02 : f64, 9.210000e+02 : f64, 9.590000e+02 : f64, 9.530000e+02 : f64>, "+">, "rn this\22)(", "+">, " )", "+">, "JCsly", #jsir_builtin, #jsir, "!==">>, "bfMPq", #jsir_builtin, 4.950000e+02 : f64, 4.610000e+02 : f64, 4.910000e+02 : f64, 4.910000e+02 : f64>, "BFaCv", #jsir_builtin, #jsir, #jsir>>, "IKNzV", #jsir_builtin, 8.730000e+02 : f64, 8.780000e+02 : f64, 8.770000e+02 : f64, 9.110000e+02 : f64>, "uXNCK", #jsir_builtin, >>, "HQlLe", #jsir_builtin, 4.890000e+02 : f64, 5.250000e+02 : f64, 4.580000e+02 : f64, 5.220000e+02 : f64>, "ZYRdl", #jsir_builtin, 9.800000e+02 : f64, 9.900000e+02 : f64, 9.470000e+02 : f64, 9.500000e+02 : f64>, "esErA", #jsir_builtin, 5.290000e+02 : f64, 5.050000e+02 : f64, 5.440000e+02 : f64, 5.660000e+02 : f64>, "KMrmn", #jsir_builtin, 4.870000e+02 : f64, 4.850000e+02 : f64, 5.210000e+02 : f64, 4.800000e+02 : f64>, "meuOR", #jsir_builtin, #jsir, "<">>, "LqGSe", #jsir_builtin, #jsir, "!==">>, "ZJayL", "stwZs"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.string_literal {#jsir, "ZJayL"} // SOURCE-NEXT: // %110 = "ZJayL" @@ -3087,7 +3087,7 @@ // SOURCE-NEXT: // %160 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %161 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %161 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %161 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %162 = jsir.numeric_literal {#jsir, 9.130000e+02 : f64} // SOURCE-NEXT: // %162 = 9.130000e+02 : f64 @@ -3114,7 +3114,7 @@ // SOURCE-NEXT: // %169 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %170 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %170 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %170 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %171 = jsir.numeric_literal {#jsir, 4.710000e+02 : f64} // SOURCE-NEXT: // %171 = 4.710000e+02 : f64 @@ -3135,7 +3135,7 @@ // SOURCE-NEXT: // %176 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %177 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %177 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %177 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %178 = jsir.numeric_literal {#jsir, 9.580000e+02 : f64} // SOURCE-NEXT: // %178 = 9.580000e+02 : f64 @@ -3214,7 +3214,7 @@ // SOURCE-NEXT: // %113 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %114 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.numeric_literal {#jsir, 8.930000e+02 : f64} // SOURCE-NEXT: // %115 = 8.930000e+02 : f64 @@ -3238,7 +3238,7 @@ // SOURCE-NEXT: // %121 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %122 = jsir.identifier {"_0x30145a"} -// SOURCE-NEXT: // %122 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %122 = #jsir_builtin, #jsir_builtin, 5.180000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %123 = jsir.numeric_literal {#jsir, 9.600000e+02 : f64} // SOURCE-NEXT: // %123 = 9.600000e+02 : f64 @@ -3271,7 +3271,7 @@ // SOURCE-NEXT: // %132 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %133 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %133 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %133 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %134 = jsir.numeric_literal {#jsir, 4.910000e+02 : f64} // SOURCE-NEXT: // %134 = 4.910000e+02 : f64 @@ -3301,7 +3301,7 @@ // SOURCE-NEXT: // %142 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %143 = jsir.identifier {"_0x51073b"} -// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %143 = #jsir_builtin, #jsir_builtin, 7.000000e+01 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %144 = jsir.numeric_literal {#jsir, 5.030000e+02 : f64} // SOURCE-NEXT: // %144 = 5.030000e+02 : f64 @@ -3557,7 +3557,7 @@ // SOURCE-NEXT: // %90 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %91 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %92 = jsir.numeric_literal {#jsir, 1.284000e+03 : f64} // SOURCE-NEXT: // %92 = 1.284000e+03 : f64 @@ -3590,7 +3590,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x40ee28", 9293, 9302, 43, "_0x40ee28">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x40ee28", 9293, 9302, 43, "_0x40ee28">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -3688,7 +3688,7 @@ // SOURCE-NEXT: // %3 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %4 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %4 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %4 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %5 = jsir.numeric_literal {#jsir, 2.860000e+02 : f64} // SOURCE-NEXT: // %5 = 2.860000e+02 : f64 @@ -3752,7 +3752,7 @@ // SOURCE-NEXT: // %13 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %14 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %15 = jsir.numeric_literal {#jsir, 3.240000e+02 : f64} // SOURCE-NEXT: // %15 = 3.240000e+02 : f64 @@ -3782,7 +3782,7 @@ // SOURCE-NEXT: // %23 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %24 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %25 = jsir.numeric_literal {#jsir, 1.344000e+03 : f64} // SOURCE-NEXT: // %25 = 1.344000e+03 : f64 @@ -3800,7 +3800,7 @@ // SOURCE-NEXT: // %29 = "__ initial" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %30 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %30 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %30 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %31 = jsir.numeric_literal {#jsir, 3.280000e+02 : f64} // SOURCE-NEXT: // %31 = 3.280000e+02 : f64 @@ -3821,7 +3821,7 @@ // SOURCE-NEXT: // %36 = "__ initialize @babel" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %38 = jsir.numeric_literal {#jsir, 1.364000e+03 : f64} // SOURCE-NEXT: // %38 = 1.364000e+03 : f64 @@ -3842,7 +3842,7 @@ // SOURCE-NEXT: // %43 = "__ initialize @babel/core cjs " // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %44 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %45 = jsir.numeric_literal {#jsir, 3.280000e+02 : f64} // SOURCE-NEXT: // %45 = 3.280000e+02 : f64 @@ -3872,7 +3872,7 @@ // SOURCE-NEXT: // %53 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %54 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %54 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %54 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %55 = jsir.numeric_literal {#jsir, 3.190000e+02 : f64} // SOURCE-NEXT: // %55 = 3.190000e+02 : f64 @@ -3896,7 +3896,7 @@ // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %62 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %63 = jsir.numeric_literal {#jsir, 1.307000e+03 : f64} // SOURCE-NEXT: // %63 = 1.307000e+03 : f64 @@ -3914,7 +3914,7 @@ // SOURCE-NEXT: // %67 = "./package." // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %68 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %69 = jsir.numeric_literal {#jsir, 3.260000e+02 : f64} // SOURCE-NEXT: // %69 = 3.260000e+02 : f64 @@ -3938,7 +3938,7 @@ // SOURCE-NEXT: // %75 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %76 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %76 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %76 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %77 = jsir.numeric_literal {#jsir, 3.170000e+02 : f64} // SOURCE-NEXT: // %77 = 3.170000e+02 : f64 @@ -3974,7 +3974,7 @@ // SOURCE-NEXT: // %89 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %90 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %90 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %90 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %91 = jsir.numeric_literal {#jsir, 2.490000e+02 : f64} // SOURCE-NEXT: // %91 = 2.490000e+02 : f64 @@ -3998,7 +3998,7 @@ // SOURCE-NEXT: // %97 = "createConfigItem" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %98 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %98 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %98 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %99 = jsir.numeric_literal {#jsir, 2.960000e+02 : f64} // SOURCE-NEXT: // %99 = 2.960000e+02 : f64 @@ -4031,7 +4031,7 @@ // SOURCE-NEXT: // %108 = "loadOptions" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.numeric_literal {#jsir, 2.980000e+02 : f64} // SOURCE-NEXT: // %110 = 2.980000e+02 : f64 @@ -4049,7 +4049,7 @@ // SOURCE-NEXT: // %114 = "transform" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %115 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %115 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %116 = jsir.numeric_literal {#jsir, 1.394000e+03 : f64} // SOURCE-NEXT: // %116 = 1.394000e+03 : f64 @@ -4067,7 +4067,7 @@ // SOURCE-NEXT: // %120 = "transformF" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %121 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %121 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %122 = jsir.numeric_literal {#jsir, 2.940000e+02 : f64} // SOURCE-NEXT: // %122 = 2.940000e+02 : f64 @@ -4088,7 +4088,7 @@ // SOURCE-NEXT: // %127 = "transformFile" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %129 = jsir.numeric_literal {#jsir, 3.050000e+02 : f64} // SOURCE-NEXT: // %129 = 3.050000e+02 : f64 @@ -4112,7 +4112,7 @@ // SOURCE-NEXT: // %135 = "transformFromAst" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %136 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %136 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %136 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %137 = jsir.numeric_literal {#jsir, 2.430000e+02 : f64} // SOURCE-NEXT: // %137 = 2.430000e+02 : f64 @@ -4139,7 +4139,7 @@ // SOURCE-NEXT: // %144 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %145 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %145 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %145 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %146 = jsir.numeric_literal {#jsir, 2.880000e+02 : f64} // SOURCE-NEXT: // %146 = 2.880000e+02 : f64 @@ -4157,7 +4157,7 @@ // SOURCE-NEXT: // %150 = "buildExter" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %151 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %151 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %151 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %152 = jsir.numeric_literal {#jsir, 1.342000e+03 : f64} // SOURCE-NEXT: // %152 = 1.342000e+03 : f64 @@ -4181,7 +4181,7 @@ // SOURCE-NEXT: // %158 = "types" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %159 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %159 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %159 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %160 = jsir.numeric_literal {#jsir, 1.392000e+03 : f64} // SOURCE-NEXT: // %160 = 1.392000e+03 : f64 @@ -4199,7 +4199,7 @@ // SOURCE-NEXT: // %164 = "tokTypes" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %165 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %165 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %165 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %166 = jsir.numeric_literal {#jsir, 3.370000e+02 : f64} // SOURCE-NEXT: // %166 = 3.370000e+02 : f64 @@ -4217,7 +4217,7 @@ // SOURCE-NEXT: // %170 = "traverse" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %171 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %171 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %171 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %172 = jsir.numeric_literal {#jsir, 2.940000e+02 : f64} // SOURCE-NEXT: // %172 = 2.940000e+02 : f64 @@ -4250,7 +4250,7 @@ // 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: jshir.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 = ] { } @@ -4287,7 +4287,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x924763", 12680, 12689, 52, "_0x924763">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x924763", 12680, 12689, 52, "_0x924763">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4314,7 +4314,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %130 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %131 = jsir.identifier {"_0x1e890b"} // SOURCE-NEXT: // %131 = @@ -4363,7 +4363,7 @@ // SOURCE-NEXT: // %119 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.identifier {"_0x924763"} -// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 4.610000e+02 : f64, "-">, #jsir_builtin, 1.110000e+02 : f64, "-">, #jsir_builtin, 5.920000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 4.610000e+02 : f64, "-">, #jsir_builtin, 1.110000e+02 : f64, "-">, #jsir_builtin, 5.920000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.numeric_literal {#jsir, 8.920000e+02 : f64} // SOURCE-NEXT: // %121 = 8.920000e+02 : f64 @@ -4447,7 +4447,7 @@ // SOURCE-NEXT: // %95 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %96 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %96 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %96 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %97 = jsir.numeric_literal {#jsir, 1.315000e+03 : f64} // SOURCE-NEXT: // %97 = 1.315000e+03 : f64 @@ -4490,7 +4490,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0xbabec0", 13059, 13068, 55, "_0xbabec0">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0xbabec0", 13059, 13068, 55, "_0xbabec0">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4517,7 +4517,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %130 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %131 = jsir.identifier {"_0x142239"} // SOURCE-NEXT: // %131 = @@ -4562,7 +4562,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x38639b", 13233, 13242, 56, "_0x38639b">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x38639b", 13233, 13242, 56, "_0x38639b">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4589,7 +4589,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %130 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %131 = jsir.identifier {"_0x370158"} // SOURCE-NEXT: // %131 = @@ -4641,7 +4641,7 @@ // SOURCE-NEXT: // %119 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.identifier {"_0x38639b"} -// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 5.700000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 4.490000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 5.700000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 4.490000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.numeric_literal {#jsir, 3.840000e+02 : f64} // SOURCE-NEXT: // %121 = 3.840000e+02 : f64 @@ -4675,7 +4675,7 @@ // SOURCE-NEXT: // %131 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %132 = jsir.identifier {"_0x38639b"} -// SOURCE-NEXT: // %132 = #jsir_builtin, #jsir_builtin, 5.700000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 4.490000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %132 = #jsir_builtin, #jsir_builtin, 5.700000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 4.490000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %133 = jsir.numeric_literal {#jsir, 3.200000e+02 : f64} // SOURCE-NEXT: // %133 = 3.200000e+02 : f64 @@ -4736,7 +4736,7 @@ // SOURCE-NEXT: // %107 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %108 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %108 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.numeric_literal {#jsir, 2.610000e+02 : f64} // SOURCE-NEXT: // %109 = 2.610000e+02 : f64 @@ -4806,7 +4806,7 @@ // SOURCE-NEXT: // %119 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.identifier {"_0x42f460"} -// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.numeric_literal {#jsir, 2.420000e+02 : f64} // SOURCE-NEXT: // %121 = 2.420000e+02 : f64 @@ -4851,7 +4851,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x8a4661", 13767, 13776, 59, "_0x8a4661">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x8a4661", 13767, 13776, 59, "_0x8a4661">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -4878,7 +4878,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %144 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %144 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %144 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %145 = jsir.identifier {"_0x48d0d1"} // SOURCE-NEXT: // %145 = @@ -4940,7 +4940,7 @@ // SOURCE-NEXT: // %145 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %146 = jsir.identifier {"_0x42f460"} -// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %146 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %147 = jsir.numeric_literal {#jsir, 2.080000e+02 : f64} // SOURCE-NEXT: // %147 = 2.080000e+02 : f64 @@ -4964,7 +4964,7 @@ // SOURCE-NEXT: // %153 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %154 = jsir.identifier {"_0x42f460"} -// SOURCE-NEXT: // %154 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %154 = #jsir_builtin, #jsir_builtin, 2.000000e+01 : f64, "-">, #jsir_builtin, 1.710000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %155 = jsir.numeric_literal {#jsir, 2.470000e+02 : f64} // SOURCE-NEXT: // %155 = 2.470000e+02 : f64 @@ -4992,7 +4992,7 @@ // SOURCE-NEXT: }, { // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x42f460", 14080, 14089, 60, "_0x42f460">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x42f460", 14080, 14089, 60, "_0x42f460">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5019,7 +5019,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %144 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %144 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %144 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %145 = jsir.identifier {"_0x2ee8cc"} // SOURCE-NEXT: // %145 = @@ -5074,7 +5074,7 @@ // SOURCE-NEXT: // %132 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %133 = jsir.identifier {"_0x8a4661"} -// SOURCE-NEXT: // %133 = #jsir_builtin, #jsir_builtin, 5.800000e+01 : f64, "-">, #jsir_builtin, 4.390000e+02 : f64, "-">, #jsir_builtin, 6.260000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %133 = #jsir_builtin, #jsir_builtin, 5.800000e+01 : f64, "-">, #jsir_builtin, 4.390000e+02 : f64, "-">, #jsir_builtin, 6.260000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %134 = jsir.numeric_literal {#jsir, 8.600000e+02 : f64} // SOURCE-NEXT: // %134 = 8.600000e+02 : f64 @@ -5139,7 +5139,7 @@ // 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: jshir.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 = ] { } @@ -5154,7 +5154,7 @@ // SOURCE-NEXT: // %90 = "defineProp" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %91 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %92 = jsir.numeric_literal {#jsir, 1.384000e+03 : f64} // SOURCE-NEXT: // %92 = 1.384000e+03 : f64 @@ -5187,7 +5187,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %103 = jsir.object_method {false, false, "method", #jsir, , 14447, 14452, 62, "get", "'get'", "get">, array} ({ +// SOURCE-NEXT: %103 = jsir.object_method {false, false, "method", #jsir, , 14447, 14452, 62, "get", "'get'", "get">, array} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5195,7 +5195,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5603f7", 14476, 14485, 64, "_0x5603f7">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5603f7", 14476, 14485, 64, "_0x5603f7">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5222,7 +5222,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.identifier {"_0x551811"} // SOURCE-NEXT: // %110 = @@ -5327,11 +5327,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %112 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %113 = jsir.object_property (%112) {#jsir, , 14688, 14695, 63, "qrFVU", "'qrFVU'", "qrFVU">, false} +// SOURCE-NEXT: %113 = jsir.object_property (%112) {#jsir, , 14688, 14695, 63, "qrFVU", "'qrFVU'", "qrFVU">, false} // SOURCE-NEXT: // %113 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %114 = jsir.identifier {"_0x5603f7"} -// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, 4.750000e+02 : f64, "-">, #jsir_builtin, 1.030000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, 4.750000e+02 : f64, "-">, #jsir_builtin, 1.030000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.numeric_literal {#jsir, 5.900000e+01 : f64} // SOURCE-NEXT: // %115 = 5.900000e+01 : f64 @@ -5360,7 +5360,7 @@ // SOURCE-NEXT: %123 = jsir.call_expression (%114, %116, %118, %120, %122) // SOURCE-NEXT: // %123 = "accessible" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %124 = jsir.object_property (%123) {#jsir, , 14831, 14838, 63, "vfvSA", "'vfvSA'", "vfvSA">, false} +// SOURCE-NEXT: %124 = jsir.object_property (%123) {#jsir, , 14831, 14838, 63, "vfvSA", "'vfvSA'", "vfvSA">, false} // SOURCE-NEXT: // %124 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.exprs_region_end (%113, %124) @@ -5386,13 +5386,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %109 = jsir.identifier {"_0x1bda43"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, #jsir>>, "vfvSA", #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin>> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, #jsir>>, "vfvSA", #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %110 = jsir.string_literal {#jsir, "qrFVU"} // SOURCE-NEXT: // %110 = "qrFVU" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %111 = jsir.member_expression (%109, %110) -// SOURCE-NEXT: // %111 = #jsir_builtin, #jsir, #jsir>> +// SOURCE-NEXT: // %111 = #jsir_builtin, #jsir, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %112 = jsir.identifier {"notLoadedError"} // SOURCE-NEXT: // %112 = @@ -5401,7 +5401,7 @@ // SOURCE-NEXT: // %113 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %114 = jsir.identifier {"_0x1bda43"} -// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir, #jsir>>, "vfvSA", #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin>> +// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir, #jsir>>, "vfvSA", #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin, #jsir_builtin>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.string_literal {#jsir, "vfvSA"} // SOURCE-NEXT: // %115 = "vfvSA" @@ -5455,7 +5455,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "notLoadedError", 15050, 15064, 66, "notLoadedError">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "notLoadedError", 15050, 15064, 66, "notLoadedError">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5475,7 +5475,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x1ef47c", 15100, 15109, 67, "_0x1ef47c">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x1ef47c", 15100, 15109, 67, "_0x1ef47c">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5502,7 +5502,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %155 = jsir.identifier {"_0x40ee28"} -// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir_builtin, 9.330000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %156 = jsir.identifier {"_0xb04e5e"} // SOURCE-NEXT: // %156 = @@ -5550,7 +5550,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x18bf26", 15262, 15271, 68, "_0x18bf26">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x18bf26", 15262, 15271, 68, "_0x18bf26">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -5577,7 +5577,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %155 = jsir.identifier {"_0xacf810"} -// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %155 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %156 = jsir.identifier {"_0x57328a"} // SOURCE-NEXT: // %156 = @@ -5638,7 +5638,7 @@ // SOURCE-NEXT: // %92 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %93 = jsir.identifier {"_0x1ef47c"} -// SOURCE-NEXT: // %93 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %93 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %94 = jsir.numeric_literal {#jsir, 7.340000e+02 : f64} // SOURCE-NEXT: // %94 = 7.340000e+02 : f64 @@ -5656,7 +5656,7 @@ // SOURCE-NEXT: // %98 = "` export o" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %99 = jsir.identifier {"_0x18bf26"} -// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %100 = jsir.numeric_literal {#jsir, 3.560000e+02 : f64} // SOURCE-NEXT: // %100 = 3.560000e+02 : f64 @@ -5677,7 +5677,7 @@ // SOURCE-NEXT: // %105 = "` export of @babel/c" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %106 = jsir.identifier {"_0x1ef47c"} -// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %107 = jsir.numeric_literal {#jsir, 7.860000e+02 : f64} // SOURCE-NEXT: // %107 = 7.860000e+02 : f64 @@ -5719,7 +5719,7 @@ // SOURCE-NEXT: // %119 = " from the " // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %120 = jsir.identifier {"_0x1ef47c"} -// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %120 = #jsir_builtin, #jsir_builtin, 4.900000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir_builtin, 2.000000e+00 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.numeric_literal {#jsir, 7.230000e+02 : f64} // SOURCE-NEXT: // %121 = 7.230000e+02 : f64 @@ -5740,7 +5740,7 @@ // SOURCE-NEXT: // %126 = " from the CommonJS v" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %127 = jsir.identifier {"_0x18bf26"} -// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.numeric_literal {#jsir, 3.380000e+02 : f64} // SOURCE-NEXT: // %128 = 3.380000e+02 : f64 @@ -5761,7 +5761,7 @@ // SOURCE-NEXT: // %133 = " from the CommonJS version aft" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %134 = jsir.identifier {"_0x18bf26"} -// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %135 = jsir.numeric_literal {#jsir, 2.700000e+02 : f64} // SOURCE-NEXT: // %135 = 2.700000e+02 : f64 @@ -5782,7 +5782,7 @@ // SOURCE-NEXT: // %140 = " from the CommonJS version after that th" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %141 = jsir.identifier {"_0x18bf26"} -// SOURCE-NEXT: // %141 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %141 = #jsir_builtin, #jsir_builtin, 3.050000e+02 : f64, "-">, #jsir_builtin, 4.340000e+02 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %142 = jsir.numeric_literal {#jsir, 2.930000e+02 : f64} // SOURCE-NEXT: // %142 = 2.930000e+02 : f64 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 24547d4..5b730a0 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 @@ -22,7 +22,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 8, 11, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 8, 11, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"btoa"} @@ -63,7 +63,7 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 58, 61, 1, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 58, 61, 1, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %8 = jsir.identifier {"btoa"} 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 32238dd..90363b8 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 @@ -26,7 +26,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 9, 12, 1, "foo">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 9, 12, 1, "foo">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -62,7 +62,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "bar", 46, 49, 2, "bar">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "bar", 46, 49, 2, "bar">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -80,7 +80,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %19 = jsir.identifier {"foo"} -// SOURCE-NEXT: // %19 = #jsir_builtin, 1.000000e+00 : f64, "+">> +// SOURCE-NEXT: // %19 = #jsir_builtin, 1.000000e+00 : f64, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %20 = jsir.identifier {"x"} // SOURCE-NEXT: // %20 = @@ -113,7 +113,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "baz", 94, 97, 3, "baz">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "baz", 94, 97, 3, "baz">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -155,11 +155,11 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 132, 135, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 132, 135, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"foo"} -// SOURCE-NEXT: // %2 = #jsir_builtin, 1.000000e+00 : f64, "+">> +// SOURCE-NEXT: // %2 = #jsir_builtin, 1.000000e+00 : f64, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} // SOURCE-NEXT: // %3 = 1.000000e+00 : f64 @@ -175,11 +175,11 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 153, 156, 0, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 153, 156, 0, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %8 = jsir.identifier {"bar"} -// SOURCE-NEXT: // %8 = #jsir_builtin, #jsir_builtin, 1.000000e+00 : f64, "+">, 2.000000e+00 : f64, "*">>> +// SOURCE-NEXT: // %8 = #jsir_builtin, #jsir_builtin, 1.000000e+00 : f64, "+">, 2.000000e+00 : f64, "*">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %9 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} // SOURCE-NEXT: // %9 = 2.000000e+00 : f64 @@ -195,14 +195,14 @@ // SOURCE-NEXT: %12 = jsir.identifier {"console"} // SOURCE-NEXT: // %12 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 174, 177, 0, "log">} +// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 174, 177, 0, "log">} // SOURCE-NEXT: // %13 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %14 = jsir.identifier {"baz"} -// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %15 = jsir.identifier {"bar"} -// SOURCE-NEXT: // %15 = #jsir_builtin, #jsir_builtin, 1.000000e+00 : f64, "+">, 2.000000e+00 : f64, "*">>> +// SOURCE-NEXT: // %15 = #jsir_builtin, #jsir_builtin, 1.000000e+00 : f64, "+">, 2.000000e+00 : f64, "*">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %16 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} // SOURCE-NEXT: // %16 = 2.000000e+00 : f64 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 8a3621f..a25e65e 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 @@ -330,7 +330,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 5349, 5351, 18, "hi">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 5349, 5351, 18, "hi">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -395,11 +395,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %33 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %34 = jsir.object_property (%33) {#jsir, , 5380, 5387, 18, "cmIIa", "'cmIIa'", "cmIIa">, false} +// SOURCE-NEXT: %34 = jsir.object_property (%33) {#jsir, , 5380, 5387, 18, "cmIIa", "'cmIIa'", "cmIIa">, false} // SOURCE-NEXT: // %34 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %35 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.numeric_literal {#jsir, 2.910000e+02 : f64} // SOURCE-NEXT: // %36 = 2.910000e+02 : f64 @@ -416,7 +416,7 @@ // SOURCE-NEXT: %40 = jsir.call_expression (%35, %36, %37, %38, %39) // SOURCE-NEXT: // %40 = "LtmRg" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %41 = jsir.object_property (%40) {#jsir, , 5471, 5478, 18, "rvTTb", "'rvTTb'", "rvTTb">, false} +// SOURCE-NEXT: %41 = jsir.object_property (%40) {#jsir, , 5471, 5478, 18, "rvTTb", "'rvTTb'", "rvTTb">, false} // SOURCE-NEXT: // %41 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.function_expression {false, false} ({ @@ -459,11 +459,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %42 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %43 = jsir.object_property (%42) {#jsir, , 5523, 5530, 18, "BLRju", "'BLRju'", "BLRju">, false} +// SOURCE-NEXT: %43 = jsir.object_property (%42) {#jsir, , 5523, 5530, 18, "BLRju", "'BLRju'", "BLRju">, false} // SOURCE-NEXT: // %43 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %44 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %45 = jsir.numeric_literal {#jsir, 6.300000e+01 : f64} // SOURCE-NEXT: // %45 = 6.300000e+01 : f64 @@ -480,11 +480,11 @@ // SOURCE-NEXT: %49 = jsir.call_expression (%44, %45, %46, %47, %48) // SOURCE-NEXT: // %49 = "snjPo" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %50 = jsir.object_property (%49) {#jsir, , 5614, 5621, 18, "INEBZ", "'INEBZ'", "INEBZ">, false} +// SOURCE-NEXT: %50 = jsir.object_property (%49) {#jsir, , 5614, 5621, 18, "INEBZ", "'INEBZ'", "INEBZ">, false} // SOURCE-NEXT: // %50 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %51 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.numeric_literal {#jsir, 4.500000e+01 : f64} // SOURCE-NEXT: // %52 = 4.500000e+01 : f64 @@ -501,11 +501,11 @@ // SOURCE-NEXT: %56 = jsir.call_expression (%51, %52, %53, %54, %55) // SOURCE-NEXT: // %56 = "Nngrv" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %57 = jsir.object_property (%56) {#jsir, , 5662, 5669, 18, "gCfqE", "'gCfqE'", "gCfqE">, false} +// SOURCE-NEXT: %57 = jsir.object_property (%56) {#jsir, , 5662, 5669, 18, "gCfqE", "'gCfqE'", "gCfqE">, false} // SOURCE-NEXT: // %57 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %58 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %58 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %58 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %59 = jsir.numeric_literal {#jsir, 2.980000e+02 : f64} // SOURCE-NEXT: // %59 = 2.980000e+02 : f64 @@ -522,7 +522,7 @@ // SOURCE-NEXT: %63 = jsir.call_expression (%58, %59, %60, %61, %62) // SOURCE-NEXT: // %63 = "2|0|4|3|1" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 5710, 5717, 18, "ZUNtd", "'ZUNtd'", "ZUNtd">, false} +// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 5710, 5717, 18, "ZUNtd", "'ZUNtd'", "ZUNtd">, false} // SOURCE-NEXT: // %64 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %65 = jsir.function_expression {false, false} ({ @@ -565,7 +565,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %65 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 5762, 5769, 18, "soDZs", "'soDZs'", "soDZs">, false} +// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 5762, 5769, 18, "soDZs", "'soDZs'", "soDZs">, false} // SOURCE-NEXT: // %66 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %67 = jsir.function_expression {false, false} ({ @@ -608,14 +608,14 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 5850, 5857, 18, "NieDC", "'NieDC'", "NieDC">, false} +// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 5850, 5857, 18, "NieDC", "'NieDC'", "NieDC">, false} // SOURCE-NEXT: // %68 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %69 = jsir.string_literal {#jsir, "return (fu"} // SOURCE-NEXT: // %69 = "return (fu" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %70 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %71 = jsir.numeric_literal {#jsir, 2.630000e+02 : f64} // SOURCE-NEXT: // %71 = 2.630000e+02 : f64 @@ -635,11 +635,11 @@ // SOURCE-NEXT: %76 = jsir.binary_expression (%69, %75) {"+"} // SOURCE-NEXT: // %76 = "return (function() " // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %77 = jsir.object_property (%76) {#jsir, , 5939, 5946, 18, "yEDez", "'yEDez'", "yEDez">, false} +// SOURCE-NEXT: %77 = jsir.object_property (%76) {#jsir, , 5939, 5946, 18, "yEDez", "'yEDez'", "yEDez">, false} // SOURCE-NEXT: // %77 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %78 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %78 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %78 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %79 = jsir.numeric_literal {#jsir, 2.830000e+02 : f64} // SOURCE-NEXT: // %79 = 2.830000e+02 : f64 @@ -657,7 +657,7 @@ // SOURCE-NEXT: // %83 = "{}.constru" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %84 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %84 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %84 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %85 = jsir.numeric_literal {#jsir, 8.200000e+01 : f64} // SOURCE-NEXT: // %85 = 8.200000e+01 : f64 @@ -678,7 +678,7 @@ // SOURCE-NEXT: // %90 = "{}.constructor(\22retu" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %91 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %91 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %92 = jsir.numeric_literal {#jsir, 2.890000e+02 : f64} // SOURCE-NEXT: // %92 = 2.890000e+02 : f64 @@ -704,7 +704,7 @@ // SOURCE-NEXT: %99 = jsir.binary_expression (%97, %98) {"+"} // SOURCE-NEXT: // %99 = "{}.constructor(\22return this\22)( )" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %100 = jsir.object_property (%99) {#jsir, , 6009, 6016, 18, "ZEmIi", "'ZEmIi'", "ZEmIi">, false} +// SOURCE-NEXT: %100 = jsir.object_property (%99) {#jsir, , 6009, 6016, 18, "ZEmIi", "'ZEmIi'", "ZEmIi">, false} // SOURCE-NEXT: // %100 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %101 = jsir.function_expression {false, false} ({ @@ -747,11 +747,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %101 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %102 = jsir.object_property (%101) {#jsir, , 6163, 6170, 18, "jXOCo", "'jXOCo'", "jXOCo">, false} +// SOURCE-NEXT: %102 = jsir.object_property (%101) {#jsir, , 6163, 6170, 18, "jXOCo", "'jXOCo'", "jXOCo">, false} // SOURCE-NEXT: // %102 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %104 = jsir.numeric_literal {#jsir, 7.100000e+01 : f64} // SOURCE-NEXT: // %104 = 7.100000e+01 : f64 @@ -774,17 +774,17 @@ // SOURCE-NEXT: %110 = jsir.binary_expression (%108, %109) {"+"} // SOURCE-NEXT: // %110 = "3|0|2|4|5|1" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %111 = jsir.object_property (%110) {#jsir, , 6252, 6259, 18, "GyCwQ", "'GyCwQ'", "GyCwQ">, false} +// SOURCE-NEXT: %111 = jsir.object_property (%110) {#jsir, , 6252, 6259, 18, "GyCwQ", "'GyCwQ'", "GyCwQ">, false} // SOURCE-NEXT: // %111 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %112 = jsir.string_literal {#jsir, "log"} // SOURCE-NEXT: // %112 = "log" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %113 = jsir.object_property (%112) {#jsir, , 6306, 6313, 18, "Fmzmy", "'Fmzmy'", "Fmzmy">, false} +// SOURCE-NEXT: %113 = jsir.object_property (%112) {#jsir, , 6306, 6313, 18, "Fmzmy", "'Fmzmy'", "Fmzmy">, false} // SOURCE-NEXT: // %113 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %114 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %114 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %115 = jsir.numeric_literal {#jsir, 7.500000e+01 : f64} // SOURCE-NEXT: // %115 = 7.500000e+01 : f64 @@ -801,11 +801,11 @@ // SOURCE-NEXT: %119 = jsir.call_expression (%114, %115, %116, %117, %118) // SOURCE-NEXT: // %119 = "warn" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %120 = jsir.object_property (%119) {#jsir, , 6326, 6333, 18, "bDDQL", "'bDDQL'", "bDDQL">, false} +// SOURCE-NEXT: %120 = jsir.object_property (%119) {#jsir, , 6326, 6333, 18, "bDDQL", "'bDDQL'", "bDDQL">, false} // SOURCE-NEXT: // %120 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %121 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %121 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %121 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %122 = jsir.numeric_literal {#jsir, 3.140000e+02 : f64} // SOURCE-NEXT: // %122 = 3.140000e+02 : f64 @@ -822,11 +822,11 @@ // SOURCE-NEXT: %126 = jsir.call_expression (%121, %122, %123, %124, %125) // SOURCE-NEXT: // %126 = "info" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %127 = jsir.object_property (%126) {#jsir, , 6374, 6381, 18, "wkULH", "'wkULH'", "wkULH">, false} +// SOURCE-NEXT: %127 = jsir.object_property (%126) {#jsir, , 6374, 6381, 18, "wkULH", "'wkULH'", "wkULH">, false} // SOURCE-NEXT: // %127 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %128 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %129 = jsir.numeric_literal {#jsir, 2.900000e+02 : f64} // SOURCE-NEXT: // %129 = 2.900000e+02 : f64 @@ -843,11 +843,11 @@ // SOURCE-NEXT: %133 = jsir.call_expression (%128, %129, %130, %131, %132) // SOURCE-NEXT: // %133 = "error" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %134 = jsir.object_property (%133) {#jsir, , 6426, 6433, 18, "Wftmu", "'Wftmu'", "Wftmu">, false} +// SOURCE-NEXT: %134 = jsir.object_property (%133) {#jsir, , 6426, 6433, 18, "Wftmu", "'Wftmu'", "Wftmu">, false} // SOURCE-NEXT: // %134 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %135 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %136 = jsir.numeric_literal {#jsir, 2.950000e+02 : f64} // SOURCE-NEXT: // %136 = 2.950000e+02 : f64 @@ -864,11 +864,11 @@ // SOURCE-NEXT: %140 = jsir.call_expression (%135, %136, %137, %138, %139) // SOURCE-NEXT: // %140 = "exception" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %141 = jsir.object_property (%140) {#jsir, , 6478, 6485, 18, "gXlVo", "'gXlVo'", "gXlVo">, false} +// SOURCE-NEXT: %141 = jsir.object_property (%140) {#jsir, , 6478, 6485, 18, "gXlVo", "'gXlVo'", "gXlVo">, false} // SOURCE-NEXT: // %141 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %142 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %142 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %142 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %143 = jsir.numeric_literal {#jsir, 2.780000e+02 : f64} // SOURCE-NEXT: // %143 = 2.780000e+02 : f64 @@ -885,7 +885,7 @@ // SOURCE-NEXT: %147 = jsir.call_expression (%142, %143, %144, %145, %146) // SOURCE-NEXT: // %147 = "table" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %148 = jsir.object_property (%147) {#jsir, , 6530, 6537, 18, "DRyXW", "'DRyXW'", "DRyXW">, false} +// SOURCE-NEXT: %148 = jsir.object_property (%147) {#jsir, , 6530, 6537, 18, "DRyXW", "'DRyXW'", "DRyXW">, false} // SOURCE-NEXT: // %148 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %149 = jsir.function_expression {false, false} ({ @@ -922,11 +922,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %149 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %150 = jsir.object_property (%149) {#jsir, , 6582, 6589, 18, "fPEpB", "'fPEpB'", "fPEpB">, false} +// SOURCE-NEXT: %150 = jsir.object_property (%149) {#jsir, , 6582, 6589, 18, "fPEpB", "'fPEpB'", "fPEpB">, false} // SOURCE-NEXT: // %150 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %151 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %151 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %151 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %152 = jsir.numeric_literal {#jsir, 3.700000e+01 : f64} // SOURCE-NEXT: // %152 = 3.700000e+01 : f64 @@ -949,7 +949,7 @@ // SOURCE-NEXT: %158 = jsir.binary_expression (%156, %157) {"+"} // SOURCE-NEXT: // %158 = "Hello World!" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %159 = jsir.object_property (%158) {#jsir, , 6650, 6657, 18, "Xxejz", "'Xxejz'", "Xxejz">, false} +// SOURCE-NEXT: %159 = jsir.object_property (%158) {#jsir, , 6650, 6657, 18, "Xxejz", "'Xxejz'", "Xxejz">, false} // SOURCE-NEXT: // %159 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.exprs_region_end (%34, %41, %43, %50, %57, %64, %66, %68, %77, %100, %102, %111, %113, %120, %127, %134, %141, %148, %150, %159) @@ -964,7 +964,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6716, 6725, 25, "_0x3e158c">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6716, 6725, 25, "_0x3e158c">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1085,7 +1085,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6944, 6953, 28, "_0x3e158c">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6944, 6953, 28, "_0x3e158c">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1139,7 +1139,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x167d7e", 7077, 7086, 29, "_0x167d7e">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x167d7e", 7077, 7086, 29, "_0x167d7e">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1194,19 +1194,19 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.string_literal {#jsir, "cmIIa"} // SOURCE-NEXT: // %37 = "cmIIa" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %38 = jsir.member_expression (%36, %37) -// SOURCE-NEXT: // %38 = #jsir_builtin, #jsir, "===">> +// SOURCE-NEXT: // %38 = #jsir_builtin, #jsir, "===">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %39 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %40 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %40 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %41 = jsir.numeric_literal {#jsir, 7.060000e+02 : f64} // SOURCE-NEXT: // %41 = 7.060000e+02 : f64 @@ -1227,7 +1227,7 @@ // SOURCE-NEXT: // %46 = "LtmRg" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %47 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %47 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %47 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %48 = jsir.numeric_literal {#jsir, 7.080000e+02 : f64} // SOURCE-NEXT: // %48 = 7.080000e+02 : f64 @@ -1312,7 +1312,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x552a36", 7413, 7422, 32, "_0x552a36">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x552a36", 7413, 7422, 32, "_0x552a36">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1339,7 +1339,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %66 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %67 = jsir.identifier {"_0x5b91b5"} // SOURCE-NEXT: // %67 = @@ -1409,7 +1409,7 @@ // SOURCE-NEXT: // %72 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %73 = jsir.identifier {"_0x552a36"} -// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 2.730000e+02 : f64, "-">, #jsir, #jsir_builtin, 8.100000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">>> +// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 2.730000e+02 : f64, "-">, #jsir, #jsir_builtin, 8.100000e+01 : f64, "-">, #jsir_builtin, #jsir_builtin, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %74 = jsir.numeric_literal {#jsir, 2.490000e+02 : f64} // SOURCE-NEXT: // %74 = 2.490000e+02 : f64 @@ -1746,7 +1746,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5fb062", 8211, 8220, 39, "_0x5fb062">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5fb062", 8211, 8220, 39, "_0x5fb062">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1830,7 +1830,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x9092eb", 8381, 8390, 41, "_0x9092eb">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x9092eb", 8381, 8390, 41, "_0x9092eb">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1857,7 +1857,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %51 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.identifier {"_0x497bbc"} // SOURCE-NEXT: // %52 = @@ -1902,7 +1902,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x620196", 8558, 8567, 42, "_0x620196">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x620196", 8558, 8567, 42, "_0x620196">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1929,7 +1929,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %51 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.identifier {"_0x425af0"} // SOURCE-NEXT: // %52 = @@ -1975,16 +1975,16 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.string_literal {#jsir, "BLRju"} // SOURCE-NEXT: // %37 = "BLRju" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %38 = jsir.member_expression (%36, %37) -// SOURCE-NEXT: // %38 = #jsir_builtin, #jsir, "===">> +// SOURCE-NEXT: // %38 = #jsir_builtin, #jsir, "===">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %39 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.string_literal {#jsir, "INEBZ"} // SOURCE-NEXT: // %40 = "INEBZ" @@ -1993,10 +1993,10 @@ // SOURCE-NEXT: // %41 = "snjPo" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %43 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %43 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %43 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %44 = jsir.numeric_literal {#jsir, 7.550000e+02 : f64} // SOURCE-NEXT: // %44 = 7.550000e+02 : f64 @@ -2561,10 +2561,10 @@ // SOURCE-NEXT: // %51 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %52 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %52 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %53 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %53 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %53 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %54 = jsir.numeric_literal {#jsir, 4.790000e+02 : f64} // SOURCE-NEXT: // %54 = 4.790000e+02 : f64 @@ -2585,7 +2585,7 @@ // SOURCE-NEXT: // %59 = "2|0|4|3|1" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %60 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %61 = jsir.numeric_literal {#jsir, 5.310000e+02 : f64} // SOURCE-NEXT: // %61 = 5.310000e+02 : f64 @@ -2719,10 +2719,10 @@ // SOURCE-NEXT: // %59 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %60 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %61 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %62 = jsir.numeric_literal {#jsir, 7.270000e+02 : f64} // SOURCE-NEXT: // %62 = 7.270000e+02 : f64 @@ -2740,25 +2740,25 @@ // SOURCE-NEXT: // %66 = "soDZs" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %67 = jsir.member_expression (%60, %66) -// SOURCE-NEXT: // %67 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %67 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %68 = jsir.identifier {"Function"} // SOURCE-NEXT: // %68 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %69 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %69 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %69 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %70 = jsir.string_literal {#jsir, "NieDC"} // SOURCE-NEXT: // %70 = "NieDC" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %71 = jsir.member_expression (%69, %70) -// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %72 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %73 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %74 = jsir.numeric_literal {#jsir, 5.070000e+02 : f64} // SOURCE-NEXT: // %74 = 5.070000e+02 : f64 @@ -2776,13 +2776,13 @@ // SOURCE-NEXT: // %78 = "NieDC" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %79 = jsir.member_expression (%72, %78) -// SOURCE-NEXT: // %79 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %79 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %80 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %81 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %82 = jsir.numeric_literal {#jsir, 5.140000e+02 : f64} // SOURCE-NEXT: // %82 = 5.140000e+02 : f64 @@ -2803,10 +2803,10 @@ // SOURCE-NEXT: // %87 = "return (function() " // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %88 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %89 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %90 = jsir.numeric_literal {#jsir, 4.810000e+02 : f64} // SOURCE-NEXT: // %90 = 4.810000e+02 : f64 @@ -2981,10 +2981,10 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %55 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %55 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %55 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %56 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %57 = jsir.numeric_literal {#jsir, 7.020000e+02 : f64} // SOURCE-NEXT: // %57 = 7.020000e+02 : f64 @@ -3002,7 +3002,7 @@ // SOURCE-NEXT: // %61 = "jXOCo" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %62 = jsir.member_expression (%55, %61) -// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "<">> +// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "<">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %63 = jsir.identifier {"_0x4a8534"} // SOURCE-NEXT: // %63 = @@ -3011,7 +3011,7 @@ // SOURCE-NEXT: // %64 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %65 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %66 = jsir.numeric_literal {#jsir, 5.260000e+02 : f64} // SOURCE-NEXT: // %66 = 5.260000e+02 : f64 @@ -3064,7 +3064,7 @@ // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %56 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %57 = jsir.string_literal {#jsir, "GyCwQ"} // SOURCE-NEXT: // %57 = "GyCwQ" @@ -3073,7 +3073,7 @@ // SOURCE-NEXT: // %58 = "3|0|2|4|5|1" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %59 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %59 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %59 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %60 = jsir.numeric_literal {#jsir, 5.350000e+02 : f64} // SOURCE-NEXT: // %60 = 5.350000e+02 : f64 @@ -3331,7 +3331,7 @@ // SOURCE-NEXT: // %60 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %61 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %62 = jsir.numeric_literal {#jsir, 5.350000e+02 : f64} // SOURCE-NEXT: // %62 = 5.350000e+02 : f64 @@ -3358,7 +3358,7 @@ // SOURCE-NEXT: // %69 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %70 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %71 = jsir.numeric_literal {#jsir, 5.340000e+02 : f64} // SOURCE-NEXT: // %71 = 5.340000e+02 : f64 @@ -3379,7 +3379,7 @@ // SOURCE-NEXT: // %76 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %77 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %77 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %77 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %78 = jsir.numeric_literal {#jsir, 7.590000e+02 : f64} // SOURCE-NEXT: // %78 = 7.590000e+02 : f64 @@ -3433,7 +3433,7 @@ // SOURCE-NEXT: // %59 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %60 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %61 = jsir.numeric_literal {#jsir, 7.380000e+02 : f64} // SOURCE-NEXT: // %61 = 7.380000e+02 : f64 @@ -3457,7 +3457,7 @@ // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %68 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %69 = jsir.numeric_literal {#jsir, 5.460000e+02 : f64} // SOURCE-NEXT: // %69 = 5.460000e+02 : f64 @@ -3509,7 +3509,7 @@ // SOURCE-NEXT: // %59 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %60 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %60 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %61 = jsir.numeric_literal {#jsir, 4.770000e+02 : f64} // SOURCE-NEXT: // %61 = 4.770000e+02 : f64 @@ -3533,7 +3533,7 @@ // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %68 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %69 = jsir.numeric_literal {#jsir, 7.470000e+02 : f64} // SOURCE-NEXT: // %69 = 7.470000e+02 : f64 @@ -3554,7 +3554,7 @@ // SOURCE-NEXT: // %74 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %75 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %75 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %75 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %76 = jsir.numeric_literal {#jsir, 7.490000e+02 : f64} // SOURCE-NEXT: // %76 = 7.490000e+02 : f64 @@ -3665,10 +3665,10 @@ // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %56 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %57 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %57 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %57 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %58 = jsir.numeric_literal {#jsir, 5.220000e+02 : f64} // SOURCE-NEXT: // %58 = 5.220000e+02 : f64 @@ -3689,10 +3689,10 @@ // SOURCE-NEXT: // %63 = "log" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %64 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %64 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %64 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %65 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %66 = jsir.numeric_literal {#jsir, 7.230000e+02 : f64} // SOURCE-NEXT: // %66 = 7.230000e+02 : f64 @@ -3713,10 +3713,10 @@ // SOURCE-NEXT: // %71 = "warn" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %72 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %73 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %73 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %74 = jsir.numeric_literal {#jsir, 7.780000e+02 : f64} // SOURCE-NEXT: // %74 = 7.780000e+02 : f64 @@ -3737,10 +3737,10 @@ // SOURCE-NEXT: // %79 = "info" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %80 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %81 = jsir.identifier {"_0x9092eb"} -// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> +// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 4.570000e+02 : f64, "-">, #jsir, #jsir_builtin, 3.690000e+02 : f64, "-">, #jsir_builtin, 8.400000e+01 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %82 = jsir.numeric_literal {#jsir, 7.200000e+02 : f64} // SOURCE-NEXT: // %82 = 7.200000e+02 : f64 @@ -3761,10 +3761,10 @@ // SOURCE-NEXT: // %87 = "error" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %88 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %89 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %90 = jsir.numeric_literal {#jsir, 5.290000e+02 : f64} // SOURCE-NEXT: // %90 = 5.290000e+02 : f64 @@ -3785,7 +3785,7 @@ // SOURCE-NEXT: // %95 = "exception" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %96 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %96 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %96 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %97 = jsir.string_literal {#jsir, "DRyXW"} // SOURCE-NEXT: // %97 = "DRyXW" @@ -3794,7 +3794,7 @@ // SOURCE-NEXT: // %98 = "table" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %99 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %100 = jsir.numeric_literal {#jsir, 4.750000e+02 : f64} // SOURCE-NEXT: // %100 = 4.750000e+02 : f64 @@ -3849,7 +3849,7 @@ // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %57 = jsir.identifier {"_0x620196"} -// SOURCE-NEXT: // %57 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> +// SOURCE-NEXT: // %57 = #jsir_builtin, #jsir_builtin, 8.800000e+01 : f64, "-">, #jsir_builtin, 3.940000e+02 : f64, "-">, #jsir, #jsir_builtin, 4.460000e+02 : f64, "-">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %58 = jsir.numeric_literal {#jsir, 5.080000e+02 : f64} // SOURCE-NEXT: // %58 = 5.080000e+02 : f64 @@ -3950,10 +3950,10 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %3 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %3 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %3 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %4 = jsir.numeric_literal {#jsir, 2.710000e+02 : f64} // SOURCE-NEXT: // %4 = 2.710000e+02 : f64 @@ -3971,7 +3971,7 @@ // SOURCE-NEXT: // %8 = "fPEpB" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %9 = jsir.member_expression (%2, %8) -// SOURCE-NEXT: // %9 = #jsir_builtin, >> +// SOURCE-NEXT: // %9 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %10 = jsir.identifier {"_0x5a5e61"} // SOURCE-NEXT: // %10 = @@ -3983,7 +3983,7 @@ // SOURCE-NEXT: // %12 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %13 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %13 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %13 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %14 = jsir.numeric_literal {#jsir, 1.010000e+02 : f64} // SOURCE-NEXT: // %14 = 1.010000e+02 : f64 @@ -4004,10 +4004,10 @@ // SOURCE-NEXT: // %19 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %20 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> +// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir, "===">>, "rvTTb", #jsir_builtin, 2.910000e+02 : f64, 2.760000e+02 : f64, 2.970000e+02 : f64, 3.030000e+02 : f64>, "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", #jsir_builtin, 6.300000e+01 : f64, 4.500000e+01 : f64, 7.300000e+01 : f64, 5.500000e+01 : f64>, "gCfqE", #jsir_builtin, 4.500000e+01 : f64, 5.700000e+01 : f64, 3.600000e+01 : f64, 5.300000e+01 : f64>, "ZUNtd", #jsir_builtin, 2.980000e+02 : f64, 2.730000e+02 : f64, 3.170000e+02 : f64, 2.830000e+02 : f64>, "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", #jsir_builtin, 2.630000e+02 : f64, 2.680000e+02 : f64, 2.800000e+02 : f64, 2.640000e+02 : f64>, "+">, "ZEmIi", #jsir_builtin, 2.830000e+02 : f64, 2.650000e+02 : f64, 2.640000e+02 : f64, 2.980000e+02 : f64>, #jsir_builtin, 8.200000e+01 : f64, 6.300000e+01 : f64, 9.800000e+01 : f64, 7.800000e+01 : f64>, "+">, #jsir_builtin, 2.890000e+02 : f64, 2.810000e+02 : f64, 3.110000e+02 : f64, 2.980000e+02 : f64>, "+">, " )", "+">, "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", #jsir_builtin, 7.100000e+01 : f64, 1.000000e+02 : f64, 1.020000e+02 : f64, 8.000000e+01 : f64>, "1", "+">, "Fmzmy", "log", "bDDQL", #jsir_builtin, 7.500000e+01 : f64, 3.400000e+01 : f64, 5.900000e+01 : f64, 5.600000e+01 : f64>, "wkULH", #jsir_builtin, 3.140000e+02 : f64, 3.060000e+02 : f64, 3.100000e+02 : f64, 3.360000e+02 : f64>, "Wftmu", #jsir_builtin, 2.900000e+02 : f64, 2.900000e+02 : f64, 2.660000e+02 : f64, 3.130000e+02 : f64>, "gXlVo", #jsir_builtin, 2.950000e+02 : f64, 3.120000e+02 : f64, 2.880000e+02 : f64, 2.840000e+02 : f64>, "DRyXW", #jsir_builtin, 2.780000e+02 : f64, 2.560000e+02 : f64, 2.890000e+02 : f64, 2.610000e+02 : f64>, "fPEpB", #jsir_builtin, >>, "Xxejz", #jsir_builtin, 3.700000e+01 : f64, 3.800000e+01 : f64, 3.000000e+01 : f64, 4.100000e+01 : f64>, "d!", "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %21 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %22 = jsir.numeric_literal {#jsir, 4.600000e+01 : f64} // SOURCE-NEXT: // %22 = 4.600000e+01 : f64 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 f0f9bec..bd37d35 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 @@ -330,7 +330,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 5349, 5351, 18, "hi">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 5349, 5351, 18, "hi">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -395,13 +395,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %18 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %19 = jsir.object_property (%18) {#jsir, , 5380, 5387, 18, "cmIIa", "'cmIIa'", "cmIIa">, false} +// SOURCE-NEXT: %19 = jsir.object_property (%18) {#jsir, , 5380, 5387, 18, "cmIIa", "'cmIIa'", "cmIIa">, false} // SOURCE-NEXT: // %19 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %20 = jsir.string_literal {#jsir, "LtmRg"} // SOURCE-NEXT: // %20 = "LtmRg" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %21 = jsir.object_property (%20) {#jsir, , 5471, 5478, 18, "rvTTb", "'rvTTb'", "rvTTb">, false} +// SOURCE-NEXT: %21 = jsir.object_property (%20) {#jsir, , 5471, 5478, 18, "rvTTb", "'rvTTb'", "rvTTb">, false} // SOURCE-NEXT: // %21 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %22 = jsir.function_expression {false, false} ({ @@ -444,25 +444,25 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %22 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %23 = jsir.object_property (%22) {#jsir, , 5493, 5500, 18, "BLRju", "'BLRju'", "BLRju">, false} +// SOURCE-NEXT: %23 = jsir.object_property (%22) {#jsir, , 5493, 5500, 18, "BLRju", "'BLRju'", "BLRju">, false} // SOURCE-NEXT: // %23 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %24 = jsir.string_literal {#jsir, "snjPo"} // SOURCE-NEXT: // %24 = "snjPo" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %25 = jsir.object_property (%24) {#jsir, , 5584, 5591, 18, "INEBZ", "'INEBZ'", "INEBZ">, false} +// SOURCE-NEXT: %25 = jsir.object_property (%24) {#jsir, , 5584, 5591, 18, "INEBZ", "'INEBZ'", "INEBZ">, false} // SOURCE-NEXT: // %25 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %26 = jsir.string_literal {#jsir, "Nngrv"} // SOURCE-NEXT: // %26 = "Nngrv" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %27 = jsir.object_property (%26) {#jsir, , 5606, 5613, 18, "gCfqE", "'gCfqE'", "gCfqE">, false} +// SOURCE-NEXT: %27 = jsir.object_property (%26) {#jsir, , 5606, 5613, 18, "gCfqE", "'gCfqE'", "gCfqE">, false} // SOURCE-NEXT: // %27 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %28 = jsir.string_literal {#jsir, "2|0|4|3|1"} // SOURCE-NEXT: // %28 = "2|0|4|3|1" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %29 = jsir.object_property (%28) {#jsir, , 5628, 5635, 18, "ZUNtd", "'ZUNtd'", "ZUNtd">, false} +// SOURCE-NEXT: %29 = jsir.object_property (%28) {#jsir, , 5628, 5635, 18, "ZUNtd", "'ZUNtd'", "ZUNtd">, false} // SOURCE-NEXT: // %29 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %30 = jsir.function_expression {false, false} ({ @@ -505,7 +505,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %30 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %31 = jsir.object_property (%30) {#jsir, , 5654, 5661, 18, "soDZs", "'soDZs'", "soDZs">, false} +// SOURCE-NEXT: %31 = jsir.object_property (%30) {#jsir, , 5654, 5661, 18, "soDZs", "'soDZs'", "soDZs">, false} // SOURCE-NEXT: // %31 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %32 = jsir.function_expression {false, false} ({ @@ -548,19 +548,19 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %32 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %33 = jsir.object_property (%32) {#jsir, , 5742, 5749, 18, "NieDC", "'NieDC'", "NieDC">, false} +// SOURCE-NEXT: %33 = jsir.object_property (%32) {#jsir, , 5742, 5749, 18, "NieDC", "'NieDC'", "NieDC">, false} // SOURCE-NEXT: // %33 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %34 = jsir.string_literal {#jsir, "return (function() "} // SOURCE-NEXT: // %34 = "return (function() " // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %35 = jsir.object_property (%34) {#jsir, , 5831, 5838, 18, "yEDez", "'yEDez'", "yEDez">, false} +// SOURCE-NEXT: %35 = jsir.object_property (%34) {#jsir, , 5831, 5838, 18, "yEDez", "'yEDez'", "yEDez">, false} // SOURCE-NEXT: // %35 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.string_literal {#jsir, "{}.constructor(\22return this\22)( )"} // SOURCE-NEXT: // %36 = "{}.constructor(\22return this\22)( )" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %37 = jsir.object_property (%36) {#jsir, , 5867, 5874, 18, "ZEmIi", "'ZEmIi'", "ZEmIi">, false} +// SOURCE-NEXT: %37 = jsir.object_property (%36) {#jsir, , 5867, 5874, 18, "ZEmIi", "'ZEmIi'", "ZEmIi">, false} // SOURCE-NEXT: // %37 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %38 = jsir.function_expression {false, false} ({ @@ -603,49 +603,49 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %38 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %39 = jsir.object_property (%38) {#jsir, , 5916, 5923, 18, "jXOCo", "'jXOCo'", "jXOCo">, false} +// SOURCE-NEXT: %39 = jsir.object_property (%38) {#jsir, , 5916, 5923, 18, "jXOCo", "'jXOCo'", "jXOCo">, false} // SOURCE-NEXT: // %39 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.string_literal {#jsir, "3|0|2|4|5|1"} // SOURCE-NEXT: // %40 = "3|0|2|4|5|1" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %41 = jsir.object_property (%40) {#jsir, , 6005, 6012, 18, "GyCwQ", "'GyCwQ'", "GyCwQ">, false} +// SOURCE-NEXT: %41 = jsir.object_property (%40) {#jsir, , 6005, 6012, 18, "GyCwQ", "'GyCwQ'", "GyCwQ">, false} // SOURCE-NEXT: // %41 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.string_literal {#jsir, "log"} // SOURCE-NEXT: // %42 = "log" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %43 = jsir.object_property (%42) {#jsir, , 6033, 6040, 18, "Fmzmy", "'Fmzmy'", "Fmzmy">, false} +// SOURCE-NEXT: %43 = jsir.object_property (%42) {#jsir, , 6033, 6040, 18, "Fmzmy", "'Fmzmy'", "Fmzmy">, false} // SOURCE-NEXT: // %43 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %44 = jsir.string_literal {#jsir, "warn"} // SOURCE-NEXT: // %44 = "warn" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %45 = jsir.object_property (%44) {#jsir, , 6053, 6060, 18, "bDDQL", "'bDDQL'", "bDDQL">, false} +// SOURCE-NEXT: %45 = jsir.object_property (%44) {#jsir, , 6053, 6060, 18, "bDDQL", "'bDDQL'", "bDDQL">, false} // SOURCE-NEXT: // %45 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %46 = jsir.string_literal {#jsir, "info"} // SOURCE-NEXT: // %46 = "info" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %47 = jsir.object_property (%46) {#jsir, , 6074, 6081, 18, "wkULH", "'wkULH'", "wkULH">, false} +// SOURCE-NEXT: %47 = jsir.object_property (%46) {#jsir, , 6074, 6081, 18, "wkULH", "'wkULH'", "wkULH">, false} // SOURCE-NEXT: // %47 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %48 = jsir.string_literal {#jsir, "error"} // SOURCE-NEXT: // %48 = "error" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %49 = jsir.object_property (%48) {#jsir, , 6095, 6102, 18, "Wftmu", "'Wftmu'", "Wftmu">, false} +// SOURCE-NEXT: %49 = jsir.object_property (%48) {#jsir, , 6095, 6102, 18, "Wftmu", "'Wftmu'", "Wftmu">, false} // SOURCE-NEXT: // %49 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %50 = jsir.string_literal {#jsir, "exception"} // SOURCE-NEXT: // %50 = "exception" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %51 = jsir.object_property (%50) {#jsir, , 6117, 6124, 18, "gXlVo", "'gXlVo'", "gXlVo">, false} +// SOURCE-NEXT: %51 = jsir.object_property (%50) {#jsir, , 6117, 6124, 18, "gXlVo", "'gXlVo'", "gXlVo">, false} // SOURCE-NEXT: // %51 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.string_literal {#jsir, "table"} // SOURCE-NEXT: // %52 = "table" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %53 = jsir.object_property (%52) {#jsir, , 6143, 6150, 18, "DRyXW", "'DRyXW'", "DRyXW">, false} +// SOURCE-NEXT: %53 = jsir.object_property (%52) {#jsir, , 6143, 6150, 18, "DRyXW", "'DRyXW'", "DRyXW">, false} // SOURCE-NEXT: // %53 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %54 = jsir.function_expression {false, false} ({ @@ -682,13 +682,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %54 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 6165, 6172, 18, "fPEpB", "'fPEpB'", "fPEpB">, false} +// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 6165, 6172, 18, "fPEpB", "'fPEpB'", "fPEpB">, false} // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %56 = jsir.string_literal {#jsir, "Hello World!"} // SOURCE-NEXT: // %56 = "Hello World!" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %57 = jsir.object_property (%56) {#jsir, , 6233, 6240, 18, "Xxejz", "'Xxejz'", "Xxejz">, false} +// SOURCE-NEXT: %57 = jsir.object_property (%56) {#jsir, , 6233, 6240, 18, "Xxejz", "'Xxejz'", "Xxejz">, false} // SOURCE-NEXT: // %57 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.exprs_region_end (%19, %21, %23, %25, %27, %29, %31, %33, %35, %37, %39, %41, %43, %45, %47, %49, %51, %53, %55, %57) @@ -703,7 +703,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6274, 6283, 25, "_0x3e158c">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x3e158c", 6274, 6283, 25, "_0x3e158c">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -824,7 +824,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x4184b2", 6502, 6511, 28, "_0x4184b2">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x4184b2", 6502, 6511, 28, "_0x4184b2">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -878,7 +878,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x167d7e", 6634, 6643, 29, "_0x167d7e">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x167d7e", 6634, 6643, 29, "_0x167d7e">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -933,16 +933,16 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %21 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %22 = jsir.string_literal {#jsir, "cmIIa"} // SOURCE-NEXT: // %22 = "cmIIa" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %23 = jsir.member_expression (%21, %22) -// SOURCE-NEXT: // %23 = #jsir_builtin, #jsir, "===">> +// SOURCE-NEXT: // %23 = #jsir_builtin, #jsir, "===">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %24 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %25 = jsir.string_literal {#jsir, "rvTTb"} // SOURCE-NEXT: // %25 = "rvTTb" @@ -1021,7 +1021,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x552a36", 6880, 6889, 32, "_0x552a36">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x552a36", 6880, 6889, 32, "_0x552a36">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1048,7 +1048,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %41 = jsir.identifier {"_0x4184b2"} -// SOURCE-NEXT: // %41 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> +// SOURCE-NEXT: // %41 = #jsir_builtin, #jsir_builtin, 2.830000e+02 : f64, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.identifier {"_0x5b91b5"} // SOURCE-NEXT: // %42 = @@ -1428,7 +1428,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5fb062", 7615, 7624, 39, "_0x5fb062">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x5fb062", 7615, 7624, 39, "_0x5fb062">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1512,7 +1512,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x9092eb", 7785, 7794, 41, "_0x9092eb">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x9092eb", 7785, 7794, 41, "_0x9092eb">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1539,7 +1539,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %31 = jsir.identifier {"_0x5fb062"} -// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %32 = jsir.identifier {"_0x497bbc"} // SOURCE-NEXT: // %32 = @@ -1584,7 +1584,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x620196", 7957, 7966, 42, "_0x620196">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "_0x620196", 7957, 7966, 42, "_0x620196">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -1611,7 +1611,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %31 = jsir.identifier {"_0x3e158c"} -// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> +// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir_builtin, #jsir_builtin, "-">, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %32 = jsir.identifier {"_0x425af0"} // SOURCE-NEXT: // %32 = @@ -1657,16 +1657,16 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %21 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %21 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %22 = jsir.string_literal {#jsir, "BLRju"} // SOURCE-NEXT: // %22 = "BLRju" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %23 = jsir.member_expression (%21, %22) -// SOURCE-NEXT: // %23 = #jsir_builtin, #jsir, "===">> +// SOURCE-NEXT: // %23 = #jsir_builtin, #jsir, "===">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %24 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %25 = jsir.string_literal {#jsir, "INEBZ"} // SOURCE-NEXT: // %25 = "INEBZ" @@ -1675,7 +1675,7 @@ // SOURCE-NEXT: // %26 = "snjPo" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %27 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %27 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %27 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %28 = jsir.string_literal {#jsir, "gCfqE"} // SOURCE-NEXT: // %28 = "gCfqE" @@ -2087,7 +2087,7 @@ // SOURCE-NEXT: // %31 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %32 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %32 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %32 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %33 = jsir.string_literal {#jsir, "ZUNtd"} // SOURCE-NEXT: // %33 = "ZUNtd" @@ -2191,37 +2191,37 @@ // SOURCE-NEXT: // %39 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %40 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %40 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %41 = jsir.string_literal {#jsir, "soDZs"} // SOURCE-NEXT: // %41 = "soDZs" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.member_expression (%40, %41) -// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %43 = jsir.identifier {"Function"} // SOURCE-NEXT: // %43 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %44 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %44 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %45 = jsir.string_literal {#jsir, "NieDC"} // SOURCE-NEXT: // %45 = "NieDC" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %46 = jsir.member_expression (%44, %45) -// SOURCE-NEXT: // %46 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %46 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %47 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %47 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %47 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %48 = jsir.string_literal {#jsir, "NieDC"} // SOURCE-NEXT: // %48 = "NieDC" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %49 = jsir.member_expression (%47, %48) -// SOURCE-NEXT: // %49 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %49 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %50 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %50 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %50 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %51 = jsir.string_literal {#jsir, "yEDez"} // SOURCE-NEXT: // %51 = "yEDez" @@ -2230,7 +2230,7 @@ // SOURCE-NEXT: // %52 = "return (function() " // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %53 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %53 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %53 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %54 = jsir.string_literal {#jsir, "ZEmIi"} // SOURCE-NEXT: // %54 = "ZEmIi" @@ -2357,13 +2357,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %35 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.string_literal {#jsir, "jXOCo"} // SOURCE-NEXT: // %36 = "jXOCo" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.member_expression (%35, %36) -// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir, "<">> +// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir, "<">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %38 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} // SOURCE-NEXT: // %38 = 0.000000e+00 : f64 @@ -2410,7 +2410,7 @@ // SOURCE-NEXT: // %35 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.string_literal {#jsir, "GyCwQ"} // SOURCE-NEXT: // %37 = "GyCwQ" @@ -2843,7 +2843,7 @@ // SOURCE-NEXT: // %35 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %36 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %36 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.string_literal {#jsir, "Fmzmy"} // SOURCE-NEXT: // %37 = "Fmzmy" @@ -2852,7 +2852,7 @@ // SOURCE-NEXT: // %38 = "log" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %39 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %40 = jsir.string_literal {#jsir, "bDDQL"} // SOURCE-NEXT: // %40 = "bDDQL" @@ -2861,7 +2861,7 @@ // SOURCE-NEXT: // %41 = "warn" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %42 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %42 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %43 = jsir.string_literal {#jsir, "wkULH"} // SOURCE-NEXT: // %43 = "wkULH" @@ -2870,7 +2870,7 @@ // SOURCE-NEXT: // %44 = "info" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %45 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %45 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %45 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %46 = jsir.string_literal {#jsir, "Wftmu"} // SOURCE-NEXT: // %46 = "Wftmu" @@ -2879,7 +2879,7 @@ // SOURCE-NEXT: // %47 = "error" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %48 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %48 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %48 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %49 = jsir.string_literal {#jsir, "gXlVo"} // SOURCE-NEXT: // %49 = "gXlVo" @@ -2888,7 +2888,7 @@ // SOURCE-NEXT: // %50 = "exception" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %51 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %51 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %52 = jsir.string_literal {#jsir, "DRyXW"} // SOURCE-NEXT: // %52 = "DRyXW" @@ -3023,13 +3023,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %3 = jsir.string_literal {#jsir, "fPEpB"} // SOURCE-NEXT: // %3 = "fPEpB" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %4 = jsir.member_expression (%2, %3) -// SOURCE-NEXT: // %4 = #jsir_builtin, >> +// SOURCE-NEXT: // %4 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %5 = jsir.identifier {"_0x5a5e61"} // SOURCE-NEXT: // %5 = @@ -3047,7 +3047,7 @@ // SOURCE-NEXT: // %9 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %10 = jsir.identifier {"_0x24a11a"} -// SOURCE-NEXT: // %10 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> +// SOURCE-NEXT: // %10 = #jsir_builtin, #jsir, "===">>, "rvTTb", "LtmRg", "BLRju", #jsir_builtin, #jsir, "===">>, "INEBZ", "snjPo", "gCfqE", "Nngrv", "ZUNtd", "2|0|4|3|1", "soDZs", #jsir_builtin, #jsir>>, "NieDC", #jsir_builtin, #jsir, "+">>, "yEDez", "return (function() ", "ZEmIi", "{}.constructor(\22return this\22)( )", "jXOCo", #jsir_builtin, #jsir, "<">>, "GyCwQ", "3|0|2|4|5|1", "Fmzmy", "log", "bDDQL", "warn", "wkULH", "info", "Wftmu", "error", "gXlVo", "exception", "DRyXW", "table", "fPEpB", #jsir_builtin, >>, "Xxejz", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %11 = jsir.string_literal {#jsir, "Xxejz"} // SOURCE-NEXT: // %11 = "Xxejz" 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 e87d296..b129f86 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 @@ -34,7 +34,7 @@ // SOURCE-NEXT: %2 = jsir.parenthesized_expression (%1) // SOURCE-NEXT: // %2 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %3 = jsir.member_expression_ref (%2) {#jsir, , "key", 9, 12, 0, "key">} +// SOURCE-NEXT: %3 = jsir.member_expression_ref (%2) {#jsir, , "key", 9, 12, 0, "key">} // SOURCE-NEXT: // %3 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %4 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} 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 f53ed66..230d27c 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 @@ -40,7 +40,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 176, 179, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 176, 179, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"prelude_1"} @@ -74,7 +74,7 @@ // SOURCE-NEXT: %5 = jsir.identifier {"console"} // SOURCE-NEXT: // %5 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %6 = jsir.member_expression (%5) {#jsir, , "log", 228, 231, 0, "log">} +// SOURCE-NEXT: %6 = jsir.member_expression (%5) {#jsir, , "log", 228, 231, 0, "log">} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %7 = jsir.identifier {"wrapper"} @@ -112,7 +112,7 @@ // SOURCE-NEXT: %10 = jsir.identifier {"console"} // SOURCE-NEXT: // %10 = // SOURCE-NEXT: // State [default = ] { > > } -// SOURCE-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 284, 287, 4, "log">} +// SOURCE-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 284, 287, 4, "log">} // SOURCE-NEXT: // %11 = // SOURCE-NEXT: // State [default = ] { > > } // SOURCE-NEXT: %12 = jsir.identifier {"wrapper"} @@ -133,7 +133,7 @@ // SOURCE-NEXT: %15 = jsir.identifier {"console"} // SOURCE-NEXT: // %15 = // SOURCE-NEXT: // State [default = ] { > > } -// SOURCE-NEXT: %16 = jsir.member_expression (%15) {#jsir, , "log", 316, 319, 5, "log">} +// SOURCE-NEXT: %16 = jsir.member_expression (%15) {#jsir, , "log", 316, 319, 5, "log">} // SOURCE-NEXT: // %16 = // SOURCE-NEXT: // State [default = ] { > > } // SOURCE-NEXT: %17 = jsir.identifier {"wrapper"} @@ -159,7 +159,7 @@ // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { > > } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 348, 351, 6, "foo">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "foo", 348, 351, 6, "foo">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -193,7 +193,7 @@ // SOURCE-NEXT: %10 = jsir.identifier {"console"} // SOURCE-NEXT: // %10 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 393, 396, 6, "log">} +// SOURCE-NEXT: %11 = jsir.member_expression (%10) {#jsir, , "log", 393, 396, 6, "log">} // SOURCE-NEXT: // %11 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %12 = jsir.identifier {"wrapper"} diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/output.generated.txt index d10aed8..a689a1c 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_alias/output.generated.txt @@ -27,7 +27,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"prelude"} @@ -64,7 +64,7 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 122, 125, 0, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 122, 125, 0, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %8 = jsir.identifier {"wrapper_1"} @@ -101,7 +101,7 @@ // SOURCE-NEXT: %12 = jsir.identifier {"console"} // SOURCE-NEXT: // %12 = // SOURCE-NEXT: // State [default = ] { > > } -// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 177, 180, 0, "log">} +// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 177, 180, 0, "log">} // SOURCE-NEXT: // %13 = // SOURCE-NEXT: // State [default = ] { > > } // SOURCE-NEXT: %14 = jsir.identifier {"wrapper_2"} @@ -138,7 +138,7 @@ // SOURCE-NEXT: %18 = jsir.identifier {"console"} // SOURCE-NEXT: // %18 = // SOURCE-NEXT: // State [default = ] { > > > } -// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 234, 237, 0, "log">} +// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 234, 237, 0, "log">} // SOURCE-NEXT: // %19 = // SOURCE-NEXT: // State [default = ] { > > > } // SOURCE-NEXT: %20 = jsir.identifier {"wrapper_3"} 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 3224444..d178f07 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 @@ -33,7 +33,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"prelude"} @@ -70,7 +70,7 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 122, 125, 0, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 122, 125, 0, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %8 = jsir.identifier {"alias"} @@ -87,7 +87,7 @@ // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: jsir.expression_statement (%11) // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper", 153, 160, 2, "wrapper">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper", 153, 160, 2, "wrapper">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -126,11 +126,11 @@ // SOURCE-NEXT: %12 = jsir.identifier {"console"} // SOURCE-NEXT: // %12 = // SOURCE-NEXT: // State [default = ] { > } -// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 197, 200, 0, "log">} +// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 197, 200, 0, "log">} // SOURCE-NEXT: // %13 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %14 = jsir.identifier {"wrapper"} -// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %15 = jsir.string_literal {#jsir, "wrapper"} // SOURCE-NEXT: // %15 = "wrapper" @@ -151,36 +151,36 @@ // SOURCE-NEXT: // %30 = // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %31 = jsir.identifier {"wrapper"} -// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %31 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { > } // SOURCE-NEXT: %32 = jsir.variable_declarator (%30, %31) // SOURCE-NEXT: // %32 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: jsir.exprs_region_end (%32) -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: }) -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %18 = jsir.identifier {"console"} // SOURCE-NEXT: // %18 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } -// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 260, 263, 0, "log">} +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 260, 263, 0, "log">} // SOURCE-NEXT: // %19 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %20 = jsir.identifier {"wrapper_alias"} -// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir>> -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %21 = jsir.string_literal {#jsir, "wrapper_alias"} // SOURCE-NEXT: // %21 = "wrapper_alias" -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %22 = jsir.call_expression (%20, %21) // SOURCE-NEXT: // %22 = "wrapper_alias" -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %23 = jsir.call_expression (%19, %22) // SOURCE-NEXT: // %23 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: jsir.expression_statement (%23) -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "alias_wrapper", 307, 320, 3, "alias_wrapper">} ({ +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "alias_wrapper", 307, 320, 3, "alias_wrapper">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -215,27 +215,27 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %24 = jsir.identifier {"console"} // SOURCE-NEXT: // %24 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } -// SOURCE-NEXT: %25 = jsir.member_expression (%24) {#jsir, , "log", 355, 358, 0, "log">} +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: %25 = jsir.member_expression (%24) {#jsir, , "log", 355, 358, 0, "log">} // SOURCE-NEXT: // %25 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %26 = jsir.identifier {"alias_wrapper"} -// SOURCE-NEXT: // %26 = #jsir_builtin, #jsir>> -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // %26 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %27 = jsir.string_literal {#jsir, "alias_wrapper"} // SOURCE-NEXT: // %27 = "alias_wrapper" -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %28 = jsir.call_expression (%26, %27) // SOURCE-NEXT: // %28 = "alias_wrapper" -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: %29 = jsir.call_expression (%25, %28) // SOURCE-NEXT: // %29 = -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: jsir.expression_statement (%29) -// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } +// SOURCE-NEXT: // State [default = ] { > , #jsir>>> } // SOURCE-NEXT: }, { // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // 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 d0a0650..b982029 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 @@ -27,7 +27,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add", 9, 12, 1, "add">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add", 9, 12, 1, "add">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -66,7 +66,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add_multiline", 49, 62, 2, "add_multiline">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add_multiline", 49, 62, 2, "add_multiline">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -122,7 +122,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add_buggy", 112, 121, 3, "add_buggy">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "add_buggy", 112, 121, 3, "add_buggy">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -155,11 +155,11 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 151, 154, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 151, 154, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"add"} -// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %3 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} // SOURCE-NEXT: // %3 = 1.000000e+00 : f64 @@ -178,11 +178,11 @@ // SOURCE-NEXT: %7 = jsir.identifier {"console"} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %8 = jsir.member_expression (%7) {#jsir, , "log", 175, 178, 0, "log">} +// SOURCE-NEXT: %8 = jsir.member_expression (%7) {#jsir, , "log", 175, 178, 0, "log">} // SOURCE-NEXT: // %8 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %9 = jsir.identifier {"add_multiline"} -// SOURCE-NEXT: // %9 = #jsir_builtin> +// SOURCE-NEXT: // %9 = #jsir_builtin> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %10 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} // SOURCE-NEXT: // %10 = 1.000000e+00 : f64 @@ -201,7 +201,7 @@ // SOURCE-NEXT: %14 = jsir.identifier {"console"} // SOURCE-NEXT: // %14 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %15 = jsir.member_expression (%14) {#jsir, , "log", 209, 212, 0, "log">} +// SOURCE-NEXT: %15 = jsir.member_expression (%14) {#jsir, , "log", 209, 212, 0, "log">} // SOURCE-NEXT: // %15 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %16 = jsir.identifier {"add_buggy"} diff --git a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/output.generated.txt b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/output.generated.txt index e1eb800..21220c3 100644 --- a/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/output.generated.txt +++ b/maldoca/js/ir/transforms/dynamic_constant_propagation/tests/simple_object/output.generated.txt @@ -40,7 +40,7 @@ // SOURCE-NEXT: %41 = jsir.string_literal {#jsir, "a"} // SOURCE-NEXT: // %41 = "a" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %42 = jsir.object_property (%41) {#jsir, , 17, 20, 0, "a", "'a'", "a">, false} +// SOURCE-NEXT: %42 = jsir.object_property (%41) {#jsir, , 17, 20, 0, "a", "'a'", "a">, false} // SOURCE-NEXT: // %42 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %43 = jsir.string_literal {#jsir, ""} @@ -52,13 +52,13 @@ // SOURCE-NEXT: %45 = jsir.binary_expression (%43, %44) {"+"} // SOURCE-NEXT: // %45 = "b" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %46 = jsir.object_property (%45) {#jsir, , 29, 32, 0, "b", "'b'", "b">, false} +// SOURCE-NEXT: %46 = jsir.object_property (%45) {#jsir, , 29, 32, 0, "b", "'b'", "b">, false} // SOURCE-NEXT: // %46 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %47 = jsir.string_literal {#jsir, "c"} // SOURCE-NEXT: // %47 = "c" // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , "c", 46, 47, 0, "c">, false} +// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , "c", 46, 47, 0, "c">, false} // SOURCE-NEXT: // %48 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %49 = jsir.string_literal {#jsir, "d"} @@ -85,11 +85,11 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 80, 83, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 80, 83, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"object"} -// SOURCE-NEXT: // %2 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %2 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %3 = jsir.string_literal {#jsir, "a"} // SOURCE-NEXT: // %3 = "a" @@ -105,11 +105,11 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 106, 109, 0, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 106, 109, 0, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %8 = jsir.identifier {"object"} -// SOURCE-NEXT: // %8 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %8 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %9 = jsir.string_literal {#jsir, ""} // SOURCE-NEXT: // %9 = "" @@ -131,11 +131,11 @@ // SOURCE-NEXT: %14 = jsir.identifier {"console"} // SOURCE-NEXT: // %14 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %15 = jsir.member_expression (%14) {#jsir, , "log", 137, 140, 0, "log">} +// SOURCE-NEXT: %15 = jsir.member_expression (%14) {#jsir, , "log", 137, 140, 0, "log">} // SOURCE-NEXT: // %15 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %16 = jsir.identifier {"object"} -// SOURCE-NEXT: // %16 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %16 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %17 = jsir.string_literal {#jsir, "b"} // SOURCE-NEXT: // %17 = "b" @@ -151,11 +151,11 @@ // SOURCE-NEXT: %20 = jsir.identifier {"console"} // SOURCE-NEXT: // %20 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %21 = jsir.member_expression (%20) {#jsir, , "log", 163, 166, 0, "log">} +// SOURCE-NEXT: %21 = jsir.member_expression (%20) {#jsir, , "log", 163, 166, 0, "log">} // SOURCE-NEXT: // %21 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %22 = jsir.identifier {"object"} -// SOURCE-NEXT: // %22 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %22 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %23 = jsir.string_literal {#jsir, ""} // SOURCE-NEXT: // %23 = "" @@ -177,13 +177,13 @@ // SOURCE-NEXT: %28 = jsir.identifier {"console"} // SOURCE-NEXT: // %28 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %29 = jsir.member_expression (%28) {#jsir, , "log", 194, 197, 0, "log">} +// SOURCE-NEXT: %29 = jsir.member_expression (%28) {#jsir, , "log", 194, 197, 0, "log">} // SOURCE-NEXT: // %29 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %30 = jsir.identifier {"object"} -// SOURCE-NEXT: // %30 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %30 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %31 = jsir.member_expression (%30) {#jsir, , "c", 205, 206, 0, "c">} +// SOURCE-NEXT: %31 = jsir.member_expression (%30) {#jsir, , "c", 205, 206, 0, "c">} // SOURCE-NEXT: // %31 = "c" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %32 = jsir.call_expression (%29, %31) @@ -194,13 +194,13 @@ // SOURCE-NEXT: %33 = jsir.identifier {"console"} // SOURCE-NEXT: // %33 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %34 = jsir.member_expression (%33) {#jsir, , "log", 217, 220, 0, "log">} +// SOURCE-NEXT: %34 = jsir.member_expression (%33) {#jsir, , "log", 217, 220, 0, "log">} // SOURCE-NEXT: // %34 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %35 = jsir.identifier {"object"} -// SOURCE-NEXT: // %35 = #jsir_builtin, "c", "c", "d", "d"> +// SOURCE-NEXT: // %35 = #jsir_builtin, "c", "c", "d", "d"> // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %36 = jsir.member_expression (%35) {#jsir, , "d", 228, 229, 0, "d">} +// SOURCE-NEXT: %36 = jsir.member_expression (%35) {#jsir, , "d", 228, 229, 0, "d">} // SOURCE-NEXT: // %36 = "d" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %37 = jsir.call_expression (%34, %36) 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 b6baa1d..6caac73 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 @@ -33,7 +33,7 @@ // SOURCE-NEXT: %0 = jsir.identifier {"console"} // SOURCE-NEXT: // %0 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} +// SOURCE-NEXT: %1 = jsir.member_expression (%0) {#jsir, , "log", 71, 74, 0, "log">} // SOURCE-NEXT: // %1 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %2 = jsir.identifier {"prelude"} @@ -50,7 +50,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%5) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_1", 98, 107, 2, "wrapper_1">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_1", 98, 107, 2, "wrapper_1">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -89,11 +89,11 @@ // SOURCE-NEXT: %6 = jsir.identifier {"console"} // SOURCE-NEXT: // %6 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 144, 147, 0, "log">} +// SOURCE-NEXT: %7 = jsir.member_expression (%6) {#jsir, , "log", 144, 147, 0, "log">} // SOURCE-NEXT: // %7 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %8 = jsir.identifier {"wrapper_1"} -// SOURCE-NEXT: // %8 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %8 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %9 = jsir.numeric_literal {#jsir, 1.000000e+00 : f64} // SOURCE-NEXT: // %9 = 1.000000e+00 : f64 @@ -106,7 +106,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%11) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_2", 173, 182, 3, "wrapper_2">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_2", 173, 182, 3, "wrapper_2">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -124,7 +124,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %24 = jsir.identifier {"wrapper_1"} -// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %24 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %25 = jsir.identifier {"x"} // SOURCE-NEXT: // %25 = @@ -145,11 +145,11 @@ // SOURCE-NEXT: %12 = jsir.identifier {"console"} // SOURCE-NEXT: // %12 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 221, 224, 0, "log">} +// SOURCE-NEXT: %13 = jsir.member_expression (%12) {#jsir, , "log", 221, 224, 0, "log">} // SOURCE-NEXT: // %13 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %14 = jsir.identifier {"wrapper_2"} -// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %14 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %15 = jsir.numeric_literal {#jsir, 2.000000e+00 : f64} // SOURCE-NEXT: // %15 = 2.000000e+00 : f64 @@ -162,7 +162,7 @@ // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: jsir.expression_statement (%17) // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_3", 250, 259, 4, "wrapper_3">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "wrapper_3", 250, 259, 4, "wrapper_3">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -207,11 +207,11 @@ // SOURCE-NEXT: %18 = jsir.identifier {"console"} // SOURCE-NEXT: // %18 = // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 302, 305, 0, "log">} +// SOURCE-NEXT: %19 = jsir.member_expression (%18) {#jsir, , "log", 302, 305, 0, "log">} // SOURCE-NEXT: // %19 = // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %20 = jsir.identifier {"wrapper_3"} -// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir_builtin, 1.000000e+02 : f64, "+">>> +// SOURCE-NEXT: // %20 = #jsir_builtin, #jsir_builtin, 1.000000e+02 : f64, "+">>> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %21 = jsir.numeric_literal {#jsir, 3.000000e+00 : f64} // SOURCE-NEXT: // %21 = 3.000000e+00 : f64 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 426dcce..1743fa7 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 @@ -240,7 +240,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 2609, 2611, 10, "hi">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 2609, 2611, 10, "hi">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -323,7 +323,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %39 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %40 = jsir.object_property (%39) {#jsir, , 2682, 2689, 10, "etVrZ", "'etVrZ'", "etVrZ">, false} +// SOURCE-NEXT: %40 = jsir.object_property (%39) {#jsir, , 2682, 2689, 10, "etVrZ", "'etVrZ'", "etVrZ">, false} // SOURCE-NEXT: // %40 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %41 = jsir.identifier {"_0x7ba5a6"} @@ -335,7 +335,7 @@ // SOURCE-NEXT: %43 = jsir.call_expression (%41, %42) // SOURCE-NEXT: // %43 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %44 = jsir.object_property (%43) {#jsir, , 2773, 2780, 10, "sxCSL", "'sxCSL'", "sxCSL">, false} +// SOURCE-NEXT: %44 = jsir.object_property (%43) {#jsir, , 2773, 2780, 10, "sxCSL", "'sxCSL'", "sxCSL">, false} // SOURCE-NEXT: // %44 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %45 = jsir.identifier {"_0x7ba5a6"} @@ -347,7 +347,7 @@ // SOURCE-NEXT: %47 = jsir.call_expression (%45, %46) // SOURCE-NEXT: // %47 = "kIjEz" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , 2804, 2811, 10, "lJTym", "'lJTym'", "lJTym">, false} +// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , 2804, 2811, 10, "lJTym", "'lJTym'", "lJTym">, false} // SOURCE-NEXT: // %48 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %49 = jsir.identifier {"_0x4a5b93"} @@ -371,7 +371,7 @@ // SOURCE-NEXT: %55 = jsir.binary_expression (%51, %54) {"+"} // SOURCE-NEXT: // %55 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 2835, 2842, 10, "TNzdU", "'TNzdU'", "TNzdU">, false} +// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 2835, 2842, 10, "TNzdU", "'TNzdU'", "TNzdU">, false} // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.function_expression {false, false} ({ @@ -414,7 +414,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %57 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 2885, 2892, 10, "SQlWw", "'SQlWw'", "SQlWw">, false} +// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 2885, 2892, 10, "SQlWw", "'SQlWw'", "SQlWw">, false} // SOURCE-NEXT: // %58 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %59 = jsir.identifier {"_0x4a5b93"} @@ -426,7 +426,7 @@ // SOURCE-NEXT: %61 = jsir.call_expression (%59, %60) // SOURCE-NEXT: // %61 = "hrAqI" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 2974, 2981, 10, "OBZKc", "'OBZKc'", "OBZKc">, false} +// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 2974, 2981, 10, "OBZKc", "'OBZKc'", "OBZKc">, false} // SOURCE-NEXT: // %62 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.identifier {"_0x7ba5a6"} @@ -438,7 +438,7 @@ // SOURCE-NEXT: %65 = jsir.call_expression (%63, %64) // SOURCE-NEXT: // %65 = "TYmVI" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 3005, 3012, 10, "aPTdp", "'aPTdp'", "aPTdp">, false} +// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 3005, 3012, 10, "aPTdp", "'aPTdp'", "aPTdp">, false} // SOURCE-NEXT: // %66 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %67 = jsir.identifier {"_0x4a5b93"} @@ -450,7 +450,7 @@ // SOURCE-NEXT: %69 = jsir.call_expression (%67, %68) // SOURCE-NEXT: // %69 = "xOSeP" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %70 = jsir.object_property (%69) {#jsir, , 3036, 3043, 10, "yeHiJ", "'yeHiJ'", "yeHiJ">, false} +// SOURCE-NEXT: %70 = jsir.object_property (%69) {#jsir, , 3036, 3043, 10, "yeHiJ", "'yeHiJ'", "yeHiJ">, false} // SOURCE-NEXT: // %70 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %71 = jsir.function_expression {false, false} ({ @@ -493,7 +493,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %71 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %72 = jsir.object_property (%71) {#jsir, , 3067, 3074, 10, "zYkRa", "'zYkRa'", "zYkRa">, false} +// SOURCE-NEXT: %72 = jsir.object_property (%71) {#jsir, , 3067, 3074, 10, "zYkRa", "'zYkRa'", "zYkRa">, false} // SOURCE-NEXT: // %72 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %73 = jsir.function_expression {false, false} ({ @@ -536,7 +536,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %73 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %74 = jsir.object_property (%73) {#jsir, , 3155, 3162, 10, "vhxzb", "'vhxzb'", "vhxzb">, false} +// SOURCE-NEXT: %74 = jsir.object_property (%73) {#jsir, , 3155, 3162, 10, "vhxzb", "'vhxzb'", "vhxzb">, false} // SOURCE-NEXT: // %74 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %75 = jsir.function_expression {false, false} ({ @@ -573,7 +573,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %75 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %76 = jsir.object_property (%75) {#jsir, , 3242, 3249, 10, "nlNip", "'nlNip'", "nlNip">, false} +// SOURCE-NEXT: %76 = jsir.object_property (%75) {#jsir, , 3242, 3249, 10, "nlNip", "'nlNip'", "nlNip">, false} // SOURCE-NEXT: // %76 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %77 = jsir.identifier {"_0x7ba5a6"} @@ -585,13 +585,13 @@ // SOURCE-NEXT: %79 = jsir.call_expression (%77, %78) // SOURCE-NEXT: // %79 = "log" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %80 = jsir.object_property (%79) {#jsir, , 3310, 3317, 10, "DKUGl", "'DKUGl'", "DKUGl">, false} +// SOURCE-NEXT: %80 = jsir.object_property (%79) {#jsir, , 3310, 3317, 10, "DKUGl", "'DKUGl'", "DKUGl">, false} // SOURCE-NEXT: // %80 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %81 = jsir.string_literal {#jsir, "warn"} // SOURCE-NEXT: // %81 = "warn" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %82 = jsir.object_property (%81) {#jsir, , 3341, 3348, 10, "nfaFT", "'nfaFT'", "nfaFT">, false} +// SOURCE-NEXT: %82 = jsir.object_property (%81) {#jsir, , 3341, 3348, 10, "nfaFT", "'nfaFT'", "nfaFT">, false} // SOURCE-NEXT: // %82 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %83 = jsir.identifier {"_0x4a5b93"} @@ -603,7 +603,7 @@ // SOURCE-NEXT: %85 = jsir.call_expression (%83, %84) // SOURCE-NEXT: // %85 = "info" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %86 = jsir.object_property (%85) {#jsir, , 3362, 3369, 10, "UNrAK", "'UNrAK'", "UNrAK">, false} +// SOURCE-NEXT: %86 = jsir.object_property (%85) {#jsir, , 3362, 3369, 10, "UNrAK", "'UNrAK'", "UNrAK">, false} // SOURCE-NEXT: // %86 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %87 = jsir.identifier {"_0x4a5b93"} @@ -615,7 +615,7 @@ // SOURCE-NEXT: %89 = jsir.call_expression (%87, %88) // SOURCE-NEXT: // %89 = "error" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %90 = jsir.object_property (%89) {#jsir, , 3393, 3400, 10, "KwTsZ", "'KwTsZ'", "KwTsZ">, false} +// SOURCE-NEXT: %90 = jsir.object_property (%89) {#jsir, , 3393, 3400, 10, "KwTsZ", "'KwTsZ'", "KwTsZ">, false} // SOURCE-NEXT: // %90 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %91 = jsir.identifier {"_0x7ba5a6"} @@ -627,7 +627,7 @@ // SOURCE-NEXT: %93 = jsir.call_expression (%91, %92) // SOURCE-NEXT: // %93 = "exception" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %94 = jsir.object_property (%93) {#jsir, , 3424, 3431, 10, "EpOIg", "'EpOIg'", "EpOIg">, false} +// SOURCE-NEXT: %94 = jsir.object_property (%93) {#jsir, , 3424, 3431, 10, "EpOIg", "'EpOIg'", "EpOIg">, false} // SOURCE-NEXT: // %94 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %95 = jsir.function_expression {false, false} ({ @@ -670,7 +670,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %95 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %96 = jsir.object_property (%95) {#jsir, , 3455, 3462, 10, "NseOK", "'NseOK'", "NseOK">, false} +// SOURCE-NEXT: %96 = jsir.object_property (%95) {#jsir, , 3455, 3462, 10, "NseOK", "'NseOK'", "NseOK">, false} // SOURCE-NEXT: // %96 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %97 = jsir.function_expression {false, false} ({ @@ -707,7 +707,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %97 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %98 = jsir.object_property (%97) {#jsir, , 3544, 3551, 10, "bhwDB", "'bhwDB'", "bhwDB">, false} +// SOURCE-NEXT: %98 = jsir.object_property (%97) {#jsir, , 3544, 3551, 10, "bhwDB", "'bhwDB'", "bhwDB">, false} // SOURCE-NEXT: // %98 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %99 = jsir.string_literal {#jsir, "Hello Worl"} @@ -719,7 +719,7 @@ // SOURCE-NEXT: %101 = jsir.binary_expression (%99, %100) {"+"} // SOURCE-NEXT: // %101 = "Hello World!" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %102 = jsir.object_property (%101) {#jsir, , 3612, 3619, 10, "zPoYh", "'zPoYh'", "zPoYh">, false} +// SOURCE-NEXT: %102 = jsir.object_property (%101) {#jsir, , 3612, 3619, 10, "zPoYh", "'zPoYh'", "zPoYh">, false} // SOURCE-NEXT: // %102 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%40, %44, %48, %56, %58, %62, %66, %70, %72, %74, %76, %80, %82, %86, %90, %94, %96, %98, %102) @@ -814,7 +814,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %74 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %74 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %74 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %75 = jsir.identifier {"_0xac9435"} // SOURCE-NEXT: // %75 = #jsir_builtin @@ -826,7 +826,7 @@ // SOURCE-NEXT: // %77 = "etVrZ" // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %78 = jsir.member_expression (%74, %77) -// SOURCE-NEXT: // %78 = #jsir_builtin, #jsir, "!==">> +// SOURCE-NEXT: // %78 = #jsir_builtin, #jsir, "!==">> // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %79 = jsir.identifier {"_0x2aedf1"} // SOURCE-NEXT: // %79 = @@ -848,11 +848,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %54 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 3771, 3778, 18, "RSHvn", "'RSHvn'", "RSHvn">, false} +// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 3771, 3778, 18, "RSHvn", "'RSHvn'", "RSHvn">, false} // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %56 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.identifier {"_0x4c20ac"} // SOURCE-NEXT: // %57 = #jsir_builtin @@ -866,11 +866,11 @@ // SOURCE-NEXT: %60 = jsir.member_expression (%56, %59) // SOURCE-NEXT: // %60 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %61 = jsir.object_property (%60) {#jsir, , 3943, 3950, 18, "SvRpW", "'SvRpW'", "SvRpW">, false} +// SOURCE-NEXT: %61 = jsir.object_property (%60) {#jsir, , 3943, 3950, 18, "SvRpW", "'SvRpW'", "SvRpW">, false} // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %62 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.identifier {"_0x7aca67"} // SOURCE-NEXT: // %63 = #jsir_builtin @@ -884,7 +884,7 @@ // SOURCE-NEXT: %66 = jsir.member_expression (%62, %65) // SOURCE-NEXT: // %66 = "kIjEz" // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %67 = jsir.object_property (%66) {#jsir, , 3991, 3998, 18, "gGwwI", "'gGwwI'", "gGwwI">, false} +// SOURCE-NEXT: %67 = jsir.object_property (%66) {#jsir, , 3991, 3998, 18, "gGwwI", "'gGwwI'", "gGwwI">, false} // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %68 = jsir.function_expression {false, false} ({ @@ -927,11 +927,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %68 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %69 = jsir.object_property (%68) {#jsir, , 4039, 4046, 18, "TPnNF", "'TPnNF'", "TPnNF">, false} +// SOURCE-NEXT: %69 = jsir.object_property (%68) {#jsir, , 4039, 4046, 18, "TPnNF", "'TPnNF'", "TPnNF">, false} // SOURCE-NEXT: // %69 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %70 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %70 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %71 = jsir.string_literal {#jsir, "TNzdU"} // SOURCE-NEXT: // %71 = "TNzdU" @@ -939,7 +939,7 @@ // SOURCE-NEXT: %72 = jsir.member_expression (%70, %71) // SOURCE-NEXT: // %72 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %73 = jsir.object_property (%72) {#jsir, , 4146, 4153, 18, "dibht", "'dibht'", "dibht">, false} +// SOURCE-NEXT: %73 = jsir.object_property (%72) {#jsir, , 4146, 4153, 18, "dibht", "'dibht'", "dibht">, false} // SOURCE-NEXT: // %73 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%55, %61, %67, %69, %73) @@ -1058,7 +1058,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %59 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %60 = jsir.object_property (%59) {#jsir, , 4348, 4355, 21, "rvMvc", "'rvMvc'", "rvMvc">, false} +// SOURCE-NEXT: %60 = jsir.object_property (%59) {#jsir, , 4348, 4355, 21, "rvMvc", "'rvMvc'", "rvMvc">, false} // SOURCE-NEXT: // %60 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %61 = jsir.function_expression {false, false} ({ @@ -1099,7 +1099,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %81 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %82 = jsir.identifier {"_0x52f6d9"} // SOURCE-NEXT: // %82 = #jsir_builtin @@ -1111,7 +1111,7 @@ // SOURCE-NEXT: // %84 = "TPnNF" // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %85 = jsir.member_expression (%81, %84) -// SOURCE-NEXT: // %85 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %85 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %86 = jsir.identifier {"_0x29bd31"} // SOURCE-NEXT: // %86 = @@ -1133,11 +1133,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 4460, 4467, 21, "PUAQc", "'PUAQc'", "PUAQc">, false} +// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 4460, 4467, 21, "PUAQc", "'PUAQc'", "PUAQc">, false} // SOURCE-NEXT: // %62 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %63 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %63 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %64 = jsir.identifier {"_0x5e0f91"} // SOURCE-NEXT: // %64 = #jsir_builtin @@ -1151,7 +1151,7 @@ // SOURCE-NEXT: %67 = jsir.member_expression (%63, %66) // SOURCE-NEXT: // %67 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 4640, 4647, 21, "vYXjF", "'vYXjF'", "vYXjF">, false} +// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 4640, 4647, 21, "vYXjF", "'vYXjF'", "vYXjF">, false} // SOURCE-NEXT: // %68 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %69 = jsir.identifier {"_0x5e0f91"} @@ -1187,7 +1187,7 @@ // SOURCE-NEXT: %79 = jsir.binary_expression (%77, %78) {"+"} // SOURCE-NEXT: // %79 = "{}.constructor(\22return this\22)( )" // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %80 = jsir.object_property (%79) {#jsir, , 4690, 4697, 21, "qDHJo", "'qDHJo'", "qDHJo">, false} +// SOURCE-NEXT: %80 = jsir.object_property (%79) {#jsir, , 4690, 4697, 21, "qDHJo", "'qDHJo'", "qDHJo">, false} // SOURCE-NEXT: // %80 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%60, %62, %68, %80) @@ -1289,7 +1289,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %61 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %61 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %62 = jsir.identifier {"_0x40d5a6"} // SOURCE-NEXT: // %62 = #jsir_builtin @@ -1301,10 +1301,10 @@ // SOURCE-NEXT: // %64 = "RSHvn" // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %65 = jsir.member_expression (%61, %64) -// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>> +// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %66 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %67 = jsir.identifier {"_0x4d80ef"} // SOURCE-NEXT: // %67 = #jsir_builtin @@ -1319,7 +1319,7 @@ // SOURCE-NEXT: // %70 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %71 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir_builtin, 4.370000e+02 : f64>>, #jsir, #jsir>>, "SvRpW", #jsir_builtin, #jsir_builtin, 4.390000e+02 : f64>>, "gGwwI", #jsir_builtin, #jsir_builtin, 4.430000e+02 : f64>>, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %72 = jsir.identifier {"_0x4d80ef"} // SOURCE-NEXT: // %72 = #jsir_builtin @@ -1670,13 +1670,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %127 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %127 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %128 = jsir.string_literal {#jsir, "SQlWw"} // SOURCE-NEXT: // %128 = "SQlWw" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %129 = jsir.member_expression (%127, %128) -// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %130 = jsir.identifier {"_0x2080eb"} // SOURCE-NEXT: // %130 = @@ -1698,7 +1698,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %117 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: %118 = jsir.object_property (%117) {#jsir, , 5901, 5908, 29, "qtcAH", "'qtcAH'", "qtcAH">, false} +// SOURCE-NEXT: %118 = jsir.object_property (%117) {#jsir, , 5901, 5908, 29, "qtcAH", "'qtcAH'", "qtcAH">, false} // SOURCE-NEXT: // %118 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %119 = jsir.identifier {"_0x5aa537"} @@ -1722,7 +1722,7 @@ // SOURCE-NEXT: %125 = jsir.binary_expression (%121, %124) {"+"} // SOURCE-NEXT: // %125 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: %126 = jsir.object_property (%125) {#jsir, , 6045, 6052, 29, "vHpQf", "'vHpQf'", "vHpQf">, false} +// SOURCE-NEXT: %126 = jsir.object_property (%125) {#jsir, , 6045, 6052, 29, "vHpQf", "'vHpQf'", "vHpQf">, false} // SOURCE-NEXT: // %126 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%118, %126) @@ -1738,7 +1738,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %97 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %97 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %97 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %98 = jsir.identifier {"_0x5aa537"} // SOURCE-NEXT: // %98 = #jsir_builtin @@ -1753,7 +1753,7 @@ // SOURCE-NEXT: // %101 = "hrAqI" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %102 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %102 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %103 = jsir.identifier {"_0x5aa537"} // SOURCE-NEXT: // %103 = #jsir_builtin @@ -1801,7 +1801,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %109 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %109 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %110 = jsir.string_literal {#jsir, "yeHiJ"} // SOURCE-NEXT: // %110 = "yeHiJ" @@ -1810,7 +1810,7 @@ // SOURCE-NEXT: // %111 = "xOSeP" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %112 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %112 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %112 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %113 = jsir.identifier {"_0x887e8"} // SOURCE-NEXT: // %113 = #jsir_builtin @@ -1835,7 +1835,7 @@ // SOURCE-NEXT: // %118 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %119 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %119 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %119 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %120 = jsir.identifier {"_0x5aa537"} // SOURCE-NEXT: // %120 = #jsir_builtin @@ -1847,13 +1847,13 @@ // SOURCE-NEXT: // %122 = "zYkRa" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %123 = jsir.member_expression (%119, %122) -// SOURCE-NEXT: // %123 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %123 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %124 = jsir.identifier {"Function"} // SOURCE-NEXT: // %124 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %125 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %125 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %126 = jsir.identifier {"_0x887e8"} // SOURCE-NEXT: // %126 = #jsir_builtin @@ -1865,10 +1865,10 @@ // SOURCE-NEXT: // %128 = "vhxzb" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %129 = jsir.member_expression (%125, %128) -// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %129 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %130 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %130 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %131 = jsir.identifier {"_0x5aa537"} // SOURCE-NEXT: // %131 = #jsir_builtin @@ -1880,10 +1880,10 @@ // SOURCE-NEXT: // %133 = "vhxzb" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %134 = jsir.member_expression (%130, %133) -// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %134 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %135 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %135 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %136 = jsir.identifier {"_0x887e8"} // SOURCE-NEXT: // %136 = #jsir_builtin @@ -2224,7 +2224,7 @@ // SOURCE-NEXT: // %48 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %49 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %49 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %49 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %50 = jsir.identifier {"_0x9c5c81"} // SOURCE-NEXT: // %50 = #jsir_builtin @@ -2236,7 +2236,7 @@ // SOURCE-NEXT: // %52 = "nlNip" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %53 = jsir.member_expression (%49, %52) -// SOURCE-NEXT: // %53 = #jsir_builtin, >> +// SOURCE-NEXT: // %53 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %54 = jsir.identifier {"_0x3f1471"} // SOURCE-NEXT: // %54 = @@ -2308,7 +2308,7 @@ // SOURCE-NEXT: // %71 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %72 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %72 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %73 = jsir.identifier {"_0x9c5c81"} // SOURCE-NEXT: // %73 = #jsir_builtin @@ -2323,7 +2323,7 @@ // SOURCE-NEXT: // %76 = "log" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %77 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %77 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %77 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %78 = jsir.string_literal {#jsir, "nfaFT"} // SOURCE-NEXT: // %78 = "nfaFT" @@ -2332,7 +2332,7 @@ // SOURCE-NEXT: // %79 = "warn" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %80 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %80 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %81 = jsir.identifier {"_0x4710fc"} // SOURCE-NEXT: // %81 = #jsir_builtin @@ -2347,7 +2347,7 @@ // SOURCE-NEXT: // %84 = "info" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %85 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %85 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %85 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %86 = jsir.string_literal {#jsir, "KwTsZ"} // SOURCE-NEXT: // %86 = "KwTsZ" @@ -2356,7 +2356,7 @@ // SOURCE-NEXT: // %87 = "error" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %88 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %88 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %89 = jsir.string_literal {#jsir, "EpOIg"} // SOURCE-NEXT: // %89 = "EpOIg" @@ -2445,7 +2445,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %39 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %39 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %40 = jsir.identifier {"_0x4710fc"} // SOURCE-NEXT: // %40 = #jsir_builtin @@ -2457,7 +2457,7 @@ // SOURCE-NEXT: // %42 = "NseOK" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %43 = jsir.member_expression (%39, %42) -// SOURCE-NEXT: // %43 = #jsir_builtin, #jsir, "<">> +// SOURCE-NEXT: // %43 = #jsir_builtin, #jsir, "<">> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %44 = jsir.identifier {"_0x19ea73"} // SOURCE-NEXT: // %44 = @@ -2741,13 +2741,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %2 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %3 = jsir.string_literal {#jsir, "bhwDB"} // SOURCE-NEXT: // %3 = "bhwDB" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %4 = jsir.member_expression (%2, %3) -// SOURCE-NEXT: // %4 = #jsir_builtin, >> +// SOURCE-NEXT: // %4 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %5 = jsir.identifier {"_0x25fd74"} // SOURCE-NEXT: // %5 = @@ -2771,7 +2771,7 @@ // SOURCE-NEXT: // %11 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %12 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %12 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> +// SOURCE-NEXT: // %12 = #jsir_builtin, #jsir, "!==">>, "sxCSL", #jsir_builtin, 4.520000e+02 : f64>, "lJTym", #jsir_builtin, 4.320000e+02 : f64>, "TNzdU", #jsir_builtin, 4.220000e+02 : f64>, #jsir_builtin, 4.440000e+02 : f64>, "+">, "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", #jsir_builtin, 4.130000e+02 : f64>, "aPTdp", #jsir_builtin, 4.090000e+02 : f64>, "yeHiJ", #jsir_builtin, 4.010000e+02 : f64>, "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", #jsir_builtin, 4.450000e+02 : f64>, "nfaFT", "warn", "UNrAK", #jsir_builtin, 4.070000e+02 : f64>, "KwTsZ", #jsir_builtin, 4.050000e+02 : f64>, "EpOIg", #jsir_builtin, 4.110000e+02 : f64>, "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", #jsir_builtin> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %13 = jsir.identifier {"_0x7ba5a6"} // SOURCE-NEXT: // %13 = #jsir_builtin 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 5b69419..a580497 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 @@ -240,7 +240,7 @@ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } -// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 2609, 2611, 10, "hi">} ({ +// SOURCE-NEXT: jsir.function_declaration {false, false, #jsir, , "hi", 2609, 2611, 10, "hi">} ({ // SOURCE-NEXT: ^bb0: // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } @@ -323,25 +323,25 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %35 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %36 = jsir.object_property (%35) {#jsir, , 2694, 2701, 10, "etVrZ", "'etVrZ'", "etVrZ">, false} +// SOURCE-NEXT: %36 = jsir.object_property (%35) {#jsir, , 2694, 2701, 10, "etVrZ", "'etVrZ'", "etVrZ">, false} // SOURCE-NEXT: // %36 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %37 = jsir.string_literal {#jsir, "FidzV"} // SOURCE-NEXT: // %37 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %38 = jsir.object_property (%37) {#jsir, , 2786, 2793, 10, "sxCSL", "'sxCSL'", "sxCSL">, false} +// SOURCE-NEXT: %38 = jsir.object_property (%37) {#jsir, , 2786, 2793, 10, "sxCSL", "'sxCSL'", "sxCSL">, false} // SOURCE-NEXT: // %38 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %39 = jsir.string_literal {#jsir, "kIjEz"} // SOURCE-NEXT: // %39 = "kIjEz" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %40 = jsir.object_property (%39) {#jsir, , 2808, 2815, 10, "lJTym", "'lJTym'", "lJTym">, false} +// SOURCE-NEXT: %40 = jsir.object_property (%39) {#jsir, , 2808, 2815, 10, "lJTym", "'lJTym'", "lJTym">, false} // SOURCE-NEXT: // %40 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %41 = jsir.string_literal {#jsir, "return (function() "} // SOURCE-NEXT: // %41 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %42 = jsir.object_property (%41) {#jsir, , 2830, 2837, 10, "TNzdU", "'TNzdU'", "TNzdU">, false} +// SOURCE-NEXT: %42 = jsir.object_property (%41) {#jsir, , 2830, 2837, 10, "TNzdU", "'TNzdU'", "TNzdU">, false} // SOURCE-NEXT: // %42 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %43 = jsir.function_expression {false, false} ({ @@ -384,25 +384,25 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %43 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %44 = jsir.object_property (%43) {#jsir, , 2866, 2873, 10, "SQlWw", "'SQlWw'", "SQlWw">, false} +// SOURCE-NEXT: %44 = jsir.object_property (%43) {#jsir, , 2866, 2873, 10, "SQlWw", "'SQlWw'", "SQlWw">, false} // SOURCE-NEXT: // %44 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %45 = jsir.string_literal {#jsir, "hrAqI"} // SOURCE-NEXT: // %45 = "hrAqI" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %46 = jsir.object_property (%45) {#jsir, , 2956, 2963, 10, "OBZKc", "'OBZKc'", "OBZKc">, false} +// SOURCE-NEXT: %46 = jsir.object_property (%45) {#jsir, , 2956, 2963, 10, "OBZKc", "'OBZKc'", "OBZKc">, false} // SOURCE-NEXT: // %46 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %47 = jsir.string_literal {#jsir, "TYmVI"} // SOURCE-NEXT: // %47 = "TYmVI" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , 2978, 2985, 10, "aPTdp", "'aPTdp'", "aPTdp">, false} +// SOURCE-NEXT: %48 = jsir.object_property (%47) {#jsir, , 2978, 2985, 10, "aPTdp", "'aPTdp'", "aPTdp">, false} // SOURCE-NEXT: // %48 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %49 = jsir.string_literal {#jsir, "xOSeP"} // SOURCE-NEXT: // %49 = "xOSeP" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %50 = jsir.object_property (%49) {#jsir, , 3000, 3007, 10, "yeHiJ", "'yeHiJ'", "yeHiJ">, false} +// SOURCE-NEXT: %50 = jsir.object_property (%49) {#jsir, , 3000, 3007, 10, "yeHiJ", "'yeHiJ'", "yeHiJ">, false} // SOURCE-NEXT: // %50 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %51 = jsir.function_expression {false, false} ({ @@ -445,7 +445,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %51 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %52 = jsir.object_property (%51) {#jsir, , 3022, 3029, 10, "zYkRa", "'zYkRa'", "zYkRa">, false} +// SOURCE-NEXT: %52 = jsir.object_property (%51) {#jsir, , 3022, 3029, 10, "zYkRa", "'zYkRa'", "zYkRa">, false} // SOURCE-NEXT: // %52 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %53 = jsir.function_expression {false, false} ({ @@ -488,7 +488,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %53 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %54 = jsir.object_property (%53) {#jsir, , 3111, 3118, 10, "vhxzb", "'vhxzb'", "vhxzb">, false} +// SOURCE-NEXT: %54 = jsir.object_property (%53) {#jsir, , 3111, 3118, 10, "vhxzb", "'vhxzb'", "vhxzb">, false} // SOURCE-NEXT: // %54 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %55 = jsir.function_expression {false, false} ({ @@ -525,37 +525,37 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 3199, 3206, 10, "nlNip", "'nlNip'", "nlNip">, false} +// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 3199, 3206, 10, "nlNip", "'nlNip'", "nlNip">, false} // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.string_literal {#jsir, "log"} // SOURCE-NEXT: // %57 = "log" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 3268, 3275, 10, "DKUGl", "'DKUGl'", "DKUGl">, false} +// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 3268, 3275, 10, "DKUGl", "'DKUGl'", "DKUGl">, false} // SOURCE-NEXT: // %58 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %59 = jsir.string_literal {#jsir, "warn"} // SOURCE-NEXT: // %59 = "warn" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %60 = jsir.object_property (%59) {#jsir, , 3288, 3295, 10, "nfaFT", "'nfaFT'", "nfaFT">, false} +// SOURCE-NEXT: %60 = jsir.object_property (%59) {#jsir, , 3288, 3295, 10, "nfaFT", "'nfaFT'", "nfaFT">, false} // SOURCE-NEXT: // %60 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %61 = jsir.string_literal {#jsir, "info"} // SOURCE-NEXT: // %61 = "info" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 3309, 3316, 10, "UNrAK", "'UNrAK'", "UNrAK">, false} +// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 3309, 3316, 10, "UNrAK", "'UNrAK'", "UNrAK">, false} // SOURCE-NEXT: // %62 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.string_literal {#jsir, "error"} // SOURCE-NEXT: // %63 = "error" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 3330, 3337, 10, "KwTsZ", "'KwTsZ'", "KwTsZ">, false} +// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 3330, 3337, 10, "KwTsZ", "'KwTsZ'", "KwTsZ">, false} // SOURCE-NEXT: // %64 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %65 = jsir.string_literal {#jsir, "exception"} // SOURCE-NEXT: // %65 = "exception" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 3352, 3359, 10, "EpOIg", "'EpOIg'", "EpOIg">, false} +// SOURCE-NEXT: %66 = jsir.object_property (%65) {#jsir, , 3352, 3359, 10, "EpOIg", "'EpOIg'", "EpOIg">, false} // SOURCE-NEXT: // %66 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %67 = jsir.function_expression {false, false} ({ @@ -598,7 +598,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %67 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 3378, 3385, 10, "NseOK", "'NseOK'", "NseOK">, false} +// SOURCE-NEXT: %68 = jsir.object_property (%67) {#jsir, , 3378, 3385, 10, "NseOK", "'NseOK'", "NseOK">, false} // SOURCE-NEXT: // %68 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %69 = jsir.function_expression {false, false} ({ @@ -635,13 +635,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %69 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %70 = jsir.object_property (%69) {#jsir, , 3468, 3475, 10, "bhwDB", "'bhwDB'", "bhwDB">, false} +// SOURCE-NEXT: %70 = jsir.object_property (%69) {#jsir, , 3468, 3475, 10, "bhwDB", "'bhwDB'", "bhwDB">, false} // SOURCE-NEXT: // %70 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %71 = jsir.string_literal {#jsir, "Hello World!"} // SOURCE-NEXT: // %71 = "Hello World!" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } -// SOURCE-NEXT: %72 = jsir.object_property (%71) {#jsir, , 3537, 3544, 10, "zPoYh", "'zPoYh'", "zPoYh">, false} +// SOURCE-NEXT: %72 = jsir.object_property (%71) {#jsir, , 3537, 3544, 10, "zPoYh", "'zPoYh'", "zPoYh">, false} // SOURCE-NEXT: // %72 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%36, %38, %40, %42, %44, %46, %48, %50, %52, %54, %56, %58, %60, %62, %64, %66, %68, %70, %72) @@ -736,13 +736,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %66 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %66 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %67 = jsir.string_literal {#jsir, "etVrZ"} // SOURCE-NEXT: // %67 = "etVrZ" // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %68 = jsir.member_expression (%66, %67) -// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir, "!==">> +// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir, "!==">> // SOURCE-NEXT: // State [default = ] { <_0xac9435#19 : #jsir_builtin> } // SOURCE-NEXT: %69 = jsir.identifier {"_0x2aedf1"} // SOURCE-NEXT: // %69 = @@ -764,11 +764,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %50 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %51 = jsir.object_property (%50) {#jsir, , 3689, 3696, 18, "RSHvn", "'RSHvn'", "RSHvn">, false} +// SOURCE-NEXT: %51 = jsir.object_property (%50) {#jsir, , 3689, 3696, 18, "RSHvn", "'RSHvn'", "RSHvn">, false} // SOURCE-NEXT: // %51 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %52 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %52 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %52 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %53 = jsir.string_literal {#jsir, "sxCSL"} // SOURCE-NEXT: // %53 = "sxCSL" @@ -776,11 +776,11 @@ // SOURCE-NEXT: %54 = jsir.member_expression (%52, %53) // SOURCE-NEXT: // %54 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 3837, 3844, 18, "SvRpW", "'SvRpW'", "SvRpW">, false} +// SOURCE-NEXT: %55 = jsir.object_property (%54) {#jsir, , 3837, 3844, 18, "SvRpW", "'SvRpW'", "SvRpW">, false} // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %56 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %56 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.string_literal {#jsir, "lJTym"} // SOURCE-NEXT: // %57 = "lJTym" @@ -788,7 +788,7 @@ // SOURCE-NEXT: %58 = jsir.member_expression (%56, %57) // SOURCE-NEXT: // %58 = "kIjEz" // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %59 = jsir.object_property (%58) {#jsir, , 3872, 3879, 18, "gGwwI", "'gGwwI'", "gGwwI">, false} +// SOURCE-NEXT: %59 = jsir.object_property (%58) {#jsir, , 3872, 3879, 18, "gGwwI", "'gGwwI'", "gGwwI">, false} // SOURCE-NEXT: // %59 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %60 = jsir.function_expression {false, false} ({ @@ -831,11 +831,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %60 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %61 = jsir.object_property (%60) {#jsir, , 3907, 3914, 18, "TPnNF", "'TPnNF'", "TPnNF">, false} +// SOURCE-NEXT: %61 = jsir.object_property (%60) {#jsir, , 3907, 3914, 18, "TPnNF", "'TPnNF'", "TPnNF">, false} // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %62 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.string_literal {#jsir, "TNzdU"} // SOURCE-NEXT: // %63 = "TNzdU" @@ -843,7 +843,7 @@ // SOURCE-NEXT: %64 = jsir.member_expression (%62, %63) // SOURCE-NEXT: // %64 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } -// SOURCE-NEXT: %65 = jsir.object_property (%64) {#jsir, , 4003, 4010, 18, "dibht", "'dibht'", "dibht">, false} +// SOURCE-NEXT: %65 = jsir.object_property (%64) {#jsir, , 4003, 4010, 18, "dibht", "'dibht'", "dibht">, false} // SOURCE-NEXT: // %65 = // SOURCE-NEXT: // State [default = ] { <_0x4c20ac#18 : #jsir_builtin> <_0x7aca67#18 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%51, %55, %59, %61, %65) @@ -962,7 +962,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %55 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 4207, 4214, 21, "rvMvc", "'rvMvc'", "rvMvc">, false} +// SOURCE-NEXT: %56 = jsir.object_property (%55) {#jsir, , 4207, 4214, 21, "rvMvc", "'rvMvc'", "rvMvc">, false} // SOURCE-NEXT: // %56 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.function_expression {false, false} ({ @@ -1003,13 +1003,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %65 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %65 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %65 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %66 = jsir.string_literal {#jsir, "TPnNF"} // SOURCE-NEXT: // %66 = "TPnNF" // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %67 = jsir.member_expression (%65, %66) -// SOURCE-NEXT: // %67 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %67 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x52f6d9#23 : #jsir_builtin> } // SOURCE-NEXT: %68 = jsir.identifier {"_0x29bd31"} // SOURCE-NEXT: // %68 = @@ -1031,11 +1031,11 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %57 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 4308, 4315, 21, "PUAQc", "'PUAQc'", "PUAQc">, false} +// SOURCE-NEXT: %58 = jsir.object_property (%57) {#jsir, , 4308, 4315, 21, "PUAQc", "'PUAQc'", "PUAQc">, false} // SOURCE-NEXT: // %58 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %59 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %59 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %59 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %60 = jsir.string_literal {#jsir, "dibht"} // SOURCE-NEXT: // %60 = "dibht" @@ -1043,13 +1043,13 @@ // SOURCE-NEXT: %61 = jsir.member_expression (%59, %60) // SOURCE-NEXT: // %61 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 4464, 4471, 21, "vYXjF", "'vYXjF'", "vYXjF">, false} +// SOURCE-NEXT: %62 = jsir.object_property (%61) {#jsir, , 4464, 4471, 21, "vYXjF", "'vYXjF'", "vYXjF">, false} // SOURCE-NEXT: // %62 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.string_literal {#jsir, "{}.constructor(\22return this\22)( )"} // SOURCE-NEXT: // %63 = "{}.constructor(\22return this\22)( )" // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } -// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 4501, 4508, 21, "qDHJo", "'qDHJo'", "qDHJo">, false} +// SOURCE-NEXT: %64 = jsir.object_property (%63) {#jsir, , 4501, 4508, 21, "qDHJo", "'qDHJo'", "qDHJo">, false} // SOURCE-NEXT: // %64 = // SOURCE-NEXT: // State [default = ] { <_0x5e0f91#21 : #jsir_builtin> <_0xb3bca#21 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%56, %58, %62, %64) @@ -1151,16 +1151,16 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %57 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %57 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %57 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %58 = jsir.string_literal {#jsir, "RSHvn"} // SOURCE-NEXT: // %58 = "RSHvn" // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %59 = jsir.member_expression (%57, %58) -// SOURCE-NEXT: // %59 = #jsir_builtin, "etVrZ">, #jsir, #jsir>> +// SOURCE-NEXT: // %59 = #jsir_builtin, "etVrZ">, #jsir, #jsir>> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %60 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %60 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %60 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %61 = jsir.string_literal {#jsir, "SvRpW"} // SOURCE-NEXT: // %61 = "SvRpW" @@ -1169,7 +1169,7 @@ // SOURCE-NEXT: // %62 = "FidzV" // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.identifier {"_0x3fafb9"} -// SOURCE-NEXT: // %63 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> +// SOURCE-NEXT: // %63 = #jsir_builtin, "etVrZ">, #jsir, #jsir>>, "SvRpW", #jsir_builtin, "sxCSL">, "gGwwI", #jsir_builtin, "lJTym">, "TPnNF", #jsir_builtin, #jsir, "+">>, "dibht", #jsir_builtin, "TNzdU">> // SOURCE-NEXT: // State [default = ] { <_0x40d5a6#24 : #jsir_builtin> <_0x4d80ef#24 : #jsir_builtin> } // SOURCE-NEXT: %64 = jsir.string_literal {#jsir, "gGwwI"} // SOURCE-NEXT: // %64 = "gGwwI" @@ -1502,13 +1502,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %101 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %101 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %101 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %102 = jsir.string_literal {#jsir, "SQlWw"} // SOURCE-NEXT: // %102 = "SQlWw" // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %103 = jsir.member_expression (%101, %102) -// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { } // SOURCE-NEXT: %104 = jsir.identifier {"_0x2080eb"} // SOURCE-NEXT: // %104 = @@ -1530,13 +1530,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // %97 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: %98 = jsir.object_property (%97) {#jsir, , 5342, 5349, 29, "qtcAH", "'qtcAH'", "qtcAH">, false} +// SOURCE-NEXT: %98 = jsir.object_property (%97) {#jsir, , 5342, 5349, 29, "qtcAH", "'qtcAH'", "qtcAH">, false} // SOURCE-NEXT: // %98 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %99 = jsir.string_literal {#jsir, "return (function() "} // SOURCE-NEXT: // %99 = "return (function() " // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } -// SOURCE-NEXT: %100 = jsir.object_property (%99) {#jsir, , 5463, 5470, 29, "vHpQf", "'vHpQf'", "vHpQf">, false} +// SOURCE-NEXT: %100 = jsir.object_property (%99) {#jsir, , 5463, 5470, 29, "vHpQf", "'vHpQf'", "vHpQf">, false} // SOURCE-NEXT: // %100 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: jsir.exprs_region_end (%98, %100) @@ -1552,7 +1552,7 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %81 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %81 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %82 = jsir.string_literal {#jsir, "OBZKc"} // SOURCE-NEXT: // %82 = "OBZKc" @@ -1561,7 +1561,7 @@ // SOURCE-NEXT: // %83 = "hrAqI" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %84 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %84 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %84 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %85 = jsir.string_literal {#jsir, "aPTdp"} // SOURCE-NEXT: // %85 = "aPTdp" @@ -1603,7 +1603,7 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %89 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %89 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %90 = jsir.string_literal {#jsir, "yeHiJ"} // SOURCE-NEXT: // %90 = "yeHiJ" @@ -1612,7 +1612,7 @@ // SOURCE-NEXT: // %91 = "xOSeP" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %92 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %92 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %92 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %93 = jsir.string_literal {#jsir, "yeHiJ"} // SOURCE-NEXT: // %93 = "yeHiJ" @@ -1631,37 +1631,37 @@ // SOURCE-NEXT: // %96 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %97 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %97 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %97 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %98 = jsir.string_literal {#jsir, "zYkRa"} // SOURCE-NEXT: // %98 = "zYkRa" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %99 = jsir.member_expression (%97, %98) -// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir>> +// SOURCE-NEXT: // %99 = #jsir_builtin, #jsir>> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %100 = jsir.identifier {"Function"} // SOURCE-NEXT: // %100 = // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %101 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %101 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %101 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %102 = jsir.string_literal {#jsir, "vhxzb"} // SOURCE-NEXT: // %102 = "vhxzb" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %103 = jsir.member_expression (%101, %102) -// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %103 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %104 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %104 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %104 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %105 = jsir.string_literal {#jsir, "vhxzb"} // SOURCE-NEXT: // %105 = "vhxzb" // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %106 = jsir.member_expression (%104, %105) -// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir, "+">> +// SOURCE-NEXT: // %106 = #jsir_builtin, #jsir, "+">> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %107 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %107 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %107 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x5aa537#29 : #jsir_builtin> <_0x887e8#29 : #jsir_builtin> } // SOURCE-NEXT: %108 = jsir.string_literal {#jsir, "TNzdU"} // SOURCE-NEXT: // %108 = "TNzdU" @@ -1912,13 +1912,13 @@ // SOURCE-NEXT: // %44 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %45 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %45 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %45 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %46 = jsir.string_literal {#jsir, "nlNip"} // SOURCE-NEXT: // %46 = "nlNip" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %47 = jsir.member_expression (%45, %46) -// SOURCE-NEXT: // %47 = #jsir_builtin, >> +// SOURCE-NEXT: // %47 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %48 = jsir.identifier {"_0x3f1471"} // SOURCE-NEXT: // %48 = @@ -1978,7 +1978,7 @@ // SOURCE-NEXT: // %61 = // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %62 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %62 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %63 = jsir.string_literal {#jsir, "DKUGl"} // SOURCE-NEXT: // %63 = "DKUGl" @@ -1987,7 +1987,7 @@ // SOURCE-NEXT: // %64 = "log" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %65 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %65 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %66 = jsir.string_literal {#jsir, "nfaFT"} // SOURCE-NEXT: // %66 = "nfaFT" @@ -1996,7 +1996,7 @@ // SOURCE-NEXT: // %67 = "warn" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %68 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %68 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %69 = jsir.string_literal {#jsir, "UNrAK"} // SOURCE-NEXT: // %69 = "UNrAK" @@ -2005,7 +2005,7 @@ // SOURCE-NEXT: // %70 = "info" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %71 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %71 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %72 = jsir.string_literal {#jsir, "KwTsZ"} // SOURCE-NEXT: // %72 = "KwTsZ" @@ -2014,7 +2014,7 @@ // SOURCE-NEXT: // %73 = "error" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %74 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %74 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %74 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %75 = jsir.string_literal {#jsir, "EpOIg"} // SOURCE-NEXT: // %75 = "EpOIg" @@ -2064,13 +2064,13 @@ // SOURCE-NEXT: // // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %35 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %35 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %36 = jsir.string_literal {#jsir, "NseOK"} // SOURCE-NEXT: // %36 = "NseOK" // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %37 = jsir.member_expression (%35, %36) -// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir, "<">> +// SOURCE-NEXT: // %37 = #jsir_builtin, #jsir, "<">> // SOURCE-NEXT: // State [default = ] { <_0x4710fc#28 : #jsir_builtin> <_0x9c5c81#28 : #jsir_builtin> } // SOURCE-NEXT: %38 = jsir.numeric_literal {#jsir, 0.000000e+00 : f64} // SOURCE-NEXT: // %38 = 0.000000e+00 : f64 @@ -2300,13 +2300,13 @@ // SOURCE-NEXT: }) // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %2 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %2 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %3 = jsir.string_literal {#jsir, "bhwDB"} // SOURCE-NEXT: // %3 = "bhwDB" // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %4 = jsir.member_expression (%2, %3) -// SOURCE-NEXT: // %4 = #jsir_builtin, >> +// SOURCE-NEXT: // %4 = #jsir_builtin, >> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %5 = jsir.identifier {"_0x25fd74"} // SOURCE-NEXT: // %5 = @@ -2324,7 +2324,7 @@ // SOURCE-NEXT: // %9 = // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %10 = jsir.identifier {"_0x318ccc"} -// SOURCE-NEXT: // %10 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> +// SOURCE-NEXT: // %10 = #jsir_builtin, #jsir, "!==">>, "sxCSL", "FidzV", "lJTym", "kIjEz", "TNzdU", "return (function() ", "SQlWw", #jsir_builtin, #jsir, "+">>, "OBZKc", "hrAqI", "aPTdp", "TYmVI", "yeHiJ", "xOSeP", "zYkRa", #jsir_builtin, #jsir>>, "vhxzb", #jsir_builtin, #jsir, "+">>, "nlNip", #jsir_builtin, >>, "DKUGl", "log", "nfaFT", "warn", "UNrAK", "info", "KwTsZ", "error", "EpOIg", "exception", "NseOK", #jsir_builtin, #jsir, "<">>, "bhwDB", #jsir_builtin, >>, "zPoYh", "Hello World!"> // SOURCE-NEXT: // State [default = ] { <_0x4a5b93#10 : #jsir_builtin> <_0x7ba5a6#10 : #jsir_builtin> } // SOURCE-NEXT: %11 = jsir.string_literal {#jsir, "zPoYh"} // SOURCE-NEXT: // %11 = "zPoYh" diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/BUILD.template b/maldoca/js/ir/transforms/peel_parentheses/tests/BUILD.template index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/BUILD.template +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/BUILD.template @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/BUILD b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/BUILD +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/lvalue/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [ diff --git a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/BUILD b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/BUILD index 9f511e8..af55e6c 100644 --- a/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/BUILD +++ b/maldoca/js/ir/transforms/peel_parentheses/tests/rvalue/BUILD @@ -18,11 +18,19 @@ package(default_applicable_licenses = ["//:license"]) licenses(["notice"]) +filegroup( + name = "test_files", + srcs = [ + "input.js", + "output.generated.txt", + ], + tags = ["ignore_srcs"], +) + glob_lit_tests( name = "all_tests", data = [ - "input.js", - "output.generated.txt", + ":test_files", "//maldoca/js/ir:lit_test_files", ], test_file_exts = [