diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/containers.baml b/baml_language/crates/baml_builtins2/baml_std/baml/containers.baml index 0d1fac3864c..c4167f3a9c7 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/containers.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/containers.baml @@ -70,6 +70,22 @@ class Array { $rust_function } + /// Returns a new array containing the non-null results of `fn` applied to + /// every element. The function is called once per element, left-to-right. + /// Does not mutate `self`. For a lazy version, use `iter().filter_map(fn)`. + function filter_map(self, fn: (T) -> U? throws E) -> U[] throws E { + let out: U[] = []; + for (let x in self.slice(0, self.length())) { + match (fn(x)) { + null => {}, + let y: U => { + out.push(y); + }, + } + } + out + } + /// Returns a new array with the elements in reverse order. Does not mutate `self`. function reverse(self) -> T[] throws never { $rust_function diff --git a/baml_language/crates/baml_builtins2/baml_std/baml/ns_iter/iter.baml b/baml_language/crates/baml_builtins2/baml_std/baml/ns_iter/iter.baml index a158e061a08..7f820773851 100644 --- a/baml_language/crates/baml_builtins2/baml_std/baml/ns_iter/iter.baml +++ b/baml_language/crates/baml_builtins2/baml_std/baml/ns_iter/iter.baml @@ -150,12 +150,16 @@ class ArrayIterator { type Error = never function next(self) -> T | Done throws never { - match (self.arr.at(self.idx)) { - null => Done {}, - let item: T => { - self.idx += 1; - item - }, + // Bounds-check by index, not by matching `at()` against null: when T is + // itself nullable, a stored null element must be yielded, not treated as + // the end of iteration. + if (self.idx >= self.arr.length()) { + return Done {}; + } + let item = self.arr.at(self.idx); + self.idx += 1; + match (item) { + let value: T => value, } } } diff --git a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap index b48e4213bb3..bcd8e8d8d4a 100644 --- a/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap +++ b/baml_language/crates/baml_cli/src/snapshots/baml_cli__describe_command_tests__render_builtin_package_listing.snap @@ -11,7 +11,7 @@ function _float_total_cmp /baml/comparable.baml function _is_primitive_array /baml/comparable.baml:151 function _rust_sort /baml/comparable.baml:172 class Array /baml/containers.baml:2 -class Map /baml/containers.baml:441 +class Map /baml/containers.baml:457 function deep_copy /baml/core.baml:3 function deep_equals /baml/core.baml:9 class Float /baml/float.baml:2 @@ -121,16 +121,16 @@ interface iter.Iterable /baml/ns_iter/iter.ba interface iter.Iterator /baml/ns_iter/iter.baml:10 function iter.flatten /baml/ns_iter/iter.baml:129 class iter.ArrayIterator /baml/ns_iter/iter.baml:133 -class iter.Range /baml/ns_iter/iter.baml:164 -class iter.Repeat /baml/ns_iter/iter.baml:196 -class iter.Map /baml/ns_iter/iter.baml:228 -class iter.Filter /baml/ns_iter/iter.baml:252 -class iter.FilterMap /baml/ns_iter/iter.baml:283 -class iter.FlatMap /baml/ns_iter/iter.baml:315 -class iter.Flatten /baml/ns_iter/iter.baml:356 -class iter.Peekable /baml/ns_iter/iter.baml:396 -class iter.StepBy /baml/ns_iter/iter.baml:434 -class iter.Chain /baml/ns_iter/iter.baml:466 +class iter.Range /baml/ns_iter/iter.baml:168 +class iter.Repeat /baml/ns_iter/iter.baml:200 +class iter.Map /baml/ns_iter/iter.baml:232 +class iter.Filter /baml/ns_iter/iter.baml:256 +class iter.FilterMap /baml/ns_iter/iter.baml:287 +class iter.FlatMap /baml/ns_iter/iter.baml:319 +class iter.Flatten /baml/ns_iter/iter.baml:360 +class iter.Peekable /baml/ns_iter/iter.baml:400 +class iter.StepBy /baml/ns_iter/iter.baml:438 +class iter.Chain /baml/ns_iter/iter.baml:470 type json.json /baml/ns_json/json.baml:2 class json.JsonParseError /baml/ns_json/json.baml:5 class json.JsonDecodeError /baml/ns_json/json.baml:9 diff --git a/baml_language/crates/baml_tests/baml_src/ns_iter/iter.baml b/baml_language/crates/baml_tests/baml_src/ns_iter/iter.baml index e1cf5e6bda2..ca67786ec46 100644 --- a/baml_language/crates/baml_tests/baml_src/ns_iter/iter.baml +++ b/baml_language/crates/baml_tests/baml_src/ns_iter/iter.baml @@ -180,6 +180,73 @@ test "iter_array_iter_lazy_over_source" { assert.is_true(baml.deep_equals(iter_array_iter_lazy_over_source_details(), [3, 2, 1, 3])) } +function iter_for_loop_sees_push_during_iteration() -> int[] throws unknown { + let xs = [1, 2]; + let visited: int[] = []; + for (let x in xs) { + visited.push(x); + if (x == 1) { + xs.push(3); + } + } + visited +} + +test "iter_for_loop_sees_push_during_iteration" { + assert.is_true(baml.deep_equals(iter_for_loop_sees_push_during_iteration(), [1, 2, 3])) +} + +function iter_for_loop_pop_during_iteration() -> int[] throws unknown { + let xs = [1, 2, 3, 4]; + let visited: int[] = []; + for (let x in xs) { + visited.push(x); + xs.pop(); + } + visited +} + +test "iter_for_loop_pop_during_iteration" { + assert.is_true(baml.deep_equals(iter_for_loop_pop_during_iteration(), [1, 2])) +} + +function iter_array_eager_filter_map() -> int[] throws unknown { + [1, 2, 3, 4].filter_map((x: int) -> int? { + if (x % 2 == 0) { + x * 10 + } else { + null + } + }) +} + +test "iter_array_eager_filter_map" { + assert.is_true(baml.deep_equals(iter_array_eager_filter_map(), [20, 40])) +} + +function iter_array_nullable_elements_details() -> int[] throws unknown { + let xs: int?[] = [1, null, 3]; + let visited = 0; + let nulls = 0; + let sum = 0; + for (let x in xs) { + visited += 1; + match (x) { + null => { + nulls += 1; + }, + let v: int => { + sum += v; + }, + } + } + [visited, nulls, sum, xs.iter().count()] +} + +test "iter_array_nullable_elements" { + assert.is_true(baml.deep_equals(iter_array_nullable_elements_details(), [3, 1, 4, 3])) +} + function iter_array_lazy_filter_map_collect() -> int[] throws unknown { [1, 2, 3, 4].iter().filter((x: int) -> bool { x % 2 == 0 diff --git a/baml_language/crates/baml_tests/snapshots/baml_src/iter.snap b/baml_language/crates/baml_tests/snapshots/baml_src/iter.snap index 7787f77b4f3..a5ed799399c 100644 --- a/baml_language/crates/baml_tests/snapshots/baml_src/iter.snap +++ b/baml_language/crates/baml_tests/snapshots/baml_src/iter.snap @@ -87,161 +87,185 @@ function iter.$init_test_ns_iter_iter(registry: testing.TestCollector) -> null { call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_lazy_filter_map_collect" + load_const "iter_for_loop_sees_push_during_iteration" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_first_adapter_defaults" + load_const "iter_for_loop_pop_during_iteration" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_collect_count" + load_const "iter_array_eager_filter_map" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_filter_step_by" + load_const "iter_array_nullable_elements" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_filter_map_fluent" + load_const "iter_array_lazy_filter_map_collect" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_chain_fluent" + load_const "iter_array_first_adapter_defaults" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_peekable_fluent" + load_const "iter_array_collect_count" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_as_iterable_param" + load_const "iter_array_filter_step_by" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_shadowed_param_method" + load_const "iter_array_filter_map_fluent" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_shadowed_param_for_in" + load_const "iter_array_chain_fluent" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_for_in_repeat" + load_const "iter_array_peekable_fluent" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_chain" + load_const "iter_array_as_iterable_param" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_repeat" + load_const "iter_shadowed_param_method" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_map" + load_const "iter_shadowed_param_for_in" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_map_implicit_source" + load_const "iter_for_in_repeat" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_explicit_map_coerces_to_iterator" + load_const "iter_chain" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_filter" + load_const "iter_repeat" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_filter_implicit_source" + load_const "iter_map" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_filter_map" + load_const "iter_map_implicit_source" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_filter_map_implicit_source" + load_const "iter_explicit_map_coerces_to_iterator" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_flat_map" + load_const "iter_filter" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_flat_map_implicit_source" + load_const "iter_filter_implicit_source" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_flatten" + load_const "iter_filter_map" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_peekable" + load_const "iter_filter_map_implicit_source" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_step_by" + load_const "iter_flat_map" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 load_var registry - load_const "iter_array_iter" + load_const "iter_flat_map_implicit_source" make_closure ., 0 load_const null call testing.TestCollector.register_test pop 1 + load_var registry + load_const "iter_flatten" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test + pop 1 + load_var registry + load_const "iter_peekable" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test + pop 1 + load_var registry + load_const "iter_step_by" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test + pop 1 + load_var registry + load_const "iter_array_iter" + make_closure ., 0 + load_const null + call testing.TestCollector.register_test + pop 1 load_const null return } @@ -1204,6 +1228,20 @@ function iter.iter_array_collect_count() -> bool { unreachable } +function iter.iter_array_eager_filter_map() -> int[] { + load_type int + load_type int + load_type void + load_const 1 + load_const 2 + load_const 3 + load_const 4 + alloc_array 4 + make_closure ., 0 + call baml.Array.filter_map + return +} + function iter.iter_array_eager_filter_map_without_collect() -> int[] { load_type int load_type void @@ -4987,421 +5025,758 @@ function iter.iter_array_lazy_filter_map_collect() -> int[] { unreachable } -function iter.iter_array_peekable_fluent() -> int[] { - load_type int - load_const 8 - load_const 9 - alloc_array 2 +function iter.iter_array_nullable_elements_details() -> int[] { + load_const 1 + load_const null + load_const 3 + alloc_array 3 + store_var xs + load_const 0 + store_var visited + load_const 0 + store_var nulls + load_const 0 + store_var sum + load_type int | null + load_var xs call baml.iter.Iterable$for$T[].iter - store_var _2 - load_var _2 - is_type baml.iter.Flatten<...> - pop_jump_if_false L0 - jump L19 + store_var _6 L0: - load_var _2 - is_type baml.iter.Range + load_var _6 + is_type baml.iter.Flatten<...> pop_jump_if_false L1 jump L18 L1: - load_var _2 + load_var _6 is_type baml.iter.ArrayIterator<...> pop_jump_if_false L2 jump L17 L2: - load_var _2 + load_var _6 is_type baml.iter.StepBy<...> pop_jump_if_false L3 jump L16 L3: - load_var _2 + load_var _6 is_type baml.iter.Chain<...> pop_jump_if_false L4 jump L15 L4: - load_var _2 + load_var _6 is_type baml.iter.Repeat<...> pop_jump_if_false L5 jump L14 L5: - load_var _2 + load_var _6 is_type baml.iter.Map<...> pop_jump_if_false L6 jump L13 L6: - load_var _2 + load_var _6 is_type baml.iter.Filter<...> pop_jump_if_false L7 jump L12 L7: - load_var _2 + load_var _6 is_type baml.iter.FilterMap<...> pop_jump_if_false L8 jump L11 L8: - load_var _2 + load_var _6 is_type baml.iter.FlatMap<...> pop_jump_if_false L9 jump L10 L9: - load_var _2 + load_var _6 is_type baml.iter.Peekable<...> - pop_jump_if_false L69 - load_type int + pop_jump_if_false L43 + load_type int | null load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + call baml.iter.Peekable.Iterator.next + store_var _8 + jump L19 L10: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _8 + jump L19 L11: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + make_bound_method baml.iter.FilterMap.Iterator.next + call_indirect + store_var _8 + jump L19 L12: - load_type int + load_type int | null load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_type void + load_var _6 + call baml.iter.Filter.Iterator.next + store_var _8 + jump L19 L13: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + make_bound_method baml.iter.Map.Iterator.next + call_indirect + store_var _8 + jump L19 L14: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_type int | null + load_var _6 + call baml.iter.Repeat.Iterator.next + store_var _8 + jump L19 L15: - load_type int + load_type int | null load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_type void + load_var _6 + call baml.iter.Chain.Iterator.next + store_var _8 + jump L19 L16: - load_type int + load_type int | null load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + call baml.iter.StepBy.Iterator.next + store_var _8 + jump L19 L17: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_type int | null + load_var _6 + call baml.iter.ArrayIterator.Iterator.next + store_var _8 + jump L19 L18: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p - jump L20 + load_var _6 + make_bound_method baml.iter.Flatten.Iterator.next + call_indirect + store_var _8 L19: - load_type int - load_type void - load_var _2 - call baml.iter.Iterator.peekable - store_var p + load_var _8 + is_type baml.iter.Done + pop_jump_if_false L20 + jump L23 L20: - alloc_array 0 - store_var out - load_type int - load_type void - load_var p - call baml.iter.Peekable.peek - store_var _40 - load_var _40 - is_type baml.iter.Done + load_var _8 + store_var x + load_var visited + load_const 1 + add_int + store_var visited + load_var x + load_const null + cmp_op == pop_jump_if_false L21 jump L22 L21: - load_var2 3 4 - call baml.Array.push - pop 1 + load_var2 4 7 + add_int + store_var sum + jump L0 L22: - load_var p - is_type baml.iter.Flatten<...> - pop_jump_if_false L23 - jump L42 + load_var nulls + load_const 1 + add_int + store_var nulls + jump L0 L23: - load_var p - is_type baml.iter.Range + load_var visited + store_var _41 + load_var nulls + store_var _42 + load_var sum + store_var _43 + load_type int | null + load_var xs + call baml.iter.Iterable$for$T[].iter + store_var _45 + load_var _45 + is_type baml.iter.Flatten<...> pop_jump_if_false L24 jump L41 L24: - load_var p + load_var _45 is_type baml.iter.ArrayIterator<...> pop_jump_if_false L25 jump L40 L25: - load_var p + load_var _45 is_type baml.iter.StepBy<...> pop_jump_if_false L26 jump L39 L26: - load_var p + load_var _45 is_type baml.iter.Chain<...> pop_jump_if_false L27 jump L38 L27: - load_var p + load_var _45 is_type baml.iter.Repeat<...> pop_jump_if_false L28 jump L37 L28: - load_var p + load_var _45 is_type baml.iter.Map<...> pop_jump_if_false L29 jump L36 L29: - load_var p + load_var _45 is_type baml.iter.Filter<...> pop_jump_if_false L30 jump L35 L30: - load_var p + load_var _45 is_type baml.iter.FilterMap<...> pop_jump_if_false L31 jump L34 L31: - load_var p + load_var _45 is_type baml.iter.FlatMap<...> pop_jump_if_false L32 jump L33 L32: - load_var p + load_var _45 is_type baml.iter.Peekable<...> - pop_jump_if_false L69 - load_type int + pop_jump_if_false L43 + load_type int | null load_type void - load_var p - call baml.iter.Peekable.Iterator.next - store_var _47 - jump L43 + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L33: - load_var p - make_bound_method baml.iter.FlatMap.Iterator.next - call_indirect - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L34: - load_var p - make_bound_method baml.iter.FilterMap.Iterator.next - call_indirect - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L35: - load_type int - load_type void + load_type int | null load_type void - load_var p - call baml.iter.Filter.Iterator.next - store_var _47 - jump L43 + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L36: - load_var p - make_bound_method baml.iter.Map.Iterator.next - call_indirect - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L37: - load_type int - load_var p - call baml.iter.Repeat.Iterator.next - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L38: - load_type int + load_type int | null load_type void - load_type void - load_var p - call baml.iter.Chain.Iterator.next - store_var _47 - jump L43 + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L39: - load_type int + load_type int | null load_type void - load_var p - call baml.iter.StepBy.Iterator.next - store_var _47 - jump L43 + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L40: - load_type int - load_var p - call baml.iter.ArrayIterator.Iterator.next - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 + jump L42 L41: - load_var p - call baml.iter.Range.Iterator.next - store_var _47 - jump L43 + load_type int | null + load_type void + load_var _45 + call baml.iter.Iterator.count + store_var _44 L42: - load_var p - make_bound_method baml.iter.Flatten.Iterator.next - call_indirect - store_var _47 + load_var2 8 9 + load_var2 10 11 + alloc_array 4 + return L43: - load_var _47 - is_type baml.iter.Done - pop_jump_if_false L44 - jump L45 - - L44: - load_var2 3 5 - call baml.Array.push - pop 1 + unreachable +} - L45: - load_var p +function iter.iter_array_peekable_fluent() -> int[] { + load_type int + load_const 8 + load_const 9 + alloc_array 2 + call baml.iter.Iterable$for$T[].iter + store_var _2 + load_var _2 is_type baml.iter.Flatten<...> - pop_jump_if_false L46 - jump L65 + pop_jump_if_false L0 + jump L19 - L46: - load_var p + L0: + load_var _2 is_type baml.iter.Range - pop_jump_if_false L47 - jump L64 + pop_jump_if_false L1 + jump L18 - L47: - load_var p + L1: + load_var _2 is_type baml.iter.ArrayIterator<...> - pop_jump_if_false L48 - jump L63 + pop_jump_if_false L2 + jump L17 - L48: - load_var p + L2: + load_var _2 is_type baml.iter.StepBy<...> - pop_jump_if_false L49 - jump L62 + pop_jump_if_false L3 + jump L16 - L49: - load_var p + L3: + load_var _2 is_type baml.iter.Chain<...> - pop_jump_if_false L50 - jump L61 + pop_jump_if_false L4 + jump L15 - L50: - load_var p + L4: + load_var _2 is_type baml.iter.Repeat<...> - pop_jump_if_false L51 - jump L60 + pop_jump_if_false L5 + jump L14 - L51: - load_var p + L5: + load_var _2 is_type baml.iter.Map<...> - pop_jump_if_false L52 - jump L59 + pop_jump_if_false L6 + jump L13 - L52: - load_var p + L6: + load_var _2 is_type baml.iter.Filter<...> - pop_jump_if_false L53 - jump L58 + pop_jump_if_false L7 + jump L12 - L53: - load_var p + L7: + load_var _2 is_type baml.iter.FilterMap<...> - pop_jump_if_false L54 - jump L57 + pop_jump_if_false L8 + jump L11 - L54: - load_var p + L8: + load_var _2 is_type baml.iter.FlatMap<...> - pop_jump_if_false L55 - jump L56 + pop_jump_if_false L9 + jump L10 - L55: - load_var p + L9: + load_var _2 is_type baml.iter.Peekable<...> pop_jump_if_false L69 load_type int load_type void - load_var p - call baml.iter.Peekable.Iterator.next - store_var _79 - jump L66 + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 - L56: - load_var p - make_bound_method baml.iter.FlatMap.Iterator.next - call_indirect - store_var _79 - jump L66 + L10: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 - L57: - load_var p - make_bound_method baml.iter.FilterMap.Iterator.next - call_indirect - store_var _79 - jump L66 + L11: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 - L58: + L12: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L13: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L14: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L15: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L16: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L17: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L18: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + jump L20 + + L19: + load_type int + load_type void + load_var _2 + call baml.iter.Iterator.peekable + store_var p + + L20: + alloc_array 0 + store_var out + load_type int + load_type void + load_var p + call baml.iter.Peekable.peek + store_var _40 + load_var _40 + is_type baml.iter.Done + pop_jump_if_false L21 + jump L22 + + L21: + load_var2 3 4 + call baml.Array.push + pop 1 + + L22: + load_var p + is_type baml.iter.Flatten<...> + pop_jump_if_false L23 + jump L42 + + L23: + load_var p + is_type baml.iter.Range + pop_jump_if_false L24 + jump L41 + + L24: + load_var p + is_type baml.iter.ArrayIterator<...> + pop_jump_if_false L25 + jump L40 + + L25: + load_var p + is_type baml.iter.StepBy<...> + pop_jump_if_false L26 + jump L39 + + L26: + load_var p + is_type baml.iter.Chain<...> + pop_jump_if_false L27 + jump L38 + + L27: + load_var p + is_type baml.iter.Repeat<...> + pop_jump_if_false L28 + jump L37 + + L28: + load_var p + is_type baml.iter.Map<...> + pop_jump_if_false L29 + jump L36 + + L29: + load_var p + is_type baml.iter.Filter<...> + pop_jump_if_false L30 + jump L35 + + L30: + load_var p + is_type baml.iter.FilterMap<...> + pop_jump_if_false L31 + jump L34 + + L31: + load_var p + is_type baml.iter.FlatMap<...> + pop_jump_if_false L32 + jump L33 + + L32: + load_var p + is_type baml.iter.Peekable<...> + pop_jump_if_false L69 + load_type int + load_type void + load_var p + call baml.iter.Peekable.Iterator.next + store_var _47 + jump L43 + + L33: + load_var p + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _47 + jump L43 + + L34: + load_var p + make_bound_method baml.iter.FilterMap.Iterator.next + call_indirect + store_var _47 + jump L43 + + L35: + load_type int + load_type void + load_type void + load_var p + call baml.iter.Filter.Iterator.next + store_var _47 + jump L43 + + L36: + load_var p + make_bound_method baml.iter.Map.Iterator.next + call_indirect + store_var _47 + jump L43 + + L37: + load_type int + load_var p + call baml.iter.Repeat.Iterator.next + store_var _47 + jump L43 + + L38: + load_type int + load_type void + load_type void + load_var p + call baml.iter.Chain.Iterator.next + store_var _47 + jump L43 + + L39: + load_type int + load_type void + load_var p + call baml.iter.StepBy.Iterator.next + store_var _47 + jump L43 + + L40: + load_type int + load_var p + call baml.iter.ArrayIterator.Iterator.next + store_var _47 + jump L43 + + L41: + load_var p + call baml.iter.Range.Iterator.next + store_var _47 + jump L43 + + L42: + load_var p + make_bound_method baml.iter.Flatten.Iterator.next + call_indirect + store_var _47 + + L43: + load_var _47 + is_type baml.iter.Done + pop_jump_if_false L44 + jump L45 + + L44: + load_var2 3 5 + call baml.Array.push + pop 1 + + L45: + load_var p + is_type baml.iter.Flatten<...> + pop_jump_if_false L46 + jump L65 + + L46: + load_var p + is_type baml.iter.Range + pop_jump_if_false L47 + jump L64 + + L47: + load_var p + is_type baml.iter.ArrayIterator<...> + pop_jump_if_false L48 + jump L63 + + L48: + load_var p + is_type baml.iter.StepBy<...> + pop_jump_if_false L49 + jump L62 + + L49: + load_var p + is_type baml.iter.Chain<...> + pop_jump_if_false L50 + jump L61 + + L50: + load_var p + is_type baml.iter.Repeat<...> + pop_jump_if_false L51 + jump L60 + + L51: + load_var p + is_type baml.iter.Map<...> + pop_jump_if_false L52 + jump L59 + + L52: + load_var p + is_type baml.iter.Filter<...> + pop_jump_if_false L53 + jump L58 + + L53: + load_var p + is_type baml.iter.FilterMap<...> + pop_jump_if_false L54 + jump L57 + + L54: + load_var p + is_type baml.iter.FlatMap<...> + pop_jump_if_false L55 + jump L56 + + L55: + load_var p + is_type baml.iter.Peekable<...> + pop_jump_if_false L69 + load_type int + load_type void + load_var p + call baml.iter.Peekable.Iterator.next + store_var _79 + jump L66 + + L56: + load_var p + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _79 + jump L66 + + L57: + load_var p + make_bound_method baml.iter.FilterMap.Iterator.next + call_indirect + store_var _79 + jump L66 + + L58: load_type int load_type void load_type void @@ -9045,200 +9420,527 @@ function iter.iter_for_in_array_of_classes() -> int { load_var total return - L22: + L22: + unreachable +} + +function iter.iter_for_in_array_of_unions() -> int { + load_const 0 + store_var total + load_type int | string + load_const 1 + load_const "two" + load_const 3 + alloc_array 3 + call baml.iter.Iterable$for$T[].iter + store_var _4 + + L0: + load_var _4 + is_type baml.iter.Flatten<...> + pop_jump_if_false L1 + jump L18 + + L1: + load_var _4 + is_type baml.iter.ArrayIterator<...> + pop_jump_if_false L2 + jump L17 + + L2: + load_var _4 + is_type baml.iter.StepBy<...> + pop_jump_if_false L3 + jump L16 + + L3: + load_var _4 + is_type baml.iter.Chain<...> + pop_jump_if_false L4 + jump L15 + + L4: + load_var _4 + is_type baml.iter.Repeat<...> + pop_jump_if_false L5 + jump L14 + + L5: + load_var _4 + is_type baml.iter.Map<...> + pop_jump_if_false L6 + jump L13 + + L6: + load_var _4 + is_type baml.iter.Filter<...> + pop_jump_if_false L7 + jump L12 + + L7: + load_var _4 + is_type baml.iter.FilterMap<...> + pop_jump_if_false L8 + jump L11 + + L8: + load_var _4 + is_type baml.iter.FlatMap<...> + pop_jump_if_false L9 + jump L10 + + L9: + load_var _4 + is_type baml.iter.Peekable<...> + pop_jump_if_false L24 + load_type int | string + load_type void + load_var _4 + call baml.iter.Peekable.Iterator.next + store_var _6 + jump L19 + + L10: + load_var _4 + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _6 + jump L19 + + L11: + load_var _4 + make_bound_method baml.iter.FilterMap.Iterator.next + call_indirect + store_var _6 + jump L19 + + L12: + load_type int | string + load_type void + load_type void + load_var _4 + call baml.iter.Filter.Iterator.next + store_var _6 + jump L19 + + L13: + load_var _4 + make_bound_method baml.iter.Map.Iterator.next + call_indirect + store_var _6 + jump L19 + + L14: + load_type int | string + load_var _4 + call baml.iter.Repeat.Iterator.next + store_var _6 + jump L19 + + L15: + load_type int | string + load_type void + load_type void + load_var _4 + call baml.iter.Chain.Iterator.next + store_var _6 + jump L19 + + L16: + load_type int | string + load_type void + load_var _4 + call baml.iter.StepBy.Iterator.next + store_var _6 + jump L19 + + L17: + load_type int | string + load_var _4 + call baml.iter.ArrayIterator.Iterator.next + store_var _6 + jump L19 + + L18: + load_var _4 + make_bound_method baml.iter.Flatten.Iterator.next + call_indirect + store_var _6 + + L19: + load_var _6 + is_type baml.iter.Done + pop_jump_if_false L20 + jump L23 + + L20: + load_var _6 + store_var_load_var x + is_type int + pop_jump_if_false L21 + jump L22 + + L21: + load_var x + load_const "two" + cmp_op == + pop_jump_if_false L0 + load_var total + load_const 20 + add_int + store_var total + jump L0 + + L22: + load_var2 1 4 + add_int + store_var total + jump L0 + + L23: + load_var total + return + + L24: unreachable } -function iter.iter_for_in_array_of_unions() -> int { - load_const 0 - store_var total - load_type int | string +function iter.iter_for_in_range() -> int[] { + alloc_array 0 + store_var out load_const 1 - load_const "two" - load_const 3 - alloc_array 3 - call baml.iter.Iterable$for$T[].iter - store_var _4 + load_const 4 + load_const + call baml.iter.Range.new + store_var _2 + load_var _2 + is_type baml.iter.Flatten<...> + pop_jump_if_false L0 + jump L21 L0: - load_var _4 - is_type baml.iter.Flatten<...> + load_var _2 + is_type baml.iter.Range pop_jump_if_false L1 - jump L18 + jump L20 L1: - load_var _4 + load_var _2 is_type baml.iter.ArrayIterator<...> pop_jump_if_false L2 - jump L17 + jump L19 L2: - load_var _4 + load_var _2 is_type baml.iter.StepBy<...> pop_jump_if_false L3 - jump L16 + jump L18 L3: - load_var _4 + load_var _2 is_type baml.iter.Chain<...> pop_jump_if_false L4 - jump L15 + jump L17 L4: - load_var _4 + load_var _2 is_type baml.iter.Repeat<...> pop_jump_if_false L5 - jump L14 + jump L16 L5: - load_var _4 + load_var _2 is_type baml.iter.Map<...> pop_jump_if_false L6 - jump L13 + jump L15 L6: - load_var _4 + load_var _2 is_type baml.iter.Filter<...> pop_jump_if_false L7 - jump L12 + jump L14 L7: - load_var _4 + load_var _2 is_type baml.iter.FilterMap<...> pop_jump_if_false L8 - jump L11 + jump L13 L8: - load_var _4 + load_var _2 is_type baml.iter.FlatMap<...> pop_jump_if_false L9 - jump L10 + jump L12 L9: - load_var _4 + load_var _2 is_type baml.iter.Peekable<...> + pop_jump_if_false L10 + jump L11 + + L10: + load_var _2 + is_type unknown[] + pop_jump_if_false L46 + load_type int + load_var _2 + call baml.iter.Iterable$for$T[].iter + store_var _3 + jump L22 + + L11: + load_type int + load_type void + load_var _2 + call baml.iter.Peekable.Iterable.iter + store_var _3 + jump L22 + + L12: + load_var _2 + make_bound_method baml.iter.FlatMap.Iterable.iter + call_indirect + store_var _3 + jump L22 + + L13: + load_var _2 + make_bound_method baml.iter.FilterMap.Iterable.iter + call_indirect + store_var _3 + jump L22 + + L14: + load_type int + load_type void + load_type void + load_var _2 + call baml.iter.Filter.Iterable.iter + store_var _3 + jump L22 + + L15: + load_var _2 + make_bound_method baml.iter.Map.Iterable.iter + call_indirect + store_var _3 + jump L22 + + L16: + load_type int + load_var _2 + call baml.iter.Repeat.Iterable.iter + store_var _3 + jump L22 + + L17: + load_type int + load_type void + load_type void + load_var _2 + call baml.iter.Chain.Iterable.iter + store_var _3 + jump L22 + + L18: + load_type int + load_type void + load_var _2 + call baml.iter.StepBy.Iterable.iter + store_var _3 + jump L22 + + L19: + load_type int + load_var _2 + call baml.iter.ArrayIterator.Iterable.iter + store_var _3 + jump L22 + + L20: + load_var _2 + call baml.iter.Range.Iterable.iter + store_var _3 + jump L22 + + L21: + load_var _2 + make_bound_method baml.iter.Flatten.Iterable.iter + call_indirect + store_var _3 + + L22: + load_var _3 + is_type baml.iter.Flatten<...> + pop_jump_if_false L23 + jump L42 + + L23: + load_var _3 + is_type baml.iter.Range pop_jump_if_false L24 - load_type int | string + jump L41 + + L24: + load_var _3 + is_type baml.iter.ArrayIterator<...> + pop_jump_if_false L25 + jump L40 + + L25: + load_var _3 + is_type baml.iter.StepBy<...> + pop_jump_if_false L26 + jump L39 + + L26: + load_var _3 + is_type baml.iter.Chain<...> + pop_jump_if_false L27 + jump L38 + + L27: + load_var _3 + is_type baml.iter.Repeat<...> + pop_jump_if_false L28 + jump L37 + + L28: + load_var _3 + is_type baml.iter.Map<...> + pop_jump_if_false L29 + jump L36 + + L29: + load_var _3 + is_type baml.iter.Filter<...> + pop_jump_if_false L30 + jump L35 + + L30: + load_var _3 + is_type baml.iter.FilterMap<...> + pop_jump_if_false L31 + jump L34 + + L31: + load_var _3 + is_type baml.iter.FlatMap<...> + pop_jump_if_false L32 + jump L33 + + L32: + load_var _3 + is_type baml.iter.Peekable<...> + pop_jump_if_false L46 + load_type int load_type void - load_var _4 + load_var _3 call baml.iter.Peekable.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L10: - load_var _4 + L33: + load_var _3 make_bound_method baml.iter.FlatMap.Iterator.next call_indirect - store_var _6 - jump L19 + store_var _33 + jump L43 - L11: - load_var _4 + L34: + load_var _3 make_bound_method baml.iter.FilterMap.Iterator.next call_indirect - store_var _6 - jump L19 + store_var _33 + jump L43 - L12: - load_type int | string + L35: + load_type int load_type void load_type void - load_var _4 + load_var _3 call baml.iter.Filter.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L13: - load_var _4 + L36: + load_var _3 make_bound_method baml.iter.Map.Iterator.next call_indirect - store_var _6 - jump L19 + store_var _33 + jump L43 - L14: - load_type int | string - load_var _4 + L37: + load_type int + load_var _3 call baml.iter.Repeat.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L15: - load_type int | string + L38: + load_type int load_type void load_type void - load_var _4 + load_var _3 call baml.iter.Chain.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L16: - load_type int | string + L39: + load_type int load_type void - load_var _4 + load_var _3 call baml.iter.StepBy.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L17: - load_type int | string - load_var _4 + L40: + load_type int + load_var _3 call baml.iter.ArrayIterator.Iterator.next - store_var _6 - jump L19 + store_var _33 + jump L43 - L18: - load_var _4 + L41: + load_var _3 + call baml.iter.Range.Iterator.next + store_var _33 + jump L43 + + L42: + load_var _3 make_bound_method baml.iter.Flatten.Iterator.next call_indirect - store_var _6 + store_var _33 - L19: - load_var _6 + L43: + load_var _33 is_type baml.iter.Done - pop_jump_if_false L20 - jump L23 - - L20: - load_var _6 - store_var_load_var x - is_type int - pop_jump_if_false L21 - jump L22 - - L21: - load_var x - load_const "two" - cmp_op == - pop_jump_if_false L0 - load_var total - load_const 20 - add_int - store_var total - jump L0 + pop_jump_if_false L44 + jump L45 - L22: + L44: load_var2 1 4 - add_int - store_var total - jump L0 + call baml.Array.push + pop 1 + jump L22 - L23: - load_var total + L45: + load_var out return - L24: + L46: unreachable } -function iter.iter_for_in_range() -> int[] { +function iter.iter_for_in_repeat() -> int[] { alloc_array 0 store_var out - load_const 1 - load_const 4 - load_const - call baml.iter.Range.new - store_var _2 - load_var _2 + load_const 7 + load_const 2 + load_type int + init_instance<1> baml.iter.Repeat .value, .count + store_var_load_var _2 is_type baml.iter.Flatten<...> pop_jump_if_false L0 jump L21 @@ -9558,330 +10260,371 @@ function iter.iter_for_in_range() -> int[] { unreachable } -function iter.iter_for_in_repeat() -> int[] { - alloc_array 0 - store_var out - load_const 7 +function iter.iter_for_loop_pop_during_iteration() -> int[] { + load_const 1 load_const 2 + load_const 3 + load_const 4 + alloc_array 4 + store_var xs + alloc_array 0 + store_var visited load_type int - init_instance<1> baml.iter.Repeat .value, .count - store_var_load_var _2 - is_type baml.iter.Flatten<...> - pop_jump_if_false L0 - jump L21 + load_var xs + call baml.iter.Iterable$for$T[].iter + store_var _4 L0: - load_var _2 - is_type baml.iter.Range + load_var _4 + is_type baml.iter.Flatten<...> pop_jump_if_false L1 jump L20 L1: - load_var _2 - is_type baml.iter.ArrayIterator<...> + load_var _4 + is_type baml.iter.Range pop_jump_if_false L2 jump L19 L2: - load_var _2 - is_type baml.iter.StepBy<...> + load_var _4 + is_type baml.iter.ArrayIterator<...> pop_jump_if_false L3 jump L18 L3: - load_var _2 - is_type baml.iter.Chain<...> + load_var _4 + is_type baml.iter.StepBy<...> pop_jump_if_false L4 jump L17 L4: - load_var _2 - is_type baml.iter.Repeat<...> + load_var _4 + is_type baml.iter.Chain<...> pop_jump_if_false L5 jump L16 L5: - load_var _2 - is_type baml.iter.Map<...> + load_var _4 + is_type baml.iter.Repeat<...> pop_jump_if_false L6 jump L15 L6: - load_var _2 - is_type baml.iter.Filter<...> + load_var _4 + is_type baml.iter.Map<...> pop_jump_if_false L7 jump L14 L7: - load_var _2 - is_type baml.iter.FilterMap<...> + load_var _4 + is_type baml.iter.Filter<...> pop_jump_if_false L8 jump L13 L8: - load_var _2 - is_type baml.iter.FlatMap<...> + load_var _4 + is_type baml.iter.FilterMap<...> pop_jump_if_false L9 jump L12 L9: - load_var _2 - is_type baml.iter.Peekable<...> + load_var _4 + is_type baml.iter.FlatMap<...> pop_jump_if_false L10 jump L11 L10: - load_var _2 - is_type unknown[] - pop_jump_if_false L46 + load_var _4 + is_type baml.iter.Peekable<...> + pop_jump_if_false L24 load_type int - load_var _2 - call baml.iter.Iterable$for$T[].iter - store_var _3 - jump L22 + load_type void + load_var _4 + call baml.iter.Peekable.Iterator.next + store_var _6 + jump L21 L11: - load_type int - load_type void - load_var _2 - call baml.iter.Peekable.Iterable.iter - store_var _3 - jump L22 + load_var _4 + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _6 + jump L21 L12: - load_var _2 - make_bound_method baml.iter.FlatMap.Iterable.iter + load_var _4 + make_bound_method baml.iter.FilterMap.Iterator.next call_indirect - store_var _3 - jump L22 + store_var _6 + jump L21 L13: - load_var _2 - make_bound_method baml.iter.FilterMap.Iterable.iter - call_indirect - store_var _3 - jump L22 - - L14: load_type int load_type void load_type void - load_var _2 - call baml.iter.Filter.Iterable.iter - store_var _3 - jump L22 + load_var _4 + call baml.iter.Filter.Iterator.next + store_var _6 + jump L21 - L15: - load_var _2 - make_bound_method baml.iter.Map.Iterable.iter + L14: + load_var _4 + make_bound_method baml.iter.Map.Iterator.next call_indirect - store_var _3 - jump L22 + store_var _6 + jump L21 - L16: + L15: load_type int - load_var _2 - call baml.iter.Repeat.Iterable.iter - store_var _3 - jump L22 + load_var _4 + call baml.iter.Repeat.Iterator.next + store_var _6 + jump L21 - L17: + L16: load_type int load_type void load_type void - load_var _2 - call baml.iter.Chain.Iterable.iter - store_var _3 - jump L22 + load_var _4 + call baml.iter.Chain.Iterator.next + store_var _6 + jump L21 - L18: + L17: load_type int load_type void - load_var _2 - call baml.iter.StepBy.Iterable.iter - store_var _3 - jump L22 + load_var _4 + call baml.iter.StepBy.Iterator.next + store_var _6 + jump L21 - L19: + L18: load_type int - load_var _2 - call baml.iter.ArrayIterator.Iterable.iter - store_var _3 - jump L22 + load_var _4 + call baml.iter.ArrayIterator.Iterator.next + store_var _6 + jump L21 + + L19: + load_var _4 + call baml.iter.Range.Iterator.next + store_var _6 + jump L21 L20: - load_var _2 - call baml.iter.Range.Iterable.iter - store_var _3 - jump L22 + load_var _4 + make_bound_method baml.iter.Flatten.Iterator.next + call_indirect + store_var _6 L21: - load_var _2 - make_bound_method baml.iter.Flatten.Iterable.iter - call_indirect - store_var _3 + load_var _6 + is_type baml.iter.Done + pop_jump_if_false L22 + jump L23 L22: - load_var _3 - is_type baml.iter.Flatten<...> - pop_jump_if_false L23 - jump L42 + load_var2 2 4 + call baml.Array.push + pop 1 + load_type int + load_var xs + call baml.Array.pop + pop 1 + jump L0 L23: - load_var _3 - is_type baml.iter.Range - pop_jump_if_false L24 - jump L41 + load_var visited + return L24: - load_var _3 + unreachable +} + +function iter.iter_for_loop_sees_push_during_iteration() -> int[] { + load_const 1 + load_const 2 + alloc_array 2 + store_var xs + alloc_array 0 + store_var visited + load_type int + load_var xs + call baml.iter.Iterable$for$T[].iter + store_var _4 + + L0: + load_var _4 + is_type baml.iter.Flatten<...> + pop_jump_if_false L1 + jump L20 + + L1: + load_var _4 + is_type baml.iter.Range + pop_jump_if_false L2 + jump L19 + + L2: + load_var _4 is_type baml.iter.ArrayIterator<...> - pop_jump_if_false L25 - jump L40 + pop_jump_if_false L3 + jump L18 - L25: - load_var _3 + L3: + load_var _4 is_type baml.iter.StepBy<...> - pop_jump_if_false L26 - jump L39 + pop_jump_if_false L4 + jump L17 - L26: - load_var _3 + L4: + load_var _4 is_type baml.iter.Chain<...> - pop_jump_if_false L27 - jump L38 + pop_jump_if_false L5 + jump L16 - L27: - load_var _3 + L5: + load_var _4 is_type baml.iter.Repeat<...> - pop_jump_if_false L28 - jump L37 + pop_jump_if_false L6 + jump L15 - L28: - load_var _3 + L6: + load_var _4 is_type baml.iter.Map<...> - pop_jump_if_false L29 - jump L36 + pop_jump_if_false L7 + jump L14 - L29: - load_var _3 + L7: + load_var _4 is_type baml.iter.Filter<...> - pop_jump_if_false L30 - jump L35 + pop_jump_if_false L8 + jump L13 - L30: - load_var _3 + L8: + load_var _4 is_type baml.iter.FilterMap<...> - pop_jump_if_false L31 - jump L34 + pop_jump_if_false L9 + jump L12 - L31: - load_var _3 + L9: + load_var _4 is_type baml.iter.FlatMap<...> - pop_jump_if_false L32 - jump L33 + pop_jump_if_false L10 + jump L11 - L32: - load_var _3 + L10: + load_var _4 is_type baml.iter.Peekable<...> - pop_jump_if_false L46 + pop_jump_if_false L24 load_type int load_type void - load_var _3 + load_var _4 call baml.iter.Peekable.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L33: - load_var _3 + L11: + load_var _4 make_bound_method baml.iter.FlatMap.Iterator.next call_indirect - store_var _33 - jump L43 + store_var _6 + jump L21 - L34: - load_var _3 + L12: + load_var _4 make_bound_method baml.iter.FilterMap.Iterator.next call_indirect - store_var _33 - jump L43 + store_var _6 + jump L21 - L35: + L13: load_type int load_type void load_type void - load_var _3 + load_var _4 call baml.iter.Filter.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L36: - load_var _3 + L14: + load_var _4 make_bound_method baml.iter.Map.Iterator.next call_indirect - store_var _33 - jump L43 + store_var _6 + jump L21 - L37: + L15: load_type int - load_var _3 + load_var _4 call baml.iter.Repeat.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L38: + L16: load_type int load_type void load_type void - load_var _3 + load_var _4 call baml.iter.Chain.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L39: + L17: load_type int load_type void - load_var _3 + load_var _4 call baml.iter.StepBy.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L40: + L18: load_type int - load_var _3 + load_var _4 call baml.iter.ArrayIterator.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L41: - load_var _3 + L19: + load_var _4 call baml.iter.Range.Iterator.next - store_var _33 - jump L43 + store_var _6 + jump L21 - L42: - load_var _3 + L20: + load_var _4 make_bound_method baml.iter.Flatten.Iterator.next call_indirect - store_var _33 + store_var _6 - L43: - load_var _33 + L21: + load_var _6 is_type baml.iter.Done - pop_jump_if_false L44 - jump L45 + pop_jump_if_false L22 + jump L23 - L44: - load_var2 1 4 + L22: + load_var _6 + store_var x + load_var2 2 5 call baml.Array.push pop 1 - jump L22 + load_var x + load_const 1 + cmp_int_op == + pop_jump_if_false L0 + load_var xs + load_const 3 + call baml.Array.push + pop 1 + jump L0 - L45: - load_var out + L23: + load_var visited return - L46: + L24: unreachable } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_hir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_hir.snap index 6135ef65b06..56cc6fe873c 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_hir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____03_hir.snap @@ -63,6 +63,9 @@ function baml.concat(self: ?, other: T[]) -> T[] [builtin] function baml.delete(self: ?, key: K) -> V? [builtin] function baml.every(self: ?, predicate: (T) -> bool throws E) -> bool [builtin] function baml.filter(self: ?, predicate: (T) -> bool throws E) -> T[] [builtin] +function baml.filter_map(self: ?, fn: (T) -> U? throws E) -> U[] [expr] { + { let out: U[] = []; for x in self.slice(0, self.length()) { } match (fn(x)) { null => { }, y: U => { out.push(y) } } } out +} function baml.find(self: ?, predicate: (T) -> bool throws E) -> T? [builtin] function baml.find_index(self: ?, predicate: (T) -> bool throws E) -> int? [builtin] function baml.find_last(self: ?, predicate: (T) -> bool throws E) -> T? [builtin] @@ -1042,7 +1045,7 @@ function baml.iter.next(self: ?) -> R | baml.iter.Done [expr] { { while true { } match (self.inner) { cur: Iterator => { } match (cur.next()) { baml.iter.Done => { self.inner = baml.iter.Done { } }, y: R => { return y } }, baml.iter.Done => { } match (self.source.next()) { baml.iter.Done => { return baml.iter.Done { } }, x: I => { let it = x.iter(); self.inner = it } } } } baml.iter.Done { } } function baml.iter.next(self: ?) -> T | baml.iter.Done [expr] { - { } match (self.arr.at(self.idx)) { null => baml.iter.Done { }, item: T => { self.idx Add= 1 } item } + { if (self.idx Ge self.arr.length()) { return baml.iter.Done { } }; let item = self.arr.at(self.idx); self.idx Add= 1 } match (item) { value: T => value } } function baml.iter.next(self: ?) -> R | baml.iter.Done [expr] { { while true { } match (self.inner) { cur: Iterator => { } match (cur.next()) { baml.iter.Done => { self.inner = baml.iter.Done { } }, y: R => { return y } }, baml.iter.Done => { } match (self.source.next()) { baml.iter.Done => { return baml.iter.Done { } }, x: T => { let it = self.func(x).iter(); self.inner = it } } } } baml.iter.Done { } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap index a524942e9a3..1e063faefba 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_5_mir.snap @@ -260,6 +260,224 @@ fn baml.Array.every = builtin(vm) fn baml.Array.filter = builtin(vm) +fn baml.Array.filter_map(self: baml.Array, fn: (unknown) -> unknown | null throws unknown) -> void[] { + // Locals: + let _0: void[] // _0 // return + let _1: baml.Array // self // param + let _2: (unknown) -> unknown | null throws unknown // fn // param + let _3: unknown[] // out + let _4: unknown[] + let _5: int + let _6: type + let _7: baml.iter.Iterator + let _8: type + let _9: unknown + let _10: bool + let _11: unknown + let _12: bool + let _13: bool + let _14: type + let _15: bool + let _16: type + let _17: type + let _18: bool + let _19: type + let _20: type + let _21: type + let _22: bool + let _23: type + let _24: bool + let _25: unknown + let _26: bool + let _27: type + let _28: type + let _29: type + let _30: bool + let _31: unknown + let _32: bool + let _33: unknown + let _34: bool + let _35: type + let _36: type + let _37: bool + let _38: unknown + let _39: unknown // x + let _40: unknown | null + let _41: unknown + let _42: bool + let _43: void // y + let _44: int + let _45: unknown + + bb0: { + _3 = []; + _5 = len(_1); + goto -> bb1; + } + + bb1: { + _6 = load_type(#0); + _4 = call const fn baml.Array.slice(copy _1, const 0_i64, copy _5) -> [bb2]; + } + + bb2: { + _8 = load_type(#0); + _7 = call const fn baml.iter.Iterable$for$T[].iter(copy _4) -> [bb3]; + } + + bb3: { + _10 = is_type(copy _7, baml.iter.Flatten<_, #0?, void, void>); + branch copy _10 -> [bb25, bb4]; + } + + bb4: { + _12 = is_type(copy _7, baml.iter.Range); + branch copy _12 -> [bb24, bb5]; + } + + bb5: { + _13 = is_type(copy _7, baml.iter.ArrayIterator<#0?>); + branch copy _13 -> [bb23, bb6]; + } + + bb6: { + _15 = is_type(copy _7, baml.iter.StepBy<#0?, void>); + branch copy _15 -> [bb22, bb7]; + } + + bb7: { + _18 = is_type(copy _7, baml.iter.Chain<#0?, void, void>); + branch copy _18 -> [bb21, bb8]; + } + + bb8: { + _22 = is_type(copy _7, baml.iter.Repeat<#0?>); + branch copy _22 -> [bb20, bb9]; + } + + bb9: { + _24 = is_type(copy _7, baml.iter.Map<_, #0?, void, void>); + branch copy _24 -> [bb19, bb10]; + } + + bb10: { + _26 = is_type(copy _7, baml.iter.Filter<#0?, void, void>); + branch copy _26 -> [bb18, bb11]; + } + + bb11: { + _30 = is_type(copy _7, baml.iter.FilterMap<_, #0?, void, void>); + branch copy _30 -> [bb17, bb12]; + } + + bb12: { + _32 = is_type(copy _7, baml.iter.FlatMap<_, #0?, void, void, void>); + branch copy _32 -> [bb16, bb13]; + } + + bb13: { + _34 = is_type(copy _7, baml.iter.Peekable<#0?, void>); + branch copy _34 -> [bb15, bb14]; + } + + bb14: { + unreachable; + } + + bb15: { + _35 = load_type(#0); + _36 = load_type(void); + _9 = call const fn baml.iter.Peekable.Iterator.next(copy _7) -> [bb26]; + } + + bb16: { + _33 = make_bound_method baml.iter.FlatMap.Iterator.next(copy _7); + _9 = call copy _33() -> [bb26]; + } + + bb17: { + _31 = make_bound_method baml.iter.FilterMap.Iterator.next(copy _7); + _9 = call copy _31() -> [bb26]; + } + + bb18: { + _27 = load_type(#0); + _28 = load_type(void); + _29 = load_type(void); + _9 = call const fn baml.iter.Filter.Iterator.next(copy _7) -> [bb26]; + } + + bb19: { + _25 = make_bound_method baml.iter.Map.Iterator.next(copy _7); + _9 = call copy _25() -> [bb26]; + } + + bb20: { + _23 = load_type(#0); + _9 = call const fn baml.iter.Repeat.Iterator.next(copy _7) -> [bb26]; + } + + bb21: { + _19 = load_type(#0); + _20 = load_type(void); + _21 = load_type(void); + _9 = call const fn baml.iter.Chain.Iterator.next(copy _7) -> [bb26]; + } + + bb22: { + _16 = load_type(#0); + _17 = load_type(void); + _9 = call const fn baml.iter.StepBy.Iterator.next(copy _7) -> [bb26]; + } + + bb23: { + _14 = load_type(#0); + _9 = call const fn baml.iter.ArrayIterator.Iterator.next(copy _7) -> [bb26]; + } + + bb24: { + _9 = call const fn baml.iter.Range.Iterator.next(copy _7) -> [bb26]; + } + + bb25: { + _11 = make_bound_method baml.iter.Flatten.Iterator.next(copy _7); + _9 = call copy _11() -> [bb26]; + } + + bb26: { + _37 = is_type(copy _9, baml.iter.Done); + branch copy _37 -> [bb30, bb27]; + } + + bb27: { + _38 = copy _9; + fresh_cell(_39); + _39 = copy _38; + _41 = copy _39; + _40 = call copy _2(copy _41) -> [bb28]; + } + + bb28: { + _42 = copy _40 == const null; + branch copy _42 -> [bb3, bb29]; + } + + bb29: { + _43 = copy _40; + _45 = copy _43; + _44 = call const fn baml.Array.push(copy _3, copy _45) -> [bb3]; + } + + bb30: { + _0 = copy _3; + goto -> bb31; + } + + bb31: { + return; + } +} + fn baml.Array.find = builtin(vm) fn baml.Array.find_index = builtin(vm) @@ -11961,38 +12179,48 @@ fn baml.iter.ArrayIterator.Iterator.next(self: null) -> void | baml.iter.Done { // Locals: let _0: void | baml.iter.Done // _0 // return let _1: null // self // param - let _2: unknown | null - let _3: (unknown[], int) -> unknown | null throws never + let _2: bool + let _3: int let _4: int - let _5: type - let _6: bool - let _7: void // item + let _5: (unknown[]) -> int throws never + let _6: unknown | null // item + let _7: (unknown[], int) -> unknown | null throws never + let _8: int + let _9: type + let _10: void // value bb0: { - _3 = copy _1.0; - _4 = copy _1.1; - _5 = load_type(#0); - _2 = call const fn baml.Array.at(copy _3, copy _4) -> [bb1]; + _3 = copy _1.1; + _5 = copy _1.0; + _4 = len(_5); + goto -> bb1; } bb1: { - _6 = copy _2 == const null; - branch copy _6 -> [bb3, bb2]; + _2 = copy _3 >= copy _4; + branch copy _2 -> [bb4, bb2]; } bb2: { - _7 = copy _2; - _1.1 = copy _1.1 + const 1_i64; - _0 = copy _7; - goto -> bb4; + _7 = copy _1.0; + _8 = copy _1.1; + _9 = load_type(#0); + _6 = call const fn baml.Array.at(copy _7, copy _8) -> [bb3]; } bb3: { - _0 = baml.iter.Done { }; - goto -> bb4; + _1.1 = copy _1.1 + const 1_i64; + _10 = copy _6; + _0 = copy _10; + goto -> bb5; } bb4: { + _0 = baml.iter.Done { }; + goto -> bb5; + } + + bb5: { return; } } diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap index b74ab3ee743..caf0854bb31 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____04_tir.snap @@ -110,6 +110,23 @@ function baml.Array.for_each(self: baml.Array, fn: (unknown) -> void throws E } } } +function baml.Array.filter_map(self: baml.Array, fn: (unknown) -> U | null throws E) -> U[] throws E { + { : U[] + let out: U[] = [] : U[] + for x in self.slice(0, self.length()) + { : void + match (fn(x) : U | null) : void + null => + { : void + } + y: U => + { : void + out.push(y) : int + } + } + out : U[] + } +} function baml.Array.sort_by_key(self: baml.Array, key: (unknown) -> U throws E) -> unknown[] throws E | U.CmpError { { : never let n = self.length() : int @@ -1521,15 +1538,16 @@ function baml.iter.ArrayIterator.iter(self: baml.iter.ArrayIterator) -> baml.ite } } function baml.iter.ArrayIterator.next(self: baml.iter.ArrayIterator) -> unknown | baml.iter.Done throws never { - { : baml.iter.Done | T - match (self.arr.at(self.idx) : T | null) : baml.iter.Done | T - null => - Done { } : baml.iter.Done - item: T => - { : T - self.idx Add= 1 : int - item : T - } + { : T + if (self.idx >= self.arr.length() : bool) : void + { : never + return Done { } : baml.iter.Done + } + let item = self.arr.at(self.idx) : T | null + self.idx Add= 1 : int + match (item : T | null) : T + value: T => + value : T } } class baml.iter.Range { @@ -1933,18 +1951,21 @@ function baml.iter.ArrayIterator$stream.iter(self: baml.iter.ArrayIterator$strea !! 3930..3934: type mismatch: expected baml.iter.Iterator, got baml.iter.ArrayIterator$stream } function baml.iter.ArrayIterator$stream.next(self: baml.iter.ArrayIterator$stream) -> unknown | baml.iter.Done throws never { - { : baml.iter.Done | T - match (self.arr.at(self.idx) : T | null) : baml.iter.Done | T - null => - Done { } : baml.iter.Done - item: T => - { : T - self.idx Add= 1 : unknown - item : T - } + { : T + if (self.idx >= self.arr.length() : bool) : void + { : never + return Done { } : baml.iter.Done + } + let item = self.arr.at(self.idx) : T | null + self.idx Add= 1 : unknown + match (item : T | null) : T + value: T => + value : T } - !! 4084..4092: type mismatch: expected int, got int | null - !! 4146..4165: operator `Add` cannot be applied to `int | null` and `1` + !! 4259..4288: operator `Ge` cannot be applied to `int | null` and `int` + !! 4259..4288: operator `Ge` cannot be applied to `int | null` and `int` + !! 4353..4361: type mismatch: expected int, got int | null + !! 4363..4378: operator `Add` cannot be applied to `int | null` and `1` } class baml.iter.Range$stream { i: int | null @@ -1955,7 +1976,7 @@ function baml.iter.Range$stream.iter(self: baml.iter.Range$stream) -> baml.iter. { : baml.iter.Range$stream self : baml.iter.Range$stream } - !! 4534..4538: type mismatch: expected baml.iter.Iterator, got baml.iter.Range$stream + !! 4773..4777: type mismatch: expected baml.iter.Iterator, got baml.iter.Range$stream } function baml.iter.Range$stream.next(self: baml.iter.Range$stream) -> int | baml.iter.Done throws never { { : int | null | baml.iter.Done @@ -1970,9 +1991,9 @@ function baml.iter.Range$stream.next(self: baml.iter.Range$stream) -> int | baml Done { } : baml.iter.Done } } - !! 4677..4694: operator `Lt` cannot be applied to `int | null` and `int | null` - !! 4723..4738: operator `Add` cannot be applied to `int | null` and `int | null` - !! 4761..4764: type mismatch: expected int | baml.iter.Done, got int | null + !! 4916..4933: operator `Lt` cannot be applied to `int | null` and `int | null` + !! 4962..4977: operator `Add` cannot be applied to `int | null` and `int | null` + !! 5000..5003: type mismatch: expected int | baml.iter.Done, got int | null } class baml.iter.Repeat$stream { value: T | null @@ -1982,7 +2003,7 @@ function baml.iter.Repeat$stream.iter(self: baml.iter.Repeat$stream) -> baml.ite { : baml.iter.Repeat$stream self : baml.iter.Repeat$stream } - !! 5122..5126: type mismatch: expected baml.iter.Iterator, got baml.iter.Repeat$stream + !! 5361..5365: type mismatch: expected baml.iter.Iterator, got baml.iter.Repeat$stream } function baml.iter.Repeat$stream.next(self: baml.iter.Repeat$stream) -> unknown | baml.iter.Done throws never { { : T | null | baml.iter.Done @@ -2001,11 +2022,11 @@ function baml.iter.Repeat$stream.next(self: baml.iter.Repeat$stream) -> unknown Done { } : baml.iter.Done } } - !! 5261..5275: operator `Lt` cannot be applied to `int | null` and `0` - !! 5278..5297: type mismatch: expected T | baml.iter.Done, got T | null - !! 5315..5329: operator `Gt` cannot be applied to `int | null` and `0` - !! 5332..5351: operator `Sub` cannot be applied to `int | null` and `1` - !! 5357..5376: type mismatch: expected T | baml.iter.Done, got T | null + !! 5500..5514: operator `Lt` cannot be applied to `int | null` and `0` + !! 5517..5536: type mismatch: expected T | baml.iter.Done, got T | null + !! 5554..5568: operator `Gt` cannot be applied to `int | null` and `0` + !! 5571..5590: operator `Sub` cannot be applied to `int | null` and `1` + !! 5596..5615: type mismatch: expected T | baml.iter.Done, got T | null } class baml.iter.Map$stream { source: baml.iter.Iterator | null @@ -2015,7 +2036,7 @@ function baml.iter.Map$stream.iter(self: baml.iter.Map$stream) -> baml.iter.Iter { : baml.iter.Map$stream self : baml.iter.Map$stream } - !! 5666..5670: type mismatch: expected baml.iter.Iterator, got baml.iter.Map$stream + !! 5905..5909: type mismatch: expected baml.iter.Iterator, got baml.iter.Map$stream } function baml.iter.Map$stream.next(self: baml.iter.Map$stream) -> unknown | baml.iter.Done throws unknown | unknown { { : baml.iter.Done | unknown @@ -2025,8 +2046,8 @@ function baml.iter.Map$stream.next(self: baml.iter.Map$stream) -> unknown | baml x: T => self.func(x) : unknown } - !! 5810..5826: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 5810..5828: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 6049..6065: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 6049..6067: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } class baml.iter.Filter$stream { source: baml.iter.Iterator | null @@ -2036,7 +2057,7 @@ function baml.iter.Filter$stream.iter(self: baml.iter.Filter$stream) -> baml.ite { : baml.iter.Filter$stream self : baml.iter.Filter$stream } - !! 6157..6161: type mismatch: expected baml.iter.Iterator, got baml.iter.Filter$stream + !! 6396..6400: type mismatch: expected baml.iter.Iterator, got baml.iter.Filter$stream } function baml.iter.Filter$stream.next(self: baml.iter.Filter$stream) -> unknown | baml.iter.Done throws unknown | unknown { { : baml.iter.Done @@ -2057,8 +2078,8 @@ function baml.iter.Filter$stream.next(self: baml.iter.Filter$stream) -> unknown } Done { } : baml.iter.Done } - !! 6324..6340: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 6324..6342: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 6563..6579: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 6563..6581: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } class baml.iter.FilterMap$stream { source: baml.iter.Iterator | null @@ -2068,7 +2089,7 @@ function baml.iter.FilterMap$stream.iter(self: baml.iter.FilterMap$stream) -> ba { : baml.iter.FilterMap$stream self : baml.iter.FilterMap$stream } - !! 6786..6790: type mismatch: expected baml.iter.Iterator, got baml.iter.FilterMap$stream + !! 7025..7029: type mismatch: expected baml.iter.Iterator, got baml.iter.FilterMap$stream } function baml.iter.FilterMap$stream.next(self: baml.iter.FilterMap$stream) -> unknown | baml.iter.Done throws unknown | unknown { { : baml.iter.Done @@ -2093,8 +2114,8 @@ function baml.iter.FilterMap$stream.next(self: baml.iter.FilterMap$stream) -> un } Done { } : baml.iter.Done } - !! 6953..6969: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 6953..6971: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 7192..7208: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 7192..7210: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } class baml.iter.FlatMap$stream { source: baml.iter.Iterator | null @@ -2105,7 +2126,7 @@ function baml.iter.FlatMap$stream.iter(self: baml.iter.FlatMap$stream) -> baml.i { : baml.iter.FlatMap$stream self : baml.iter.FlatMap$stream } - !! 7543..7547: type mismatch: expected baml.iter.Iterator, got baml.iter.FlatMap$stream + !! 7782..7786: type mismatch: expected baml.iter.Iterator, got baml.iter.FlatMap$stream } function baml.iter.FlatMap$stream.next(self: baml.iter.FlatMap$stream) -> unknown | baml.iter.Done throws unknown | unknown | unknown { { : baml.iter.Done @@ -2140,13 +2161,13 @@ function baml.iter.FlatMap$stream.next(self: baml.iter.FlatMap$stream) -> unknow } Done { } : baml.iter.Done } - !! 7808..7816: type `never` has no member `next` - !! 7938..7953: type mismatch: expected baml.iter.Iterator | baml.iter.Done$stream | null, got baml.iter.Done - !! 7978..7994: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 7978..7996: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called - !! 7704..8203: non-exhaustive match on `baml.iter.Iterator | baml.iter.Done$stream | null`; missing: baml.iter.Iterator, baml.iter.Done$stream {}, null - !! 7786..7937: unreachable arm - !! 7956..8192: unreachable arm + !! 8047..8055: type `never` has no member `next` + !! 8177..8192: type mismatch: expected baml.iter.Iterator | baml.iter.Done$stream | null, got baml.iter.Done + !! 8217..8233: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 8217..8235: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 7943..8442: non-exhaustive match on `baml.iter.Iterator | baml.iter.Done$stream | null`; missing: baml.iter.Iterator, baml.iter.Done$stream {}, null + !! 8025..8176: unreachable arm + !! 8195..8431: unreachable arm } class baml.iter.Flatten$stream { source: baml.iter.Iterator | null @@ -2156,7 +2177,7 @@ function baml.iter.Flatten$stream.iter(self: baml.iter.Flatten$stream) -> baml.i { : baml.iter.Flatten$stream self : baml.iter.Flatten$stream } - !! 8539..8543: type mismatch: expected baml.iter.Iterator, got baml.iter.Flatten$stream + !! 8778..8782: type mismatch: expected baml.iter.Iterator, got baml.iter.Flatten$stream } function baml.iter.Flatten$stream.next(self: baml.iter.Flatten$stream) -> unknown | baml.iter.Done throws unknown | unknown { { : baml.iter.Done @@ -2191,13 +2212,13 @@ function baml.iter.Flatten$stream.next(self: baml.iter.Flatten$stream) -> unknow } Done { } : baml.iter.Done } - !! 8794..8802: type `never` has no member `next` - !! 8924..8939: type mismatch: expected baml.iter.Iterator | baml.iter.Done$stream | null, got baml.iter.Done - !! 8964..8980: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 8964..8982: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called - !! 8690..9178: non-exhaustive match on `baml.iter.Iterator | baml.iter.Done$stream | null`; missing: baml.iter.Iterator, baml.iter.Done$stream {}, null - !! 8772..8923: unreachable arm - !! 8942..9167: unreachable arm + !! 9033..9041: type `never` has no member `next` + !! 9163..9178: type mismatch: expected baml.iter.Iterator | baml.iter.Done$stream | null, got baml.iter.Done + !! 9203..9219: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 9203..9221: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 8929..9417: non-exhaustive match on `baml.iter.Iterator | baml.iter.Done$stream | null`; missing: baml.iter.Iterator, baml.iter.Done$stream {}, null + !! 9011..9162: unreachable arm + !! 9181..9406: unreachable arm } class baml.iter.Peekable$stream { source: baml.iter.Iterator | null @@ -2208,7 +2229,7 @@ function baml.iter.Peekable$stream.iter(self: baml.iter.Peekable$stream) -> baml { : baml.iter.Peekable$stream self : baml.iter.Peekable$stream } - !! 9646..9650: type mismatch: expected baml.iter.Iterator, got baml.iter.Peekable$stream + !! 9885..9889: type mismatch: expected baml.iter.Iterator, got baml.iter.Peekable$stream } function baml.iter.Peekable$stream.next(self: baml.iter.Peekable$stream) -> unknown | baml.iter.Done throws unknown { { : unknown @@ -2221,9 +2242,9 @@ function baml.iter.Peekable$stream.next(self: baml.iter.Peekable$stream) -> unkn } self.source.next() : unknown } - !! 9904..9905: type mismatch: expected T | baml.iter.Done, got T | baml.iter.Done$stream | null - !! 9914..9937: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 9914..9939: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 10143..10144: type mismatch: expected T | baml.iter.Done, got T | baml.iter.Done$stream | null + !! 10153..10176: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 10153..10178: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } class baml.iter.StepBy$stream { source: baml.iter.Iterator | null @@ -2234,7 +2255,7 @@ function baml.iter.StepBy$stream.iter(self: baml.iter.StepBy$stream) -> baml.ite { : baml.iter.StepBy$stream self : baml.iter.StepBy$stream } - !! 10172..10176: type mismatch: expected baml.iter.Iterator, got baml.iter.StepBy$stream + !! 10411..10415: type mismatch: expected baml.iter.Iterator, got baml.iter.StepBy$stream } function baml.iter.StepBy$stream.next(self: baml.iter.StepBy$stream) -> unknown | baml.iter.Done throws unknown { { : unknown @@ -2259,13 +2280,13 @@ function baml.iter.StepBy$stream.next(self: baml.iter.StepBy$stream) -> unknown } self.source.next() : unknown } - !! 10359..10376: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 10359..10378: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called - !! 10413..10424: operator `Sub` cannot be applied to `int | null` and `1` - !! 10451..10467: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 10451..10469: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called - !! 10555..10578: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null - !! 10555..10580: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 10598..10615: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 10598..10617: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 10652..10663: operator `Sub` cannot be applied to `int | null` and `1` + !! 10690..10706: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 10690..10708: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 10794..10817: did you mean `self.source?.next`? `self.source.next` does not handle the case when `self.source` is null + !! 10794..10819: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } class baml.iter.Chain$stream { first: baml.iter.Iterator | null @@ -2276,7 +2297,7 @@ function baml.iter.Chain$stream.iter(self: baml.iter.Chain$stream) -> baml.iter. { : baml.iter.Chain$stream self : baml.iter.Chain$stream } - !! 10861..10865: type mismatch: expected baml.iter.Iterator, got baml.iter.Chain$stream + !! 11100..11104: type mismatch: expected baml.iter.Iterator, got baml.iter.Chain$stream } function baml.iter.Chain$stream.next(self: baml.iter.Chain$stream) -> unknown | baml.iter.Done throws unknown | unknown { { : unknown @@ -2294,10 +2315,10 @@ function baml.iter.Chain$stream.next(self: baml.iter.Chain$stream) -> unknown | } self.other.next() : unknown } - !! 11037..11052: did you mean `self.first?.next`? `self.first.next` does not handle the case when `self.first` is null - !! 11037..11054: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called - !! 11159..11181: did you mean `self.other?.next`? `self.other.next` does not handle the case when `self.other` is null - !! 11159..11183: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 11276..11291: did you mean `self.first?.next`? `self.first.next` does not handle the case when `self.first` is null + !! 11276..11293: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called + !! 11398..11420: did you mean `self.other?.next`? `self.other.next` does not handle the case when `self.other` is null + !! 11398..11422: `(() -> unknown | baml.iter.Done throws never) | null` is not a function — it cannot be called } --- /baml/ns_json/json.baml --- diff --git a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap index 867566d6918..05cdd33defe 100644 --- a/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap +++ b/baml_language/crates/baml_tests/snapshots/compiles/__baml_std__/baml_tests__compiles____baml_std____06_codegen.snap @@ -16,6 +16,195 @@ function baml.Array.every(self: baml.Array, predicate: (unknown) -> boo function baml.Array.filter(self: baml.Array, predicate: (unknown) -> bool throws unknown) -> unknown[] { } +function baml.Array.filter_map(self: baml.Array, fn: (unknown) -> unknown | null throws unknown) -> unknown[] { + alloc_array 0 + store_var out + load_type #0 + load_var self + load_const 0 + load_var self + container_len + call baml.Array.slice + store_var _4 + load_type #0 + load_var _4 + call baml.iter.Iterable$for$T[].iter + store_var _7 + + L0: + load_var _7 + is_type baml.iter.Flatten<...> + pop_jump_if_false L1 + jump L20 + + L1: + load_var _7 + is_type baml.iter.Range + pop_jump_if_false L2 + jump L19 + + L2: + load_var _7 + is_type baml.iter.ArrayIterator<...> + pop_jump_if_false L3 + jump L18 + + L3: + load_var _7 + is_type baml.iter.StepBy<...> + pop_jump_if_false L4 + jump L17 + + L4: + load_var _7 + is_type baml.iter.Chain<...> + pop_jump_if_false L5 + jump L16 + + L5: + load_var _7 + is_type baml.iter.Repeat<...> + pop_jump_if_false L6 + jump L15 + + L6: + load_var _7 + is_type baml.iter.Map<...> + pop_jump_if_false L7 + jump L14 + + L7: + load_var _7 + is_type baml.iter.Filter<...> + pop_jump_if_false L8 + jump L13 + + L8: + load_var _7 + is_type baml.iter.FilterMap<...> + pop_jump_if_false L9 + jump L12 + + L9: + load_var _7 + is_type baml.iter.FlatMap<...> + pop_jump_if_false L10 + jump L11 + + L10: + load_var _7 + is_type baml.iter.Peekable<...> + pop_jump_if_false L25 + load_type #0 + load_type void + load_var _7 + call baml.iter.Peekable.Iterator.next + store_var _9 + jump L21 + + L11: + load_var _7 + make_bound_method baml.iter.FlatMap.Iterator.next + call_indirect + store_var _9 + jump L21 + + L12: + load_var _7 + make_bound_method baml.iter.FilterMap.Iterator.next + call_indirect + store_var _9 + jump L21 + + L13: + load_type #0 + load_type void + load_type void + load_var _7 + call baml.iter.Filter.Iterator.next + store_var _9 + jump L21 + + L14: + load_var _7 + make_bound_method baml.iter.Map.Iterator.next + call_indirect + store_var _9 + jump L21 + + L15: + load_type #0 + load_var _7 + call baml.iter.Repeat.Iterator.next + store_var _9 + jump L21 + + L16: + load_type #0 + load_type void + load_type void + load_var _7 + call baml.iter.Chain.Iterator.next + store_var _9 + jump L21 + + L17: + load_type #0 + load_type void + load_var _7 + call baml.iter.StepBy.Iterator.next + store_var _9 + jump L21 + + L18: + load_type #0 + load_var _7 + call baml.iter.ArrayIterator.Iterator.next + store_var _9 + jump L21 + + L19: + load_var _7 + call baml.iter.Range.Iterator.next + store_var _9 + jump L21 + + L20: + load_var _7 + make_bound_method baml.iter.Flatten.Iterator.next + call_indirect + store_var _9 + + L21: + load_var _9 + is_type baml.iter.Done + pop_jump_if_false L22 + jump L24 + + L22: + load_var2 6 2 + call_indirect + store_var _40 + load_var _40 + load_const null + cmp_op == + pop_jump_if_false L23 + jump L0 + + L23: + load_var2 3 7 + call baml.Array.push + pop 1 + jump L0 + + L24: + load_var out + return + + L25: + unreachable +} + function baml.Array.find(self: baml.Array, predicate: (unknown) -> bool throws unknown) -> unknown | null { } @@ -5329,27 +5518,29 @@ function baml.iter.ArrayIterator$stream.Iterable.iter(self: baml.iter.ArrayItera } function baml.iter.ArrayIterator$stream.Iterator.next(self: baml.iter.ArrayIterator$stream) -> unknown | baml.iter.Done { - load_type #0 - load_var self - load_field .0 load_var self load_field .1 - call baml.Array.at - store_var _2 - load_var _2 - load_const null - cmp_op == + store_var _3 + load_var2 2 1 + load_field .0 + container_len + cmp_int_op >= pop_jump_if_false L0 jump L1 L0: + load_type #0 + load_var self + load_field .0 + load_var self + load_field .1 + call baml.Array.at load_var self copy 0 load_field .1 load_const 1 bin_op + store_field .1 - load_var _2 jump L2 L1: @@ -5365,27 +5556,29 @@ function baml.iter.ArrayIterator.Iterable.iter(self: baml.iter.ArrayIterator) -> unknown | baml.iter.Done { - load_type #0 - load_var self - load_field .0 load_var self load_field .1 - call baml.Array.at - store_var _2 - load_var _2 - load_const null - cmp_op == + store_var _3 + load_var2 2 1 + load_field .0 + container_len + cmp_int_op >= pop_jump_if_false L0 jump L1 L0: + load_type #0 + load_var self + load_field .0 + load_var self + load_field .1 + call baml.Array.at load_var self copy 0 load_field .1 load_const 1 bin_op + store_field .1 - load_var _2 jump L2 L1: diff --git a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap index 9e8fe7965a1..1ef0f4a1c53 100644 --- a/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap +++ b/baml_language/crates/baml_tests/src/compiler2_tir/snapshots/baml_tests__compiler2_tir__phase5__snapshot_baml_package_items.snap @@ -3,7 +3,7 @@ source: crates/baml_tests/src/compiler2_tir/phase5.rs expression: output --- namespace baml: - class Array { methods: [length, at, push, pop, remove_at, concat, for_each, filter, reverse, sort_by, sort_by_key, slice, join, map, to_json, some, every, find, find_index, find_last, find_last_index, includes, index_of, last_index_of, reduce, flat_map, clear, shift, unshift, insert, splice, from_json] } + class Array { methods: [length, at, push, pop, remove_at, concat, for_each, filter, filter_map, reverse, sort_by, sort_by_key, slice, join, map, to_json, some, every, find, find_index, find_last, find_last_index, includes, index_of, last_index_of, reduce, flat_map, clear, shift, unshift, insert, splice, from_json] } class Bigint { methods: [to_json, abs, min, max, clamp, isqrt, pow, ilog, parse, random, from_json] } class Bool { methods: [to_json, from_json] } type Comparable diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap index 54b6dd39583..5bf57a45bce 100644 --- a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap +++ b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded.snap @@ -3,7 +3,7 @@ source: crates/baml_tests/tests/bytecode_format/main.rs --- function assert.contains(haystack: string, needle: string) -> null { 32 0 load_var2 1 2 - 1 call 182 ntypeargs=0 (baml.String.includes) + 1 call 183 ntypeargs=0 (baml.String.includes) 2 unary_op ! 3 pop_jump_if_false +2 (to 5) 4 jump +3 (to 7) @@ -13,7 +13,7 @@ function assert.contains(haystack: string, needle: string) -> null { 32 6 jump +3 (to 9) 33 7 load_const 1 ("assertion failed: string does not contain expected substring") - 8 call 308 ntypeargs=0 (baml.sys.panic) + 8 call 309 ntypeargs=0 (baml.sys.panic) 9 return } @@ -28,7 +28,7 @@ function assert.equal(actual: unknown, expected: unknown) -> null { 23 5 jump +3 (to 8) 24 6 load_const 1 ("assertion failed: expected equal values") - 7 call 308 ntypeargs=0 (baml.sys.panic) + 7 call 309 ntypeargs=0 (baml.sys.panic) 8 return } @@ -43,7 +43,7 @@ function assert.is_true(condition: bool) -> null { 5 5 jump +3 (to 8) 6 6 load_const 1 ("assertion failed: expected true") - 7 call 308 ntypeargs=0 (baml.sys.panic) + 7 call 309 ntypeargs=0 (baml.sys.panic) 8 return } @@ -59,7 +59,7 @@ function assert.not_null(value: unknown | null) -> null { 14 6 jump +3 (to 9) 15 7 load_const 1 ("assertion failed: expected non-null value") - 8 call 308 ntypeargs=0 (baml.sys.panic) + 8 call 309 ntypeargs=0 (baml.sys.panic) 9 return } @@ -72,18 +72,18 @@ function testing.$invoke_collector(collector: (testing.TestCollector) -> void th function testing.RunReport.from_json(j: baml.json.json) -> testing.RunReport { 7 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("duration_ms") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.RunReport .outcome, .duration_ms) 15 return } @@ -96,7 +96,7 @@ function testing.RunReport.to_json(self: testing.RunReport) -> baml.json.json { 4 call_indirect 5 load_var 1 (self) 6 load_field 1 (duration_ms) - 7 call 66 ntypeargs=0 (baml.Int.to_json) + 7 call 67 ntypeargs=0 (baml.Int.to_json) 8 load_const 1 ("outcome") 9 load_const 2 ("duration_ms") 10 alloc_map 2 @@ -106,18 +106,18 @@ function testing.RunReport.to_json(self: testing.RunReport) -> baml.json.json { function testing.SerializedTest.from_json(j: baml.json.json) -> testing.SerializedTest { 78 0 load_var 1 (j) 1 load_const 0 ("type") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("name") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 1 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.SerializedTest .type, .name) 15 return } @@ -125,10 +125,10 @@ function testing.SerializedTest.from_json(j: baml.json.json) -> testing.Serializ function testing.SerializedTest.to_json(self: testing.SerializedTest) -> baml.json.json { 78 0 load_var 1 (self) 1 load_field 0 (type) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_var 1 (self) 4 load_field 1 (name) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_const 0 ("type") 7 load_const 1 ("name") 8 alloc_map 2 @@ -138,25 +138,25 @@ function testing.SerializedTest.to_json(self: testing.SerializedTest) -> baml.js function testing.SerializedTestSet.from_json(j: baml.json.json) -> testing.SerializedTestSet { 83 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("items") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("loadingTimeMs") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.SerializedTestSet .name, .items, .loadingTimeMs) 22 return } @@ -164,14 +164,14 @@ function testing.SerializedTestSet.from_json(j: baml.json.json) -> testing.Seria function testing.SerializedTestSet.to_json(self: testing.SerializedTestSet) -> baml.json.json { 83 0 load_var 1 (self) 1 load_field 0 (name) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_type 0 4 load_var 1 (self) 5 load_field 1 (items) 6 call 34 ntypeargs=1 (baml.Array.to_json) 7 load_var 1 (self) 8 load_field 2 (loadingTimeMs) - 9 call 66 ntypeargs=0 (baml.Int.to_json) + 9 call 67 ntypeargs=0 (baml.Int.to_json) 10 load_const 1 ("name") 11 load_const 2 ("items") 12 load_const 3 ("loadingTimeMs") @@ -185,7 +185,7 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 2 store_var 3 (_3) 3 load_type 0 4 load_var 3 (_3) - 5 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 5 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 6 store_var 4 (_4) 7 load_var 4 (_4) 8 is_type 1 @@ -229,16 +229,16 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 46 load_type 0 47 load_type 11 48 load_var 4 (_4) - 49 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 49 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 50 store_var 5 (_6) 51 jump +50 (to 101) 52 load_var 4 (_4) - 53 make_bound_method 662 + 53 make_bound_method 663 54 call_indirect 55 store_var 5 (_6) 56 jump +45 (to 101) 57 load_var 4 (_4) - 58 make_bound_method 675 + 58 make_bound_method 676 59 call_indirect 60 store_var 5 (_6) 61 jump +40 (to 101) @@ -246,39 +246,39 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 63 load_type 11 64 load_type 11 65 load_var 4 (_4) - 66 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 66 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 67 store_var 5 (_6) 68 jump +33 (to 101) 69 load_var 4 (_4) - 70 make_bound_method 611 + 70 make_bound_method 612 71 call_indirect 72 store_var 5 (_6) 73 jump +28 (to 101) 74 load_type 0 75 load_var 4 (_4) - 76 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 76 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 77 store_var 5 (_6) 78 jump +23 (to 101) 79 load_type 0 80 load_type 11 81 load_type 11 82 load_var 4 (_4) - 83 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 83 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 84 store_var 5 (_6) 85 jump +16 (to 101) 86 load_type 0 87 load_type 11 88 load_var 4 (_4) - 89 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 89 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 90 store_var 5 (_6) 91 jump +10 (to 101) 92 load_type 0 93 load_var 4 (_4) - 94 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 94 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 95 store_var 5 (_6) 96 jump +5 (to 101) 97 load_var 4 (_4) - 98 make_bound_method 646 + 98 make_bound_method 647 99 call_indirect 100 store_var 5 (_6) 101 load_var 5 (_6) @@ -306,25 +306,25 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s function testing.TestCollector.from_json(j: baml.json.json) -> testing.TestCollector { 29 0 load_var 1 (j) 1 load_const 0 ("prefix") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("tests") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("testsets") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) 22 return } @@ -368,7 +368,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 24 store_var 8 (_13) 25 load_type 4 26 load_var 8 (_13) - 27 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 27 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 28 store_var 9 (_14) 29 load_var 9 (_14) 30 is_type 5 @@ -412,16 +412,16 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 68 load_type 4 69 load_type 15 70 load_var 9 (_14) - 71 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 71 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 72 store_var 10 (_16) 73 jump +50 (to 123) 74 load_var 9 (_14) - 75 make_bound_method 662 + 75 make_bound_method 663 76 call_indirect 77 store_var 10 (_16) 78 jump +45 (to 123) 79 load_var 9 (_14) - 80 make_bound_method 675 + 80 make_bound_method 676 81 call_indirect 82 store_var 10 (_16) 83 jump +40 (to 123) @@ -429,39 +429,39 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 85 load_type 15 86 load_type 15 87 load_var 9 (_14) - 88 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 88 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 89 store_var 10 (_16) 90 jump +33 (to 123) 91 load_var 9 (_14) - 92 make_bound_method 611 + 92 make_bound_method 612 93 call_indirect 94 store_var 10 (_16) 95 jump +28 (to 123) 96 load_type 4 97 load_var 9 (_14) - 98 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 98 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 99 store_var 10 (_16) 100 jump +23 (to 123) 101 load_type 4 102 load_type 15 103 load_type 15 104 load_var 9 (_14) - 105 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 105 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 106 store_var 10 (_16) 107 jump +16 (to 123) 108 load_type 4 109 load_type 15 110 load_var 9 (_14) - 111 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 111 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 112 store_var 10 (_16) 113 jump +10 (to 123) 114 load_type 4 115 load_var 9 (_14) - 116 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 116 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 117 store_var 10 (_16) 118 jump +5 (to 123) 119 load_var 9 (_14) - 120 make_bound_method 646 + 120 make_bound_method 647 121 call_indirect 122 store_var 10 (_16) 123 load_var 10 (_16) @@ -480,7 +480,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 135 load_var 11 (t) 136 load_field 0 (name) 137 load_var 7 (hash_prefix) - 138 call 155 ntypeargs=0 (baml.String.starts_with) + 138 call 156 ntypeargs=0 (baml.String.starts_with) 139 pop_jump_if_false -110 (to 29) 140 load_var 6 (count) 141 load_const 17 (1) @@ -504,7 +504,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 158 load_var 6 (count) 159 load_const 17 (1) 160 add_int - 161 call 517 ntypeargs=1 (baml.unstable.string) + 161 call 518 ntypeargs=1 (baml.unstable.string) 162 store_var 14 (_57) 163 load_var2 13 14 164 bin_op + @@ -555,7 +555,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 24 store_var 8 (_13) 25 load_type 4 26 load_var 8 (_13) - 27 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 27 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 28 store_var 9 (_14) 29 load_var 9 (_14) 30 is_type 5 @@ -599,16 +599,16 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 68 load_type 4 69 load_type 15 70 load_var 9 (_14) - 71 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 71 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 72 store_var 10 (_16) 73 jump +50 (to 123) 74 load_var 9 (_14) - 75 make_bound_method 662 + 75 make_bound_method 663 76 call_indirect 77 store_var 10 (_16) 78 jump +45 (to 123) 79 load_var 9 (_14) - 80 make_bound_method 675 + 80 make_bound_method 676 81 call_indirect 82 store_var 10 (_16) 83 jump +40 (to 123) @@ -616,39 +616,39 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 85 load_type 15 86 load_type 15 87 load_var 9 (_14) - 88 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 88 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 89 store_var 10 (_16) 90 jump +33 (to 123) 91 load_var 9 (_14) - 92 make_bound_method 611 + 92 make_bound_method 612 93 call_indirect 94 store_var 10 (_16) 95 jump +28 (to 123) 96 load_type 4 97 load_var 9 (_14) - 98 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 98 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 99 store_var 10 (_16) 100 jump +23 (to 123) 101 load_type 4 102 load_type 15 103 load_type 15 104 load_var 9 (_14) - 105 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 105 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 106 store_var 10 (_16) 107 jump +16 (to 123) 108 load_type 4 109 load_type 15 110 load_var 9 (_14) - 111 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 111 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 112 store_var 10 (_16) 113 jump +10 (to 123) 114 load_type 4 115 load_var 9 (_14) - 116 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 116 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 117 store_var 10 (_16) 118 jump +5 (to 123) 119 load_var 9 (_14) - 120 make_bound_method 646 + 120 make_bound_method 647 121 call_indirect 122 store_var 10 (_16) 123 load_var 10 (_16) @@ -667,7 +667,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 135 load_var 11 (ts) 136 load_field 0 (name) 137 load_var 7 (hash_prefix) - 138 call 155 ntypeargs=0 (baml.String.starts_with) + 138 call 156 ntypeargs=0 (baml.String.starts_with) 139 pop_jump_if_false -110 (to 29) 140 load_var 6 (count) 141 load_const 17 (1) @@ -691,7 +691,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 158 load_var 6 (count) 159 load_const 17 (1) 160 add_int - 161 call 517 ntypeargs=1 (baml.unstable.string) + 161 call 518 ntypeargs=1 (baml.unstable.string) 162 store_var 14 (_57) 163 load_var2 13 14 164 bin_op + @@ -714,7 +714,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na function testing.TestCollector.to_json(self: testing.TestCollector) -> baml.json.json { 29 0 load_var 1 (self) 1 load_field 0 (prefix) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_type 0 4 load_var 1 (self) 5 load_field 1 (tests) @@ -733,25 +733,25 @@ function testing.TestCollector.to_json(self: testing.TestCollector) -> baml.json function testing.TestRegistration.from_json(j: baml.json.json) -> testing.TestRegistration { 5 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("body") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("runner") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestRegistration .name, .body, .runner) 22 return } @@ -759,8 +759,8 @@ function testing.TestRegistration.from_json(j: baml.json.json) -> testing.TestRe function testing.TestRegistration.to_json(self: testing.TestRegistration) -> baml.json.json { 13 0 load_type 0 1 load_var 1 (self) - 2 call 412 ntypeargs=1 (baml.json.to_string) - 3 call 407 ntypeargs=0 (baml.json.parse) + 2 call 413 ntypeargs=1 (baml.json.to_string) + 3 call 408 ntypeargs=0 (baml.json.parse) 4 return } @@ -772,7 +772,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 156 4 load_type 0 5 load_var 3 (_3) - 6 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 6 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 7 store_var 4 (_4) 8 load_var 4 (_4) 9 is_type 1 @@ -816,16 +816,16 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 47 load_type 0 48 load_type 11 49 load_var 4 (_4) - 50 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 50 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 51 store_var 5 (_6) 52 jump +50 (to 102) 53 load_var 4 (_4) - 54 make_bound_method 662 + 54 make_bound_method 663 55 call_indirect 56 store_var 5 (_6) 57 jump +45 (to 102) 58 load_var 4 (_4) - 59 make_bound_method 675 + 59 make_bound_method 676 60 call_indirect 61 store_var 5 (_6) 62 jump +40 (to 102) @@ -833,39 +833,39 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 64 load_type 11 65 load_type 11 66 load_var 4 (_4) - 67 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 67 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 68 store_var 5 (_6) 69 jump +33 (to 102) 70 load_var 4 (_4) - 71 make_bound_method 611 + 71 make_bound_method 612 72 call_indirect 73 store_var 5 (_6) 74 jump +28 (to 102) 75 load_type 0 76 load_var 4 (_4) - 77 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 77 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 78 store_var 5 (_6) 79 jump +23 (to 102) 80 load_type 0 81 load_type 11 82 load_type 11 83 load_var 4 (_4) - 84 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 84 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 85 store_var 5 (_6) 86 jump +16 (to 102) 87 load_type 0 88 load_type 11 89 load_var 4 (_4) - 90 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 90 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 91 store_var 5 (_6) 92 jump +10 (to 102) 93 load_type 0 94 load_var 4 (_4) - 95 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 95 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 96 store_var 5 (_6) 97 jump +5 (to 102) 98 load_var 4 (_4) - 99 make_bound_method 646 + 99 make_bound_method 647 100 call_indirect 101 store_var 5 (_6) 102 load_var 5 (_6) @@ -880,7 +880,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 110 cmp_op == 111 pop_jump_if_false -103 (to 8) - 159 112 call 304 ntypeargs=0 (baml.sys.now_ms) + 159 112 call 305 ntypeargs=0 (baml.sys.now_ms) 113 store_var 7 (start) 160 114 load_var 2 (name) @@ -894,7 +894,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 121 call_indirect 122 pop 1 - 162 123 call 304 ntypeargs=0 (baml.sys.now_ms) + 162 123 call 305 ntypeargs=0 (baml.sys.now_ms) 124 store_var 9 (_46) 168 125 load_type 13 @@ -912,7 +912,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 135 pop 1 169 136 load_var 1 (self) - 137 call 840 ntypeargs=0 (testing.TestRegistry.serialize) + 137 call 841 ntypeargs=0 (testing.TestRegistry.serialize) 138 jump +123 (to 261) 173 139 load_type 13 @@ -924,7 +924,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 172 145 load_type 13 146 load_var 10 (_57) - 147 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 147 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 148 store_var 11 (_61) 149 load_var 11 (_61) 150 is_type 15 @@ -968,16 +968,16 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 188 load_type 13 189 load_type 11 190 load_var 11 (_61) - 191 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 191 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 192 store_var 12 (_63) 193 jump +50 (to 243) 194 load_var 11 (_61) - 195 make_bound_method 662 + 195 make_bound_method 663 196 call_indirect 197 store_var 12 (_63) 198 jump +45 (to 243) 199 load_var 11 (_61) - 200 make_bound_method 675 + 200 make_bound_method 676 201 call_indirect 202 store_var 12 (_63) 203 jump +40 (to 243) @@ -985,39 +985,39 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 205 load_type 11 206 load_type 11 207 load_var 11 (_61) - 208 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 208 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 209 store_var 12 (_63) 210 jump +33 (to 243) 211 load_var 11 (_61) - 212 make_bound_method 611 + 212 make_bound_method 612 213 call_indirect 214 store_var 12 (_63) 215 jump +28 (to 243) 216 load_type 13 217 load_var 11 (_61) - 218 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 218 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 219 store_var 12 (_63) 220 jump +23 (to 243) 221 load_type 13 222 load_type 11 223 load_type 11 224 load_var 11 (_61) - 225 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 225 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 226 store_var 12 (_63) 227 jump +16 (to 243) 228 load_type 13 229 load_type 11 230 load_var 11 (_61) - 231 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 231 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 232 store_var 12 (_63) 233 jump +10 (to 243) 234 load_type 13 235 load_var 11 (_61) - 236 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 236 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 237 store_var 12 (_63) 238 jump +5 (to 243) 239 load_var 11 (_61) - 240 make_bound_method 646 + 240 make_bound_method 647 241 call_indirect 242 store_var 12 (_63) 243 load_var 12 (_63) @@ -1036,11 +1036,11 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 175 254 load_var2 2 13 255 load_const 25 ("/") 256 bin_op + - 257 call 155 ntypeargs=0 (baml.String.starts_with) + 257 call 156 ntypeargs=0 (baml.String.starts_with) 258 pop_jump_if_false -109 (to 149) 176 259 load_var2 14 2 - 260 call 845 ntypeargs=0 (testing.TestRegistry.expand_set) + 260 call 846 ntypeargs=0 (testing.TestRegistry.expand_set) 261 return 179 262 load_const 26 ("TestSet not found for expansion: ") @@ -1053,25 +1053,25 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin function testing.TestRegistry.from_json(j: baml.json.json) -> testing.TestRegistry { 93 0 load_var 1 (j) 1 load_const 0 ("collector") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("expansions") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("loading_time_ms") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) 22 return } @@ -1093,7 +1093,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 136 4 load_type 0 5 load_var 3 (_3) - 6 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 6 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 7 store_var 4 (_4) 8 load_var 4 (_4) 9 is_type 1 @@ -1137,16 +1137,16 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 47 load_type 0 48 load_type 11 49 load_var 4 (_4) - 50 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 50 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 51 store_var 5 (_6) 52 jump +50 (to 102) 53 load_var 4 (_4) - 54 make_bound_method 662 + 54 make_bound_method 663 55 call_indirect 56 store_var 5 (_6) 57 jump +45 (to 102) 58 load_var 4 (_4) - 59 make_bound_method 675 + 59 make_bound_method 676 60 call_indirect 61 store_var 5 (_6) 62 jump +40 (to 102) @@ -1154,39 +1154,39 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 64 load_type 11 65 load_type 11 66 load_var 4 (_4) - 67 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 67 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 68 store_var 5 (_6) 69 jump +33 (to 102) 70 load_var 4 (_4) - 71 make_bound_method 611 + 71 make_bound_method 612 72 call_indirect 73 store_var 5 (_6) 74 jump +28 (to 102) 75 load_type 0 76 load_var 4 (_4) - 77 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 77 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 78 store_var 5 (_6) 79 jump +23 (to 102) 80 load_type 0 81 load_type 11 82 load_type 11 83 load_var 4 (_4) - 84 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 84 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 85 store_var 5 (_6) 86 jump +16 (to 102) 87 load_type 0 88 load_type 11 89 load_var 4 (_4) - 90 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 90 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 91 store_var 5 (_6) 92 jump +10 (to 102) 93 load_type 0 94 load_var 4 (_4) - 95 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 95 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 96 store_var 5 (_6) 97 jump +5 (to 102) 98 load_var 4 (_4) - 99 make_bound_method 646 + 99 make_bound_method 647 100 call_indirect 101 store_var 5 (_6) 102 load_var 5 (_6) @@ -1205,7 +1205,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 113 load_field 1 (body) 114 load_var 6 (t) 115 load_field 2 (runner) - 116 call 851 ntypeargs=0 (testing.run_test) + 116 call 852 ntypeargs=0 (testing.run_test) 117 jump +123 (to 240) 143 118 load_type 13 @@ -1217,7 +1217,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 142 124 load_type 13 125 load_var 7 (_40) - 126 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 126 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 127 store_var 8 (_44) 128 load_var 8 (_44) 129 is_type 15 @@ -1261,16 +1261,16 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 167 load_type 13 168 load_type 11 169 load_var 8 (_44) - 170 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 170 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 171 store_var 9 (_46) 172 jump +50 (to 222) 173 load_var 8 (_44) - 174 make_bound_method 662 + 174 make_bound_method 663 175 call_indirect 176 store_var 9 (_46) 177 jump +45 (to 222) 178 load_var 8 (_44) - 179 make_bound_method 675 + 179 make_bound_method 676 180 call_indirect 181 store_var 9 (_46) 182 jump +40 (to 222) @@ -1278,39 +1278,39 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 184 load_type 11 185 load_type 11 186 load_var 8 (_44) - 187 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 187 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 188 store_var 9 (_46) 189 jump +33 (to 222) 190 load_var 8 (_44) - 191 make_bound_method 611 + 191 make_bound_method 612 192 call_indirect 193 store_var 9 (_46) 194 jump +28 (to 222) 195 load_type 13 196 load_var 8 (_44) - 197 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 197 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 198 store_var 9 (_46) 199 jump +23 (to 222) 200 load_type 13 201 load_type 11 202 load_type 11 203 load_var 8 (_44) - 204 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 204 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 205 store_var 9 (_46) 206 jump +16 (to 222) 207 load_type 13 208 load_type 11 209 load_var 8 (_44) - 210 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 210 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 211 store_var 9 (_46) 212 jump +10 (to 222) 213 load_type 13 214 load_var 8 (_44) - 215 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 215 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 216 store_var 9 (_46) 217 jump +5 (to 222) 218 load_var 8 (_44) - 219 make_bound_method 646 + 219 make_bound_method 647 220 call_indirect 221 store_var 9 (_46) 222 load_var 9 (_46) @@ -1329,12 +1329,12 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 146 233 load_var2 2 10 234 load_const 25 ("/") 235 bin_op + - 236 call 155 ntypeargs=0 (baml.String.starts_with) + 236 call 156 ntypeargs=0 (baml.String.starts_with) 145 237 pop_jump_if_false -109 (to 128) 147 238 load_var2 11 2 - 239 call 844 ntypeargs=0 (testing.TestRegistry.run_test) + 239 call 845 ntypeargs=0 (testing.TestRegistry.run_test) 240 return 150 241 load_const 26 ("Test not found: ") @@ -1354,7 +1354,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 5 store_var 3 (_3) 6 load_type 0 7 load_var 3 (_3) - 8 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 8 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 9 store_var 4 (_4) 10 load_var 4 (_4) 11 is_type 1 @@ -1398,16 +1398,16 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 49 load_type 0 50 load_type 11 51 load_var 4 (_4) - 52 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 52 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 53 store_var 5 (_6) 54 jump +50 (to 104) 55 load_var 4 (_4) - 56 make_bound_method 662 + 56 make_bound_method 663 57 call_indirect 58 store_var 5 (_6) 59 jump +45 (to 104) 60 load_var 4 (_4) - 61 make_bound_method 675 + 61 make_bound_method 676 62 call_indirect 63 store_var 5 (_6) 64 jump +40 (to 104) @@ -1415,39 +1415,39 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 66 load_type 11 67 load_type 11 68 load_var 4 (_4) - 69 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 69 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 70 store_var 5 (_6) 71 jump +33 (to 104) 72 load_var 4 (_4) - 73 make_bound_method 611 + 73 make_bound_method 612 74 call_indirect 75 store_var 5 (_6) 76 jump +28 (to 104) 77 load_type 0 78 load_var 4 (_4) - 79 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 79 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 80 store_var 5 (_6) 81 jump +23 (to 104) 82 load_type 0 83 load_type 11 84 load_type 11 85 load_var 4 (_4) - 86 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 86 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 87 store_var 5 (_6) 88 jump +16 (to 104) 89 load_type 0 90 load_type 11 91 load_var 4 (_4) - 92 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 92 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 93 store_var 5 (_6) 94 jump +10 (to 104) 95 load_type 0 96 load_var 4 (_4) - 97 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 97 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 98 store_var 5 (_6) 99 jump +5 (to 104) 100 load_var 4 (_4) - 101 make_bound_method 646 + 101 make_bound_method 647 102 call_indirect 103 store_var 5 (_6) 104 load_var 5 (_6) @@ -1471,7 +1471,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 119 store_var 6 (_39) 120 load_type 14 121 load_var 6 (_39) - 122 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 122 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 123 store_var 7 (_40) 124 load_var 7 (_40) 125 is_type 15 @@ -1515,16 +1515,16 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 163 load_type 14 164 load_type 11 165 load_var 7 (_40) - 166 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 166 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 167 store_var 8 (_42) 168 jump +50 (to 218) 169 load_var 7 (_40) - 170 make_bound_method 662 + 170 make_bound_method 663 171 call_indirect 172 store_var 8 (_42) 173 jump +45 (to 218) 174 load_var 7 (_40) - 175 make_bound_method 675 + 175 make_bound_method 676 176 call_indirect 177 store_var 8 (_42) 178 jump +40 (to 218) @@ -1532,39 +1532,39 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 180 load_type 11 181 load_type 11 182 load_var 7 (_40) - 183 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 183 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 184 store_var 8 (_42) 185 jump +33 (to 218) 186 load_var 7 (_40) - 187 make_bound_method 611 + 187 make_bound_method 612 188 call_indirect 189 store_var 8 (_42) 190 jump +28 (to 218) 191 load_type 14 192 load_var 7 (_40) - 193 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 193 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 194 store_var 8 (_42) 195 jump +23 (to 218) 196 load_type 14 197 load_type 11 198 load_type 11 199 load_var 7 (_40) - 200 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 200 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 201 store_var 8 (_42) 202 jump +16 (to 218) 203 load_type 14 204 load_type 11 205 load_var 7 (_40) - 206 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 206 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 207 store_var 8 (_42) 208 jump +10 (to 218) 209 load_type 14 210 load_var 7 (_40) - 211 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 211 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 212 store_var 8 (_42) 213 jump +5 (to 218) 214 load_var 7 (_40) - 215 make_bound_method 646 + 215 make_bound_method 647 216 call_indirect 217 store_var 8 (_42) 218 load_var 8 (_42) @@ -1580,7 +1580,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 227 load_field 1 (expansions) 228 load_var 9 (ts) 229 load_field 0 (name) - 230 call 48 ntypeargs=2 (baml.Map.get) + 230 call 49 ntypeargs=2 (baml.Map.get) 231 store_var 10 (expanded) 118 232 load_var 10 (expanded) @@ -1605,7 +1605,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 248 store_var 12 (_81) 122 249 load_var 11 (sub) - 250 call 840 ntypeargs=0 (testing.TestRegistry.serialize) + 250 call 841 ntypeargs=0 (testing.TestRegistry.serialize) 251 store_var 13 (_82) 120 252 load_var2 2 12 @@ -1625,7 +1625,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.json { 93 0 load_var 1 (self) 1 load_field 0 (collector) - 2 call 852 ntypeargs=0 (testing.TestCollector.to_json) + 2 call 853 ntypeargs=0 (testing.TestCollector.to_json) 3 load_type 0 4 load_type 1 5 load_var 1 (self) @@ -1633,7 +1633,7 @@ function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.j 7 call 20 ntypeargs=2 (baml.Map.to_json) 8 load_var 1 (self) 9 load_field 2 (loading_time_ms) - 10 call 66 ntypeargs=0 (baml.Int.to_json) + 10 call 67 ntypeargs=0 (baml.Int.to_json) 11 load_const 2 ("collector") 12 load_const 3 ("expansions") 13 load_const 4 ("loading_time_ms") @@ -1644,18 +1644,18 @@ function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.j function testing.TestReport.from_json(j: baml.json.json) -> testing.TestReport { 18 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("runs") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.TestReport .outcome, .runs) 15 return } @@ -1679,25 +1679,25 @@ function testing.TestReport.to_json(self: testing.TestReport) -> baml.json.json function testing.TestSetRegistration.from_json(j: baml.json.json) -> testing.TestSetRegistration { 17 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("collector") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("runner") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) 22 return } @@ -1705,47 +1705,47 @@ function testing.TestSetRegistration.from_json(j: baml.json.json) -> testing.Tes function testing.TestSetRegistration.to_json(self: testing.TestSetRegistration) -> baml.json.json { 25 0 load_type 0 1 load_var 1 (self) - 2 call 412 ntypeargs=1 (baml.json.to_string) - 3 call 407 ntypeargs=0 (baml.json.parse) + 2 call 413 ntypeargs=1 (baml.json.to_string) + 3 call 408 ntypeargs=0 (baml.json.parse) 4 return } function testing.TestSetReport.from_json(j: baml.json.json) -> testing.TestSetReport { 25 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("passed") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("failed") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 3 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 load_var 1 (j) 22 load_const 5 ("total") - 23 call 410 ntypeargs=0 (baml.json.field) + 23 call 411 ntypeargs=0 (baml.json.field) 24 store_var 5 (_12) 25 load_type 3 26 load_var 5 (_12) - 27 call 402 ntypeargs=1 (baml.json.from_json) + 27 call 403 ntypeargs=1 (baml.json.from_json) 28 load_var 1 (j) 29 load_const 6 ("results") - 30 call 410 ntypeargs=0 (baml.json.field) + 30 call 411 ntypeargs=0 (baml.json.field) 31 store_var 6 (_15) 32 load_type 7 33 load_var 6 (_15) - 34 call 402 ntypeargs=1 (baml.json.from_json) + 34 call 403 ntypeargs=1 (baml.json.from_json) 35 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .results) 36 return } @@ -1758,13 +1758,13 @@ function testing.TestSetReport.to_json(self: testing.TestSetReport) -> baml.json 4 call_indirect 5 load_var 1 (self) 6 load_field 1 (passed) - 7 call 66 ntypeargs=0 (baml.Int.to_json) + 7 call 67 ntypeargs=0 (baml.Int.to_json) 8 load_var 1 (self) 9 load_field 2 (failed) - 10 call 66 ntypeargs=0 (baml.Int.to_json) + 10 call 67 ntypeargs=0 (baml.Int.to_json) 11 load_var 1 (self) 12 load_field 3 (total) - 13 call 66 ntypeargs=0 (baml.Int.to_json) + 13 call 67 ntypeargs=0 (baml.Int.to_json) 14 load_type 1 15 load_var 1 (self) 16 load_field 4 (results) @@ -1784,7 +1784,7 @@ function testing.run_test(body: () -> void throws unknown, runner: ((() -> testi 2 store_var 1 185 3 load_var 1 (body) - 4 make_closure 1592 1 + 4 make_closure 1593 1 5 store_var 3 (base_run) 200 6 load_var 2 (runner) @@ -1825,18 +1825,18 @@ function testing.run_testset(run_children: () -> testing.TestSetReport throws ne function user.ErrorInfo.from_json(j: baml.json.json) -> ErrorInfo { 26 0 load_var 1 (j) 1 load_const 0 ("code") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("message") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (user.ErrorInfo .code, .message) 15 return } @@ -1844,10 +1844,10 @@ function user.ErrorInfo.from_json(j: baml.json.json) -> ErrorInfo { function user.ErrorInfo.to_json(self: ErrorInfo) -> baml.json.json { 26 0 load_var 1 (self) 1 load_field 0 (code) - 2 call 66 ntypeargs=0 (baml.Int.to_json) + 2 call 67 ntypeargs=0 (baml.Int.to_json) 3 load_var 1 (self) 4 load_field 1 (message) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_const 0 ("code") 7 load_const 1 ("message") 8 alloc_map 2 @@ -1857,25 +1857,25 @@ function user.ErrorInfo.to_json(self: ErrorInfo) -> baml.json.json { function user.Report.from_json(j: baml.json.json) -> Report { 20 0 load_var 1 (j) 1 load_const 0 ("score") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("label") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("breakdown") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (user.Report .score, .label, .breakdown) 22 return } @@ -1883,10 +1883,10 @@ function user.Report.from_json(j: baml.json.json) -> Report { function user.Report.to_json(self: Report) -> baml.json.json { 20 0 load_var 1 (self) 1 load_field 0 (score) - 2 call 66 ntypeargs=0 (baml.Int.to_json) + 2 call 67 ntypeargs=0 (baml.Int.to_json) 3 load_var 1 (self) 4 load_field 1 (label) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_type 0 7 load_type 1 8 load_var 1 (self) @@ -1902,25 +1902,25 @@ function user.Report.to_json(self: Report) -> baml.json.json { function user.User.from_json(j: baml.json.json) -> User { 3 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 2 (_3) 4 load_type 1 5 load_var 2 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("age") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 3 (_6) 11 load_type 3 12 load_var 3 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("role") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 4 (_9) 18 load_type 5 19 load_var 4 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (user.User .name, .age, .role) 22 return } @@ -1954,10 +1954,10 @@ function user.User.promote(self: User, bonus: int) -> Report { function user.User.to_json(self: User) -> baml.json.json { 3 0 load_var 1 (self) 1 load_field 0 (name) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_var 1 (self) 4 load_field 1 (age) - 5 call 66 ntypeargs=0 (baml.Int.to_json) + 5 call 67 ntypeargs=0 (baml.Int.to_json) 6 load_var 1 (self) 7 load_field 2 (role) 8 load_const 0 ("to_json") diff --git a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap index 1f1536aba91..ce5d3e4dbd2 100644 --- a/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap +++ b/baml_language/crates/baml_tests/tests/bytecode_format/snapshots/bytecode_format__bytecode_display_expanded_unoptimized.snap @@ -3,7 +3,7 @@ source: crates/baml_tests/tests/bytecode_format/main.rs --- function assert.contains(haystack: string, needle: string) -> null { 32 0 load_var2 1 2 - 1 call 182 ntypeargs=0 (baml.String.includes) + 1 call 183 ntypeargs=0 (baml.String.includes) 2 unary_op ! 3 pop_jump_if_false +2 (to 5) 4 jump +3 (to 7) @@ -13,7 +13,7 @@ function assert.contains(haystack: string, needle: string) -> null { 32 6 jump +3 (to 9) 33 7 load_const 1 ("assertion failed: string does not contain expected substring") - 8 call 308 ntypeargs=0 (baml.sys.panic) + 8 call 309 ntypeargs=0 (baml.sys.panic) 9 return } @@ -28,7 +28,7 @@ function assert.equal(actual: unknown, expected: unknown) -> null { 23 5 jump +3 (to 8) 24 6 load_const 1 ("assertion failed: expected equal values") - 7 call 308 ntypeargs=0 (baml.sys.panic) + 7 call 309 ntypeargs=0 (baml.sys.panic) 8 return } @@ -43,7 +43,7 @@ function assert.is_true(condition: bool) -> null { 5 5 jump +3 (to 8) 6 6 load_const 1 ("assertion failed: expected true") - 7 call 308 ntypeargs=0 (baml.sys.panic) + 7 call 309 ntypeargs=0 (baml.sys.panic) 8 return } @@ -59,7 +59,7 @@ function assert.not_null(value: unknown | null) -> null { 14 6 jump +3 (to 9) 15 7 load_const 1 ("assertion failed: expected non-null value") - 8 call 308 ntypeargs=0 (baml.sys.panic) + 8 call 309 ntypeargs=0 (baml.sys.panic) 9 return } @@ -72,18 +72,18 @@ function testing.$invoke_collector(collector: (testing.TestCollector) -> void th function testing.RunReport.from_json(j: baml.json.json) -> testing.RunReport { 7 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("duration_ms") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.RunReport .outcome, .duration_ms) 15 store_var 2 (_0) 16 load_var 2 (_0) @@ -98,7 +98,7 @@ function testing.RunReport.to_json(self: testing.RunReport) -> baml.json.json { 4 call_indirect 5 load_var 1 (self) 6 load_field 1 (duration_ms) - 7 call 66 ntypeargs=0 (baml.Int.to_json) + 7 call 67 ntypeargs=0 (baml.Int.to_json) 8 load_const 1 ("outcome") 9 load_const 2 ("duration_ms") 10 alloc_map 2 @@ -110,18 +110,18 @@ function testing.RunReport.to_json(self: testing.RunReport) -> baml.json.json { function testing.SerializedTest.from_json(j: baml.json.json) -> testing.SerializedTest { 78 0 load_var 1 (j) 1 load_const 0 ("type") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("name") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 1 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.SerializedTest .type, .name) 15 store_var 2 (_0) 16 load_var 2 (_0) @@ -131,10 +131,10 @@ function testing.SerializedTest.from_json(j: baml.json.json) -> testing.Serializ function testing.SerializedTest.to_json(self: testing.SerializedTest) -> baml.json.json { 78 0 load_var 1 (self) 1 load_field 0 (type) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_var 1 (self) 4 load_field 1 (name) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_const 0 ("type") 7 load_const 1 ("name") 8 alloc_map 2 @@ -146,25 +146,25 @@ function testing.SerializedTest.to_json(self: testing.SerializedTest) -> baml.js function testing.SerializedTestSet.from_json(j: baml.json.json) -> testing.SerializedTestSet { 83 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("items") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("loadingTimeMs") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.SerializedTestSet .name, .items, .loadingTimeMs) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -174,14 +174,14 @@ function testing.SerializedTestSet.from_json(j: baml.json.json) -> testing.Seria function testing.SerializedTestSet.to_json(self: testing.SerializedTestSet) -> baml.json.json { 83 0 load_var 1 (self) 1 load_field 0 (name) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_type 0 4 load_var 1 (self) 5 load_field 1 (items) 6 call 34 ntypeargs=1 (baml.Array.to_json) 7 load_var 1 (self) 8 load_field 2 (loadingTimeMs) - 9 call 66 ntypeargs=0 (baml.Int.to_json) + 9 call 67 ntypeargs=0 (baml.Int.to_json) 10 load_const 1 ("name") 11 load_const 2 ("items") 12 load_const 3 ("loadingTimeMs") @@ -197,7 +197,7 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 2 store_var 4 (_3) 3 load_type 0 4 load_var 4 (_3) - 5 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 5 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 6 store_var 5 (_4) 7 load_var 5 (_4) 8 is_type 1 @@ -241,16 +241,16 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 46 load_type 0 47 load_type 11 48 load_var 5 (_4) - 49 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 49 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 50 store_var 6 (_6) 51 jump +50 (to 101) 52 load_var 5 (_4) - 53 make_bound_method 662 + 53 make_bound_method 663 54 call_indirect 55 store_var 6 (_6) 56 jump +45 (to 101) 57 load_var 5 (_4) - 58 make_bound_method 675 + 58 make_bound_method 676 59 call_indirect 60 store_var 6 (_6) 61 jump +40 (to 101) @@ -258,39 +258,39 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s 63 load_type 11 64 load_type 11 65 load_var 5 (_4) - 66 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 66 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 67 store_var 6 (_6) 68 jump +33 (to 101) 69 load_var 5 (_4) - 70 make_bound_method 611 + 70 make_bound_method 612 71 call_indirect 72 store_var 6 (_6) 73 jump +28 (to 101) 74 load_type 0 75 load_var 5 (_4) - 76 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 76 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 77 store_var 6 (_6) 78 jump +23 (to 101) 79 load_type 0 80 load_type 11 81 load_type 11 82 load_var 5 (_4) - 83 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 83 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 84 store_var 6 (_6) 85 jump +16 (to 101) 86 load_type 0 87 load_type 11 88 load_var 5 (_4) - 89 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 89 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 90 store_var 6 (_6) 91 jump +10 (to 101) 92 load_type 0 93 load_var 5 (_4) - 94 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 94 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 95 store_var 6 (_6) 96 jump +5 (to 101) 97 load_var 5 (_4) - 98 make_bound_method 646 + 98 make_bound_method 647 99 call_indirect 100 store_var 6 (_6) 101 load_var 6 (_6) @@ -320,25 +320,25 @@ function testing.TestCollector.find_testset(self: testing.TestCollector, name: s function testing.TestCollector.from_json(j: baml.json.json) -> testing.TestCollector { 29 0 load_var 1 (j) 1 load_const 0 ("prefix") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("tests") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("testsets") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestCollector .prefix, .tests, .testsets) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -386,7 +386,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 24 store_var 9 (_13) 25 load_type 4 26 load_var 9 (_13) - 27 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 27 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 28 store_var 10 (_14) 29 load_var 10 (_14) 30 is_type 5 @@ -430,16 +430,16 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 68 load_type 4 69 load_type 15 70 load_var 10 (_14) - 71 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 71 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 72 store_var 11 (_16) 73 jump +50 (to 123) 74 load_var 10 (_14) - 75 make_bound_method 662 + 75 make_bound_method 663 76 call_indirect 77 store_var 11 (_16) 78 jump +45 (to 123) 79 load_var 10 (_14) - 80 make_bound_method 675 + 80 make_bound_method 676 81 call_indirect 82 store_var 11 (_16) 83 jump +40 (to 123) @@ -447,39 +447,39 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 85 load_type 15 86 load_type 15 87 load_var 10 (_14) - 88 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 88 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 89 store_var 11 (_16) 90 jump +33 (to 123) 91 load_var 10 (_14) - 92 make_bound_method 611 + 92 make_bound_method 612 93 call_indirect 94 store_var 11 (_16) 95 jump +28 (to 123) 96 load_type 4 97 load_var 10 (_14) - 98 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 98 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 99 store_var 11 (_16) 100 jump +23 (to 123) 101 load_type 4 102 load_type 15 103 load_type 15 104 load_var 10 (_14) - 105 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 105 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 106 store_var 11 (_16) 107 jump +16 (to 123) 108 load_type 4 109 load_type 15 110 load_var 10 (_14) - 111 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 111 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 112 store_var 11 (_16) 113 jump +10 (to 123) 114 load_type 4 115 load_var 10 (_14) - 116 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 116 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 117 store_var 11 (_16) 118 jump +5 (to 123) 119 load_var 10 (_14) - 120 make_bound_method 646 + 120 make_bound_method 647 121 call_indirect 122 store_var 11 (_16) 123 load_var 11 (_16) @@ -498,7 +498,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 135 load_var 12 (t) 136 load_field 0 (name) 137 load_var 8 (hash_prefix) - 138 call 155 ntypeargs=0 (baml.String.starts_with) + 138 call 156 ntypeargs=0 (baml.String.starts_with) 139 pop_jump_if_false -110 (to 29) 140 load_var 7 (count) 141 load_const 17 (1) @@ -522,7 +522,7 @@ function testing.TestCollector.register_test(self: testing.TestCollector, name: 158 load_var 7 (count) 159 load_const 17 (1) 160 add_int - 161 call 517 ntypeargs=1 (baml.unstable.string) + 161 call 518 ntypeargs=1 (baml.unstable.string) 162 store_var 15 (_57) 163 load_var2 14 15 164 bin_op + @@ -575,7 +575,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 24 store_var 9 (_13) 25 load_type 4 26 load_var 9 (_13) - 27 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 27 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 28 store_var 10 (_14) 29 load_var 10 (_14) 30 is_type 5 @@ -619,16 +619,16 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 68 load_type 4 69 load_type 15 70 load_var 10 (_14) - 71 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 71 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 72 store_var 11 (_16) 73 jump +50 (to 123) 74 load_var 10 (_14) - 75 make_bound_method 662 + 75 make_bound_method 663 76 call_indirect 77 store_var 11 (_16) 78 jump +45 (to 123) 79 load_var 10 (_14) - 80 make_bound_method 675 + 80 make_bound_method 676 81 call_indirect 82 store_var 11 (_16) 83 jump +40 (to 123) @@ -636,39 +636,39 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 85 load_type 15 86 load_type 15 87 load_var 10 (_14) - 88 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 88 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 89 store_var 11 (_16) 90 jump +33 (to 123) 91 load_var 10 (_14) - 92 make_bound_method 611 + 92 make_bound_method 612 93 call_indirect 94 store_var 11 (_16) 95 jump +28 (to 123) 96 load_type 4 97 load_var 10 (_14) - 98 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 98 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 99 store_var 11 (_16) 100 jump +23 (to 123) 101 load_type 4 102 load_type 15 103 load_type 15 104 load_var 10 (_14) - 105 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 105 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 106 store_var 11 (_16) 107 jump +16 (to 123) 108 load_type 4 109 load_type 15 110 load_var 10 (_14) - 111 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 111 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 112 store_var 11 (_16) 113 jump +10 (to 123) 114 load_type 4 115 load_var 10 (_14) - 116 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 116 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 117 store_var 11 (_16) 118 jump +5 (to 123) 119 load_var 10 (_14) - 120 make_bound_method 646 + 120 make_bound_method 647 121 call_indirect 122 store_var 11 (_16) 123 load_var 11 (_16) @@ -687,7 +687,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 135 load_var 12 (ts) 136 load_field 0 (name) 137 load_var 8 (hash_prefix) - 138 call 155 ntypeargs=0 (baml.String.starts_with) + 138 call 156 ntypeargs=0 (baml.String.starts_with) 139 pop_jump_if_false -110 (to 29) 140 load_var 7 (count) 141 load_const 17 (1) @@ -711,7 +711,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na 158 load_var 7 (count) 159 load_const 17 (1) 160 add_int - 161 call 517 ntypeargs=1 (baml.unstable.string) + 161 call 518 ntypeargs=1 (baml.unstable.string) 162 store_var 15 (_57) 163 load_var2 14 15 164 bin_op + @@ -736,7 +736,7 @@ function testing.TestCollector.register_test_set(self: testing.TestCollector, na function testing.TestCollector.to_json(self: testing.TestCollector) -> baml.json.json { 29 0 load_var 1 (self) 1 load_field 0 (prefix) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_type 0 4 load_var 1 (self) 5 load_field 1 (tests) @@ -757,25 +757,25 @@ function testing.TestCollector.to_json(self: testing.TestCollector) -> baml.json function testing.TestRegistration.from_json(j: baml.json.json) -> testing.TestRegistration { 5 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("body") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("runner") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestRegistration .name, .body, .runner) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -785,8 +785,8 @@ function testing.TestRegistration.from_json(j: baml.json.json) -> testing.TestRe function testing.TestRegistration.to_json(self: testing.TestRegistration) -> baml.json.json { 13 0 load_type 0 1 load_var 1 (self) - 2 call 412 ntypeargs=1 (baml.json.to_string) - 3 call 407 ntypeargs=0 (baml.json.parse) + 2 call 413 ntypeargs=1 (baml.json.to_string) + 3 call 408 ntypeargs=0 (baml.json.parse) 4 return } @@ -798,7 +798,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 156 4 load_type 0 5 load_var 3 (_3) - 6 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 6 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 7 store_var 4 (_4) 8 load_var 4 (_4) 9 is_type 1 @@ -842,16 +842,16 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 47 load_type 0 48 load_type 11 49 load_var 4 (_4) - 50 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 50 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 51 store_var 5 (_6) 52 jump +50 (to 102) 53 load_var 4 (_4) - 54 make_bound_method 662 + 54 make_bound_method 663 55 call_indirect 56 store_var 5 (_6) 57 jump +45 (to 102) 58 load_var 4 (_4) - 59 make_bound_method 675 + 59 make_bound_method 676 60 call_indirect 61 store_var 5 (_6) 62 jump +40 (to 102) @@ -859,39 +859,39 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 64 load_type 11 65 load_type 11 66 load_var 4 (_4) - 67 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 67 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 68 store_var 5 (_6) 69 jump +33 (to 102) 70 load_var 4 (_4) - 71 make_bound_method 611 + 71 make_bound_method 612 72 call_indirect 73 store_var 5 (_6) 74 jump +28 (to 102) 75 load_type 0 76 load_var 4 (_4) - 77 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 77 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 78 store_var 5 (_6) 79 jump +23 (to 102) 80 load_type 0 81 load_type 11 82 load_type 11 83 load_var 4 (_4) - 84 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 84 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 85 store_var 5 (_6) 86 jump +16 (to 102) 87 load_type 0 88 load_type 11 89 load_var 4 (_4) - 90 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 90 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 91 store_var 5 (_6) 92 jump +10 (to 102) 93 load_type 0 94 load_var 4 (_4) - 95 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 95 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 96 store_var 5 (_6) 97 jump +5 (to 102) 98 load_var 4 (_4) - 99 make_bound_method 646 + 99 make_bound_method 647 100 call_indirect 101 store_var 5 (_6) 102 load_var 5 (_6) @@ -906,7 +906,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 110 cmp_op == 111 pop_jump_if_false -103 (to 8) - 159 112 call 304 ntypeargs=0 (baml.sys.now_ms) + 159 112 call 305 ntypeargs=0 (baml.sys.now_ms) 113 store_var 7 (start) 160 114 load_var 2 (name) @@ -920,7 +920,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 121 call_indirect 122 pop 1 - 162 123 call 304 ntypeargs=0 (baml.sys.now_ms) + 162 123 call 305 ntypeargs=0 (baml.sys.now_ms) 124 load_var 7 (start) 125 sub_int 126 store_var 9 (elapsed) @@ -942,7 +942,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 138 pop 1 169 139 load_var 1 (self) - 140 call 840 ntypeargs=0 (testing.TestRegistry.serialize) + 140 call 841 ntypeargs=0 (testing.TestRegistry.serialize) 141 jump +123 (to 264) 173 142 load_type 13 @@ -954,7 +954,7 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 172 148 load_type 13 149 load_var 11 (_57) - 150 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 150 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 151 store_var 12 (_61) 152 load_var 12 (_61) 153 is_type 15 @@ -998,16 +998,16 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 191 load_type 13 192 load_type 11 193 load_var 12 (_61) - 194 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 194 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 195 store_var 13 (_63) 196 jump +50 (to 246) 197 load_var 12 (_61) - 198 make_bound_method 662 + 198 make_bound_method 663 199 call_indirect 200 store_var 13 (_63) 201 jump +45 (to 246) 202 load_var 12 (_61) - 203 make_bound_method 675 + 203 make_bound_method 676 204 call_indirect 205 store_var 13 (_63) 206 jump +40 (to 246) @@ -1015,39 +1015,39 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 208 load_type 11 209 load_type 11 210 load_var 12 (_61) - 211 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 211 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 212 store_var 13 (_63) 213 jump +33 (to 246) 214 load_var 12 (_61) - 215 make_bound_method 611 + 215 make_bound_method 612 216 call_indirect 217 store_var 13 (_63) 218 jump +28 (to 246) 219 load_type 13 220 load_var 12 (_61) - 221 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 221 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 222 store_var 13 (_63) 223 jump +23 (to 246) 224 load_type 13 225 load_type 11 226 load_type 11 227 load_var 12 (_61) - 228 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 228 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 229 store_var 13 (_63) 230 jump +16 (to 246) 231 load_type 13 232 load_type 11 233 load_var 12 (_61) - 234 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 234 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 235 store_var 13 (_63) 236 jump +10 (to 246) 237 load_type 13 238 load_var 12 (_61) - 239 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 239 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 240 store_var 13 (_63) 241 jump +5 (to 246) 242 load_var 12 (_61) - 243 make_bound_method 646 + 243 make_bound_method 647 244 call_indirect 245 store_var 13 (_63) 246 load_var 13 (_63) @@ -1066,11 +1066,11 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin 175 257 load_var2 2 14 258 load_const 25 ("/") 259 bin_op + - 260 call 155 ntypeargs=0 (baml.String.starts_with) + 260 call 156 ntypeargs=0 (baml.String.starts_with) 261 pop_jump_if_false -109 (to 152) 176 262 load_var2 15 2 - 263 call 845 ntypeargs=0 (testing.TestRegistry.expand_set) + 263 call 846 ntypeargs=0 (testing.TestRegistry.expand_set) 264 return 179 265 load_const 26 ("TestSet not found for expansion: ") @@ -1083,25 +1083,25 @@ function testing.TestRegistry.expand_set(self: testing.TestRegistry, name: strin function testing.TestRegistry.from_json(j: baml.json.json) -> testing.TestRegistry { 93 0 load_var 1 (j) 1 load_const 0 ("collector") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("expansions") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("loading_time_ms") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestRegistry .collector, .expansions, .loading_time_ms) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -1127,7 +1127,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 136 4 load_type 0 5 load_var 3 (_3) - 6 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 6 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 7 store_var 4 (_4) 8 load_var 4 (_4) 9 is_type 1 @@ -1171,16 +1171,16 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 47 load_type 0 48 load_type 11 49 load_var 4 (_4) - 50 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 50 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 51 store_var 5 (_6) 52 jump +50 (to 102) 53 load_var 4 (_4) - 54 make_bound_method 662 + 54 make_bound_method 663 55 call_indirect 56 store_var 5 (_6) 57 jump +45 (to 102) 58 load_var 4 (_4) - 59 make_bound_method 675 + 59 make_bound_method 676 60 call_indirect 61 store_var 5 (_6) 62 jump +40 (to 102) @@ -1188,39 +1188,39 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 64 load_type 11 65 load_type 11 66 load_var 4 (_4) - 67 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 67 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 68 store_var 5 (_6) 69 jump +33 (to 102) 70 load_var 4 (_4) - 71 make_bound_method 611 + 71 make_bound_method 612 72 call_indirect 73 store_var 5 (_6) 74 jump +28 (to 102) 75 load_type 0 76 load_var 4 (_4) - 77 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 77 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 78 store_var 5 (_6) 79 jump +23 (to 102) 80 load_type 0 81 load_type 11 82 load_type 11 83 load_var 4 (_4) - 84 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 84 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 85 store_var 5 (_6) 86 jump +16 (to 102) 87 load_type 0 88 load_type 11 89 load_var 4 (_4) - 90 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 90 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 91 store_var 5 (_6) 92 jump +10 (to 102) 93 load_type 0 94 load_var 4 (_4) - 95 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 95 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 96 store_var 5 (_6) 97 jump +5 (to 102) 98 load_var 4 (_4) - 99 make_bound_method 646 + 99 make_bound_method 647 100 call_indirect 101 store_var 5 (_6) 102 load_var 5 (_6) @@ -1239,7 +1239,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 113 load_field 1 (body) 114 load_var 6 (t) 115 load_field 2 (runner) - 116 call 851 ntypeargs=0 (testing.run_test) + 116 call 852 ntypeargs=0 (testing.run_test) 117 jump +123 (to 240) 143 118 load_type 13 @@ -1251,7 +1251,7 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 142 124 load_type 13 125 load_var 7 (_40) - 126 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 126 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 127 store_var 8 (_44) 128 load_var 8 (_44) 129 is_type 15 @@ -1295,16 +1295,16 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 167 load_type 13 168 load_type 11 169 load_var 8 (_44) - 170 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 170 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 171 store_var 9 (_46) 172 jump +50 (to 222) 173 load_var 8 (_44) - 174 make_bound_method 662 + 174 make_bound_method 663 175 call_indirect 176 store_var 9 (_46) 177 jump +45 (to 222) 178 load_var 8 (_44) - 179 make_bound_method 675 + 179 make_bound_method 676 180 call_indirect 181 store_var 9 (_46) 182 jump +40 (to 222) @@ -1312,39 +1312,39 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 184 load_type 11 185 load_type 11 186 load_var 8 (_44) - 187 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 187 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 188 store_var 9 (_46) 189 jump +33 (to 222) 190 load_var 8 (_44) - 191 make_bound_method 611 + 191 make_bound_method 612 192 call_indirect 193 store_var 9 (_46) 194 jump +28 (to 222) 195 load_type 13 196 load_var 8 (_44) - 197 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 197 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 198 store_var 9 (_46) 199 jump +23 (to 222) 200 load_type 13 201 load_type 11 202 load_type 11 203 load_var 8 (_44) - 204 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 204 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 205 store_var 9 (_46) 206 jump +16 (to 222) 207 load_type 13 208 load_type 11 209 load_var 8 (_44) - 210 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 210 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 211 store_var 9 (_46) 212 jump +10 (to 222) 213 load_type 13 214 load_var 8 (_44) - 215 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 215 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 216 store_var 9 (_46) 217 jump +5 (to 222) 218 load_var 8 (_44) - 219 make_bound_method 646 + 219 make_bound_method 647 220 call_indirect 221 store_var 9 (_46) 222 load_var 9 (_46) @@ -1363,12 +1363,12 @@ function testing.TestRegistry.run_test(self: testing.TestRegistry, name: string) 146 233 load_var2 2 10 234 load_const 25 ("/") 235 bin_op + - 236 call 155 ntypeargs=0 (baml.String.starts_with) + 236 call 156 ntypeargs=0 (baml.String.starts_with) 145 237 pop_jump_if_false -109 (to 128) 147 238 load_var2 11 2 - 239 call 844 ntypeargs=0 (testing.TestRegistry.run_test) + 239 call 845 ntypeargs=0 (testing.TestRegistry.run_test) 240 return 150 241 load_const 26 ("Test not found: ") @@ -1388,7 +1388,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 5 store_var 4 (_3) 6 load_type 0 7 load_var 4 (_3) - 8 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 8 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 9 store_var 5 (_4) 10 load_var 5 (_4) 11 is_type 1 @@ -1432,16 +1432,16 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 49 load_type 0 50 load_type 11 51 load_var 5 (_4) - 52 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 52 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 53 store_var 6 (_6) 54 jump +50 (to 104) 55 load_var 5 (_4) - 56 make_bound_method 662 + 56 make_bound_method 663 57 call_indirect 58 store_var 6 (_6) 59 jump +45 (to 104) 60 load_var 5 (_4) - 61 make_bound_method 675 + 61 make_bound_method 676 62 call_indirect 63 store_var 6 (_6) 64 jump +40 (to 104) @@ -1449,39 +1449,39 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 66 load_type 11 67 load_type 11 68 load_var 5 (_4) - 69 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 69 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 70 store_var 6 (_6) 71 jump +33 (to 104) 72 load_var 5 (_4) - 73 make_bound_method 611 + 73 make_bound_method 612 74 call_indirect 75 store_var 6 (_6) 76 jump +28 (to 104) 77 load_type 0 78 load_var 5 (_4) - 79 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 79 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 80 store_var 6 (_6) 81 jump +23 (to 104) 82 load_type 0 83 load_type 11 84 load_type 11 85 load_var 5 (_4) - 86 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 86 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 87 store_var 6 (_6) 88 jump +16 (to 104) 89 load_type 0 90 load_type 11 91 load_var 5 (_4) - 92 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 92 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 93 store_var 6 (_6) 94 jump +10 (to 104) 95 load_type 0 96 load_var 5 (_4) - 97 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 97 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 98 store_var 6 (_6) 99 jump +5 (to 104) 100 load_var 5 (_4) - 101 make_bound_method 646 + 101 make_bound_method 647 102 call_indirect 103 store_var 6 (_6) 104 load_var 6 (_6) @@ -1506,7 +1506,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 121 store_var 8 (_39) 122 load_type 14 123 load_var 8 (_39) - 124 call 626 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) + 124 call 627 ntypeargs=1 (baml.iter.Iterable$for$T[].iter) 125 store_var 9 (_40) 126 load_var 9 (_40) 127 is_type 15 @@ -1550,16 +1550,16 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 165 load_type 14 166 load_type 11 167 load_var 9 (_40) - 168 call 631 ntypeargs=2 (baml.iter.Peekable.Iterator.next) + 168 call 632 ntypeargs=2 (baml.iter.Peekable.Iterator.next) 169 store_var 10 (_42) 170 jump +50 (to 220) 171 load_var 9 (_40) - 172 make_bound_method 662 + 172 make_bound_method 663 173 call_indirect 174 store_var 10 (_42) 175 jump +45 (to 220) 176 load_var 9 (_40) - 177 make_bound_method 675 + 177 make_bound_method 676 178 call_indirect 179 store_var 10 (_42) 180 jump +40 (to 220) @@ -1567,39 +1567,39 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 182 load_type 11 183 load_type 11 184 load_var 9 (_40) - 185 call 598 ntypeargs=3 (baml.iter.Filter.Iterator.next) + 185 call 599 ntypeargs=3 (baml.iter.Filter.Iterator.next) 186 store_var 10 (_42) 187 jump +33 (to 220) 188 load_var 9 (_40) - 189 make_bound_method 611 + 189 make_bound_method 612 190 call_indirect 191 store_var 10 (_42) 192 jump +28 (to 220) 193 load_type 14 194 load_var 9 (_40) - 195 call 625 ntypeargs=1 (baml.iter.Repeat.Iterator.next) + 195 call 626 ntypeargs=1 (baml.iter.Repeat.Iterator.next) 196 store_var 10 (_42) 197 jump +23 (to 220) 198 load_type 14 199 load_type 11 200 load_type 11 201 load_var 9 (_40) - 202 call 601 ntypeargs=3 (baml.iter.Chain.Iterator.next) + 202 call 602 ntypeargs=3 (baml.iter.Chain.Iterator.next) 203 store_var 10 (_42) 204 jump +16 (to 220) 205 load_type 14 206 load_type 11 207 load_var 9 (_40) - 208 call 615 ntypeargs=2 (baml.iter.StepBy.Iterator.next) + 208 call 616 ntypeargs=2 (baml.iter.StepBy.Iterator.next) 209 store_var 10 (_42) 210 jump +10 (to 220) 211 load_type 14 212 load_var 9 (_40) - 213 call 657 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) + 213 call 658 ntypeargs=1 (baml.iter.ArrayIterator.Iterator.next) 214 store_var 10 (_42) 215 jump +5 (to 220) 216 load_var 9 (_40) - 217 make_bound_method 646 + 217 make_bound_method 647 218 call_indirect 219 store_var 10 (_42) 220 load_var 10 (_42) @@ -1615,7 +1615,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 229 load_field 1 (expansions) 230 load_var 11 (ts) 231 load_field 0 (name) - 232 call 48 ntypeargs=2 (baml.Map.get) + 232 call 49 ntypeargs=2 (baml.Map.get) 233 store_var 12 (expanded) 118 234 load_var 12 (expanded) @@ -1640,7 +1640,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. 250 store_var 14 (_81) 122 251 load_var 13 (sub) - 252 call 840 ntypeargs=0 (testing.TestRegistry.serialize) + 252 call 841 ntypeargs=0 (testing.TestRegistry.serialize) 253 store_var 15 (_82) 120 254 load_var2 3 14 @@ -1662,7 +1662,7 @@ function testing.TestRegistry.serialize(self: testing.TestRegistry) -> (testing. function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.json { 93 0 load_var 1 (self) 1 load_field 0 (collector) - 2 call 852 ntypeargs=0 (testing.TestCollector.to_json) + 2 call 853 ntypeargs=0 (testing.TestCollector.to_json) 3 load_type 0 4 load_type 1 5 load_var 1 (self) @@ -1670,7 +1670,7 @@ function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.j 7 call 20 ntypeargs=2 (baml.Map.to_json) 8 load_var 1 (self) 9 load_field 2 (loading_time_ms) - 10 call 66 ntypeargs=0 (baml.Int.to_json) + 10 call 67 ntypeargs=0 (baml.Int.to_json) 11 load_const 2 ("collector") 12 load_const 3 ("expansions") 13 load_const 4 ("loading_time_ms") @@ -1683,18 +1683,18 @@ function testing.TestRegistry.to_json(self: testing.TestRegistry) -> baml.json.j function testing.TestReport.from_json(j: baml.json.json) -> testing.TestReport { 18 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("runs") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (testing.TestReport .outcome, .runs) 15 store_var 2 (_0) 16 load_var 2 (_0) @@ -1722,25 +1722,25 @@ function testing.TestReport.to_json(self: testing.TestReport) -> baml.json.json function testing.TestSetRegistration.from_json(j: baml.json.json) -> testing.TestSetRegistration { 17 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("collector") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("runner") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (testing.TestSetRegistration .name, .collector, .runner) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -1750,47 +1750,47 @@ function testing.TestSetRegistration.from_json(j: baml.json.json) -> testing.Tes function testing.TestSetRegistration.to_json(self: testing.TestSetRegistration) -> baml.json.json { 25 0 load_type 0 1 load_var 1 (self) - 2 call 412 ntypeargs=1 (baml.json.to_string) - 3 call 407 ntypeargs=0 (baml.json.parse) + 2 call 413 ntypeargs=1 (baml.json.to_string) + 3 call 408 ntypeargs=0 (baml.json.parse) 4 return } function testing.TestSetReport.from_json(j: baml.json.json) -> testing.TestSetReport { 25 0 load_var 1 (j) 1 load_const 0 ("outcome") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("passed") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("failed") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 3 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 load_var 1 (j) 22 load_const 5 ("total") - 23 call 410 ntypeargs=0 (baml.json.field) + 23 call 411 ntypeargs=0 (baml.json.field) 24 store_var 6 (_12) 25 load_type 3 26 load_var 6 (_12) - 27 call 402 ntypeargs=1 (baml.json.from_json) + 27 call 403 ntypeargs=1 (baml.json.from_json) 28 load_var 1 (j) 29 load_const 6 ("results") - 30 call 410 ntypeargs=0 (baml.json.field) + 30 call 411 ntypeargs=0 (baml.json.field) 31 store_var 7 (_15) 32 load_type 7 33 load_var 7 (_15) - 34 call 402 ntypeargs=1 (baml.json.from_json) + 34 call 403 ntypeargs=1 (baml.json.from_json) 35 init_instance 0 (testing.TestSetReport .outcome, .passed, .failed, .total, .results) 36 store_var 2 (_0) 37 load_var 2 (_0) @@ -1805,13 +1805,13 @@ function testing.TestSetReport.to_json(self: testing.TestSetReport) -> baml.json 4 call_indirect 5 load_var 1 (self) 6 load_field 1 (passed) - 7 call 66 ntypeargs=0 (baml.Int.to_json) + 7 call 67 ntypeargs=0 (baml.Int.to_json) 8 load_var 1 (self) 9 load_field 2 (failed) - 10 call 66 ntypeargs=0 (baml.Int.to_json) + 10 call 67 ntypeargs=0 (baml.Int.to_json) 11 load_var 1 (self) 12 load_field 3 (total) - 13 call 66 ntypeargs=0 (baml.Int.to_json) + 13 call 67 ntypeargs=0 (baml.Int.to_json) 14 load_type 1 15 load_var 1 (self) 16 load_field 4 (results) @@ -1833,7 +1833,7 @@ function testing.run_test(body: () -> void throws unknown, runner: ((() -> testi 2 store_var 1 185 3 load_var 1 (body) - 4 make_closure 1592 1 + 4 make_closure 1593 1 5 store_var 3 (base_run) 200 6 load_var 2 (runner) @@ -1878,18 +1878,18 @@ function testing.run_testset(run_children: () -> testing.TestSetReport throws ne function user.ErrorInfo.from_json(j: baml.json.json) -> ErrorInfo { 26 0 load_var 1 (j) 1 load_const 0 ("code") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("message") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 init_instance 0 (user.ErrorInfo .code, .message) 15 store_var 2 (_0) 16 load_var 2 (_0) @@ -1899,10 +1899,10 @@ function user.ErrorInfo.from_json(j: baml.json.json) -> ErrorInfo { function user.ErrorInfo.to_json(self: ErrorInfo) -> baml.json.json { 26 0 load_var 1 (self) 1 load_field 0 (code) - 2 call 66 ntypeargs=0 (baml.Int.to_json) + 2 call 67 ntypeargs=0 (baml.Int.to_json) 3 load_var 1 (self) 4 load_field 1 (message) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_const 0 ("code") 7 load_const 1 ("message") 8 alloc_map 2 @@ -1914,25 +1914,25 @@ function user.ErrorInfo.to_json(self: ErrorInfo) -> baml.json.json { function user.Report.from_json(j: baml.json.json) -> Report { 20 0 load_var 1 (j) 1 load_const 0 ("score") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("label") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("breakdown") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (user.Report .score, .label, .breakdown) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -1942,10 +1942,10 @@ function user.Report.from_json(j: baml.json.json) -> Report { function user.Report.to_json(self: Report) -> baml.json.json { 20 0 load_var 1 (self) 1 load_field 0 (score) - 2 call 66 ntypeargs=0 (baml.Int.to_json) + 2 call 67 ntypeargs=0 (baml.Int.to_json) 3 load_var 1 (self) 4 load_field 1 (label) - 5 call 167 ntypeargs=0 (baml.String.to_json) + 5 call 168 ntypeargs=0 (baml.String.to_json) 6 load_type 0 7 load_type 1 8 load_var 1 (self) @@ -1963,25 +1963,25 @@ function user.Report.to_json(self: Report) -> baml.json.json { function user.User.from_json(j: baml.json.json) -> User { 3 0 load_var 1 (j) 1 load_const 0 ("name") - 2 call 410 ntypeargs=0 (baml.json.field) + 2 call 411 ntypeargs=0 (baml.json.field) 3 store_var 3 (_3) 4 load_type 1 5 load_var 3 (_3) - 6 call 402 ntypeargs=1 (baml.json.from_json) + 6 call 403 ntypeargs=1 (baml.json.from_json) 7 load_var 1 (j) 8 load_const 2 ("age") - 9 call 410 ntypeargs=0 (baml.json.field) + 9 call 411 ntypeargs=0 (baml.json.field) 10 store_var 4 (_6) 11 load_type 3 12 load_var 4 (_6) - 13 call 402 ntypeargs=1 (baml.json.from_json) + 13 call 403 ntypeargs=1 (baml.json.from_json) 14 load_var 1 (j) 15 load_const 4 ("role") - 16 call 410 ntypeargs=0 (baml.json.field) + 16 call 411 ntypeargs=0 (baml.json.field) 17 store_var 5 (_9) 18 load_type 5 19 load_var 5 (_9) - 20 call 402 ntypeargs=1 (baml.json.from_json) + 20 call 403 ntypeargs=1 (baml.json.from_json) 21 init_instance 0 (user.User .name, .age, .role) 22 store_var 2 (_0) 23 load_var 2 (_0) @@ -2020,10 +2020,10 @@ function user.User.promote(self: User, bonus: int) -> Report { function user.User.to_json(self: User) -> baml.json.json { 3 0 load_var 1 (self) 1 load_field 0 (name) - 2 call 167 ntypeargs=0 (baml.String.to_json) + 2 call 168 ntypeargs=0 (baml.String.to_json) 3 load_var 1 (self) 4 load_field 1 (age) - 5 call 66 ntypeargs=0 (baml.Int.to_json) + 5 call 67 ntypeargs=0 (baml.Int.to_json) 6 load_var 1 (self) 7 load_field 2 (role) 8 load_const 0 ("to_json")