diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index 852abe75..1c6150ec 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -166,10 +166,55 @@ def to_a(*args) # to_set: a new Set of the elements (each preprocessed by the block, if given), # as MRI's Enumerable#to_set. Defined here so every Enumerable — Array, Range, # Hash, … — can be turned into a Set. - def to_set(klass = Set, *args, &block) + # + # ⛔ *args RATHER THAN `klass = Set`, and the reason is the deprecation below: + # with a default parameter, `to_set` and `to_set(Set)` are INDISTINGUISHABLE + # inside the method — klass == Set and args empty in both. MRI warns for the + # second and not the first, so the test is ARITY, not the value. + # + # Measured against MRI 4.0.7 through cmd/oracle (#909), and three of these are + # not what "with arguments warns" would lead one to write: + # + # [1,2].to_set silent + # [1,2].to_set(Set) warns <- even though Set IS the default + # [1,2].to_set(MySet) warns + # [1,2].to_set { … } SILENT <- a block alone is not "arguments" + # (1..3).to_set silent <- see Range#to_set on forwarding + # Set[1,2].to_set(Set) SILENT <- Set#to_set does not warn at all + # + # The message is reproduced character for character, with uplevel: 1 so the + # file:line prefix names the CALLER, as MRI's does. + # + # ⛔ And it is a plain `warn`, NOT the :deprecated category: measured, MRI + # still emits it under `Warning[:deprecated] = false`. Routing it through the + # category would silence a warning MRI does not silence. + # ⛔ The warning goes through this helper so the MESSAGE lives in ONE place and + # so `uplevel` is computed from a known depth. uplevel: 2 skips the helper and + # its caller, landing on the user's line — for Enumerable#to_set AND for any + # override that calls it, which is what Range#to_set needs. + # + # Measured: with the warning written inline in to_set at uplevel: 1, + # `(1..3).to_set(Set)` reported `prelude.rb:1174` — the line of Range#to_set's + # `super` — where MRI reports the caller's line. In MRI both to_set are C, so + # there is no intervening Ruby frame to land on; here there is, and an + # interpreter's own prelude has no business appearing in a user's warning. + private def __warn_to_set_args(args) + return if args.empty? + warn("passing arguments to Enumerable#to_set is deprecated", uplevel: 2) + end + + # __to_set_core is to_set without the warning, so an override that has already + # warned (Range#to_set) does not warn a second time through `super`. + private def __to_set_core(args, block) + klass = args.empty? ? Set : args.shift klass.new(self, *args, &block) end + def to_set(*args, &block) + __warn_to_set_args(args) + __to_set_core(args, block) + end + # to_h: each element (or each yield of the block) must be a [key, value] pair. # A non-Array pair is coerced with #to_ary (MRI's rb_check_array_type). Any # arguments are forwarded to #each. @@ -1140,9 +1185,28 @@ class Range # core/range/to_set_spec.rb:22. Unconditional rather than version-gated: no # spec asserts the old behaviour — nothing can assert a hang — so the only # thing a version gate would preserve is the way to wedge the interpreter. - def to_set(klass = Set, *args, &block) + # ⛔ TWO changes here, both forced by the deprecation warning in + # Enumerable#to_set (#909), and neither changes what this method returns. + # + # 1. *args, not `klass = Set`: the C above forwards argc/argv VERBATIM, and a + # default parameter does not. With `klass = Set` a bare `range.to_set` + # reached Enumerable#to_set carrying an explicit Set — harmless while that + # method ignored the difference, and a false warning the moment it stopped. + # MRI is silent for `(1..3).to_set`, measured. + # + # 2. It warns here and calls __to_set_core instead of `super`. `super` would + # warn from Enumerable's frame, whose uplevel lands on THIS method's line: + # measured, `(1..3).to_set(Set)` reported `prelude.rb:1174` where MRI + # reports the caller. Warning here puts the user's line in the message and + # the core call keeps it to one warning. + # + # ⚠ So the call shape no longer mirrors `rb_call_super` above, while the + # RESULT still does. The C can forward blindly because both to_set are C and + # add no Ruby frame; a prelude written in Ruby cannot. + def to_set(*args, &block) raise RangeError, "cannot convert endless range to a set" if self.end.nil? - super + __warn_to_set_args(args) + __to_set_core(args, block) end # Range#== is true when other is a Range (or subclass) with == begin, == end diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index 4ce71247..4f2bebca 100644 --- a/internal/vm/prelude_frozen_gen.go +++ b/internal/vm/prelude_frozen_gen.go @@ -19,7 +19,7 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 998}, {PC: 6, Line: 1013}, {PC: 8, Line: 1024}, {PC: 10, Line: 1037}, {PC: 12, Line: 1041}, {PC: 14, Line: 1050}, {PC: 16, Line: 1107}, {PC: 18, Line: 1178}, {PC: 20, Line: 1193}, {PC: 22, Line: 1599}, {PC: 24, Line: 1819}, {PC: 26, Line: 1898}, {PC: 28, Line: 1929}, {PC: 30, Line: 1949}, {PC: 32, Line: 1989}, {PC: 34, Line: 2002}, {PC: 36, Line: 2042}, {PC: 38, Line: 2223}, {PC: 40, Line: 2265}, {PC: 42, Line: 2266}, {PC: 46, Line: 2331}, {PC: 48, Line: 2332}, {PC: 52, Line: 2441}, {PC: 54, Line: 2442}, {PC: 58, Line: 2543}, {PC: 60, Line: 2544}, {PC: 64, Line: 2601}, {PC: 66, Line: 2726}, {PC: 68, Line: 2784}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 1043}, {PC: 6, Line: 1058}, {PC: 8, Line: 1069}, {PC: 10, Line: 1082}, {PC: 12, Line: 1086}, {PC: 14, Line: 1095}, {PC: 16, Line: 1152}, {PC: 18, Line: 1242}, {PC: 20, Line: 1257}, {PC: 22, Line: 1663}, {PC: 24, Line: 1883}, {PC: 26, Line: 1962}, {PC: 28, Line: 1993}, {PC: 30, Line: 2013}, {PC: 32, Line: 2053}, {PC: 34, Line: 2066}, {PC: 36, Line: 2106}, {PC: 38, Line: 2287}, {PC: 40, Line: 2329}, {PC: 42, Line: 2330}, {PC: 46, Line: 2395}, {PC: 48, Line: 2396}, {PC: 52, Line: 2505}, {PC: 54, Line: 2506}, {PC: 58, Line: 2607}, {PC: 60, Line: 2608}, {PC: 64, Line: 2665}, {PC: 66, Line: 2790}, {PC: 68, Line: 2848}}, FirstLine: 1, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -55,7 +55,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"other", "cmp", "", "right"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 259}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 46, Line: 109}, {PC: 50, Line: 25}, {PC: 58, Line: 27}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 304}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 46, Line: 109}, {PC: 50, Line: 25}, {PC: 58, Line: 27}}, FirstLine: 16, Super: "", }, @@ -204,20 +204,20 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3, Flags: 2}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 4}, {Op: 9}, {Op: 44, A: 7, B: 5}, {Op: 9}, {Op: 44, A: 8, B: 6}, {Op: 9}, {Op: 78, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 7}, {Op: 9}, {Op: 44, A: 11, B: 8}, {Op: 9}, {Op: 44, A: 12, B: 9}, {Op: 9}, {Op: 44, A: 13, B: 10}, {Op: 9}, {Op: 44, A: 14, B: 11}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 9}, {Op: 78, A: 16, B: 15}, {Op: 9}, {Op: 44, A: 17, B: 13}, {Op: 9}, {Op: 44, A: 18, B: 14}, {Op: 9}, {Op: 78, A: 19, B: 18}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 78, A: 27, B: 26}, {Op: 9}, {Op: 44, A: 28, B: 21}, {Op: 9}, {Op: 44, A: 29, B: 22}, {Op: 9}, {Op: 44, A: 30, B: 23}, {Op: 9}, {Op: 44, A: 31, B: 24}, {Op: 9}, {Op: 44, A: 32, B: 25}, {Op: 9}, {Op: 44, A: 33, B: 26}, {Op: 9}, {Op: 44, A: 34, B: 27}, {Op: 9}, {Op: 44, A: 35, B: 28}, {Op: 9}, {Op: 44, A: 36, B: 29}, {Op: 9}, {Op: 78, A: 37, B: 36}, {Op: 9}, {Op: 44, A: 38, B: 30}, {Op: 9}, {Op: 44, A: 39, B: 31}, {Op: 9}, {Op: 44, A: 40, B: 32}, {Op: 9}, {Op: 44, A: 41, B: 33}, {Op: 9}, {Op: 44, A: 42, B: 34}, {Op: 9}, {Op: 44, A: 43, B: 35}, {Op: 9}, {Op: 44, A: 44, B: 36}, {Op: 9}, {Op: 44, A: 45, B: 37}, {Op: 9}, {Op: 78, A: 46, B: 15}, {Op: 9}, {Op: 44, A: 47, B: 38}, {Op: 9}, {Op: 44, A: 48, B: 39}, {Op: 9}, {Op: 44, A: 49, B: 40}, {Op: 9}, {Op: 44, A: 50, B: 41}, {Op: 9}, {Op: 44, A: 51, B: 42}, {Op: 9}, {Op: 44, A: 52, B: 43}, {Op: 9}, {Op: 44, A: 53, B: 44}, {Op: 9}, {Op: 44, A: 54, B: 45}, {Op: 9}, {Op: 44, A: 55, B: 46}, {Op: 9}, {Op: 44, A: 56, B: 47}, {Op: 9}, {Op: 44, A: 57, B: 48}, {Op: 9}, {Op: 44, A: 58, B: 49}, {Op: 9}, {Op: 44, A: 59, B: 50}, {Op: 9}, {Op: 44, A: 60, B: 51}, {Op: 9}, {Op: 44, A: 61, B: 52}, {Op: 9}, {Op: 44, A: 62, B: 53}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3, Flags: 2}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 5}, {Op: 44, A: 6, B: 4}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 44, A: 7, B: 5}, {Op: 30, A: 3, B: 1, Flags: 2}, {Op: 9}, {Op: 44, A: 8, B: 6}, {Op: 9}, {Op: 44, A: 9, B: 7}, {Op: 9}, {Op: 44, A: 10, B: 8}, {Op: 9}, {Op: 78, A: 11, B: 10}, {Op: 9}, {Op: 44, A: 12, B: 9}, {Op: 9}, {Op: 44, A: 13, B: 10}, {Op: 9}, {Op: 44, A: 14, B: 11}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 9}, {Op: 44, A: 16, B: 13}, {Op: 9}, {Op: 44, A: 17, B: 14}, {Op: 9}, {Op: 78, A: 18, B: 17}, {Op: 9}, {Op: 44, A: 19, B: 15}, {Op: 9}, {Op: 44, A: 20, B: 16}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 17}, {Op: 9}, {Op: 78, A: 23, B: 22}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 44, A: 27, B: 21}, {Op: 9}, {Op: 44, A: 28, B: 22}, {Op: 9}, {Op: 78, A: 29, B: 28}, {Op: 9}, {Op: 44, A: 30, B: 23}, {Op: 9}, {Op: 44, A: 31, B: 24}, {Op: 9}, {Op: 44, A: 32, B: 25}, {Op: 9}, {Op: 44, A: 33, B: 26}, {Op: 9}, {Op: 44, A: 34, B: 27}, {Op: 9}, {Op: 44, A: 35, B: 28}, {Op: 9}, {Op: 44, A: 36, B: 29}, {Op: 9}, {Op: 44, A: 37, B: 30}, {Op: 9}, {Op: 44, A: 38, B: 31}, {Op: 9}, {Op: 78, A: 39, B: 38}, {Op: 9}, {Op: 44, A: 40, B: 32}, {Op: 9}, {Op: 44, A: 41, B: 33}, {Op: 9}, {Op: 44, A: 42, B: 34}, {Op: 9}, {Op: 44, A: 43, B: 35}, {Op: 9}, {Op: 44, A: 44, B: 36}, {Op: 9}, {Op: 44, A: 45, B: 37}, {Op: 9}, {Op: 44, A: 46, B: 38}, {Op: 9}, {Op: 44, A: 47, B: 39}, {Op: 9}, {Op: 78, A: 48, B: 17}, {Op: 9}, {Op: 44, A: 49, B: 40}, {Op: 9}, {Op: 44, A: 50, B: 41}, {Op: 9}, {Op: 44, A: 51, B: 42}, {Op: 9}, {Op: 44, A: 52, B: 43}, {Op: 9}, {Op: 44, A: 53, B: 44}, {Op: 9}, {Op: 44, A: 54, B: 45}, {Op: 9}, {Op: 44, A: 55, B: 46}, {Op: 9}, {Op: 44, A: 56, B: 47}, {Op: 9}, {Op: 44, A: 57, B: 48}, {Op: 9}, {Op: 44, A: 58, B: 49}, {Op: 9}, {Op: 44, A: 59, B: 50}, {Op: 9}, {Op: 44, A: 60, B: 51}, {Op: 9}, {Op: 44, A: 61, B: 52}, {Op: 9}, {Op: 44, A: 62, B: 53}, {Op: 9}, {Op: 44, A: 63, B: 54}, {Op: 9}, {Op: 44, A: 64, B: 55}, {Op: 53}}, Consts: []object.Value{ object.Symbol("__each_packed"), object.Symbol("__pack"), object.Symbol("__enum_int_arg"), }, - Names: []string{"__each_packed", "__pack", "__enum_int_arg", "private", "to_a", "entries", "to_set", "to_h", "map", "collect", "count", "min_by", "max_by", "sort", "sort_by", "select", "filter", "reject", "find", "detect", "include?", "member?", "sum", "min", "max", "minmax", "reduce", "inject", "any?", "all?", "none?", "one?", "uniq", "compact", "each_with_index", "reverse_each", "flat_map", "collect_concat", "each_entry", "each_with_object", "filter_map", "partition", "group_by", "tally", "zip", "find_index", "find_all", "grep", "grep_v", "take_while", "drop_while", "each_slice", "each_cons", "first", "take", "drop", "chunk_while", "slice_when", "chunk", "slice_before", "slice_after", "minmax_by", "cycle"}, + Names: []string{"__each_packed", "__pack", "__enum_int_arg", "private", "to_a", "entries", "__warn_to_set_args", "__to_set_core", "to_set", "to_h", "map", "collect", "count", "min_by", "max_by", "sort", "sort_by", "select", "filter", "reject", "find", "detect", "include?", "member?", "sum", "min", "max", "minmax", "reduce", "inject", "any?", "all?", "none?", "one?", "uniq", "compact", "each_with_index", "reverse_each", "flat_map", "collect_concat", "each_entry", "each_with_object", "filter_map", "partition", "group_by", "tally", "zip", "find_index", "find_all", "grep", "grep_v", "take_while", "drop_while", "each_slice", "each_cons", "first", "take", "drop", "chunk_while", "slice_when", "chunk", "slice_before", "slice_after", "minmax_by", "cycle"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 169}, {PC: 18, Line: 176}, {PC: 20, Line: 188}, {PC: 22, Line: 198}, {PC: 24, Line: 200}, {PC: 26, Line: 221}, {PC: 28, Line: 226}, {PC: 30, Line: 231}, {PC: 32, Line: 235}, {PC: 34, Line: 240}, {PC: 36, Line: 246}, {PC: 38, Line: 248}, {PC: 40, Line: 258}, {PC: 42, Line: 273}, {PC: 44, Line: 275}, {PC: 46, Line: 280}, {PC: 48, Line: 285}, {PC: 50, Line: 310}, {PC: 52, Line: 327}, {PC: 54, Line: 344}, {PC: 56, Line: 348}, {PC: 58, Line: 398}, {PC: 60, Line: 404}, {PC: 62, Line: 418}, {PC: 64, Line: 432}, {PC: 66, Line: 450}, {PC: 68, Line: 471}, {PC: 70, Line: 498}, {PC: 72, Line: 504}, {PC: 74, Line: 518}, {PC: 76, Line: 524}, {PC: 78, Line: 540}, {PC: 80, Line: 547}, {PC: 82, Line: 553}, {PC: 84, Line: 559}, {PC: 86, Line: 569}, {PC: 88, Line: 583}, {PC: 90, Line: 597}, {PC: 92, Line: 633}, {PC: 94, Line: 662}, {PC: 96, Line: 676}, {PC: 98, Line: 680}, {PC: 100, Line: 686}, {PC: 102, Line: 692}, {PC: 104, Line: 707}, {PC: 106, Line: 724}, {PC: 108, Line: 744}, {PC: 110, Line: 768}, {PC: 112, Line: 790}, {PC: 114, Line: 804}, {PC: 116, Line: 821}, {PC: 118, Line: 841}, {PC: 120, Line: 867}, {PC: 122, Line: 900}, {PC: 124, Line: 923}, {PC: 126, Line: 946}, {PC: 128, Line: 953}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 201}, {PC: 20, Line: 208}, {PC: 24, Line: 213}, {PC: 26, Line: 221}, {PC: 28, Line: 233}, {PC: 30, Line: 243}, {PC: 32, Line: 245}, {PC: 34, Line: 266}, {PC: 36, Line: 271}, {PC: 38, Line: 276}, {PC: 40, Line: 280}, {PC: 42, Line: 285}, {PC: 44, Line: 291}, {PC: 46, Line: 293}, {PC: 48, Line: 303}, {PC: 50, Line: 318}, {PC: 52, Line: 320}, {PC: 54, Line: 325}, {PC: 56, Line: 330}, {PC: 58, Line: 355}, {PC: 60, Line: 372}, {PC: 62, Line: 389}, {PC: 64, Line: 393}, {PC: 66, Line: 443}, {PC: 68, Line: 449}, {PC: 70, Line: 463}, {PC: 72, Line: 477}, {PC: 74, Line: 495}, {PC: 76, Line: 516}, {PC: 78, Line: 543}, {PC: 80, Line: 549}, {PC: 82, Line: 563}, {PC: 84, Line: 569}, {PC: 86, Line: 585}, {PC: 88, Line: 592}, {PC: 90, Line: 598}, {PC: 92, Line: 604}, {PC: 94, Line: 614}, {PC: 96, Line: 628}, {PC: 98, Line: 642}, {PC: 100, Line: 678}, {PC: 102, Line: 707}, {PC: 104, Line: 721}, {PC: 106, Line: 725}, {PC: 108, Line: 731}, {PC: 110, Line: 737}, {PC: 112, Line: 752}, {PC: 114, Line: 769}, {PC: 116, Line: 789}, {PC: 118, Line: 813}, {PC: 120, Line: 835}, {PC: 122, Line: 849}, {PC: 124, Line: 866}, {PC: 126, Line: 886}, {PC: 128, Line: 912}, {PC: 130, Line: 945}, {PC: 132, Line: 968}, {PC: 134, Line: 991}, {PC: 136, Line: 998}}, FirstLine: 116, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -268,7 +268,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 259}, {PC: 5, Line: 132}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 304}, {PC: 5, Line: 132}}, FirstLine: 131, Super: "", }, @@ -334,20 +334,57 @@ func embeddedPrelude() *bytecode.ISeq { }, Super: "", }, + &bytecode.ISeq{ + Name: "__warn_to_set_args", + Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 6}, {Op: 2}, {Op: 53}, {Op: 26, A: 7}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, A: 1, B: 2}, {Op: 53}}, + Consts: []object.Value{ + object.FString("passing arguments to Enumerable#to_set is deprecated", ""), + object.Symbol("uplevel"), + object.IntValue(2), + }, + Names: []string{"empty?", "warn"}, + Params: []string{"args"}, + NumRequired: 1, + SplatIndex: -1, + PostCount: 0, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 1, + Locals: []string{"args"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 202}, {PC: 8, Line: 203}}, + FirstLine: 201, + Super: "", + }, + &bytecode.ISeq{ + Name: "__to_set_core", + Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 28, A: 5}, {Op: 33, A: 1}, {Op: 26, A: 7}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67, A: 3, Flags: 3}, {Op: 53}}, + Names: []string{"empty?", "Set", "shift", "new"}, + Params: []string{"args", "block"}, + NumRequired: 2, + SplatIndex: -1, + PostCount: 0, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 3, + Locals: []string{"args", "block", "klass"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 209}, {PC: 9, Line: 210}, {PC: 11, Line: 109}}, + FirstLine: 208, + Super: "", + }, &bytecode.ISeq{ Name: "to_set", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 1, Flags: 3}, {Op: 53}}, - Names: []string{"Set", "new"}, - Params: []string{"klass", "args"}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 2}, {Op: 53}}, + Names: []string{"__warn_to_set_args", "__to_set_core"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: 1, + SplatIndex: 0, PostCount: 0, KwRestSlot: -1, - BlockSlot: 2, - NumLocals: 3, - Locals: []string{"klass", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 169}, {PC: 5, Line: 170}, {PC: 7, Line: 109}}, - FirstLine: 169, + BlockSlot: 1, + NumLocals: 2, + Locals: []string{"args", "block"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 214}, {PC: 4, Line: 215}}, + FirstLine: 213, Super: "", }, &bytecode.ISeq{ @@ -362,8 +399,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 177}, {PC: 3, Line: 178}, {PC: 10, Line: 185}}, - FirstLine: 176, + Lines: []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 3, Line: 223}, {PC: 10, Line: 230}}, + FirstLine: 221, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_h", @@ -386,8 +423,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"a", "pair", "ary", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 179}, {PC: 13, Line: 180}, {PC: 18, Line: 181}, {PC: 33, Line: 182}, {PC: 51, Line: 183}}, - FirstLine: 178, + Lines: []bytecode.LineEntry{{PC: 0, Line: 224}, {PC: 13, Line: 225}, {PC: 18, Line: 226}, {PC: 33, Line: 227}, {PC: 51, Line: 228}}, + FirstLine: 223, Super: "", }, }, @@ -407,8 +444,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 189}, {PC: 10, Line: 190}, {PC: 13, Line: 191}, {PC: 16, Line: 192}}, - FirstLine: 188, + Lines: []bytecode.LineEntry{{PC: 0, Line: 234}, {PC: 10, Line: 235}, {PC: 13, Line: 236}, {PC: 16, Line: 237}}, + FirstLine: 233, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in map", @@ -423,8 +460,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 189}}, - FirstLine: 189, + Lines: []bytecode.LineEntry{{PC: 0, Line: 234}}, + FirstLine: 234, Super: "", }, &bytecode.ISeq{ @@ -439,8 +476,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 191}}, - FirstLine: 191, + Lines: []bytecode.LineEntry{{PC: 0, Line: 236}}, + FirstLine: 236, Super: "", }, }, @@ -466,8 +503,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "n", "item"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 201}, {PC: 17, Line: 202}, {PC: 20, Line: 203}, {PC: 24, Line: 208}, {PC: 35, Line: 209}, {PC: 40, Line: 210}, {PC: 45, Line: 212}, {PC: 48, Line: 214}, {PC: 51, Line: 216}}, - FirstLine: 200, + Lines: []bytecode.LineEntry{{PC: 0, Line: 246}, {PC: 17, Line: 247}, {PC: 20, Line: 248}, {PC: 24, Line: 253}, {PC: 35, Line: 254}, {PC: 40, Line: 255}, {PC: 45, Line: 257}, {PC: 48, Line: 259}, {PC: 51, Line: 261}}, + FirstLine: 245, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in count", @@ -484,8 +521,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 210}}, - FirstLine: 210, + Lines: []bytecode.LineEntry{{PC: 0, Line: 255}}, + FirstLine: 255, Super: "", }, &bytecode.ISeq{ @@ -502,8 +539,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 212}}, - FirstLine: 212, + Lines: []bytecode.LineEntry{{PC: 0, Line: 257}}, + FirstLine: 257, Super: "", }, &bytecode.ISeq{ @@ -520,8 +557,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 214}}, - FirstLine: 214, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 259, Super: "", }, }, @@ -542,8 +579,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 16, Line: 223}}, - FirstLine: 221, + Lines: []bytecode.LineEntry{{PC: 0, Line: 267}, {PC: 16, Line: 268}}, + FirstLine: 266, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in min_by", @@ -558,8 +595,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 222}}, - FirstLine: 222, + Lines: []bytecode.LineEntry{{PC: 0, Line: 267}}, + FirstLine: 267, Super: "", }, &bytecode.ISeq{ @@ -573,8 +610,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 223}}, - FirstLine: 223, + Lines: []bytecode.LineEntry{{PC: 0, Line: 268}}, + FirstLine: 268, Super: "", }, }, @@ -595,8 +632,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 227}, {PC: 16, Line: 228}}, - FirstLine: 226, + Lines: []bytecode.LineEntry{{PC: 0, Line: 272}, {PC: 16, Line: 273}}, + FirstLine: 271, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in max_by", @@ -611,8 +648,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 227}}, - FirstLine: 227, + Lines: []bytecode.LineEntry{{PC: 0, Line: 272}}, + FirstLine: 272, Super: "", }, &bytecode.ISeq{ @@ -626,8 +663,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 228}}, - FirstLine: 228, + Lines: []bytecode.LineEntry{{PC: 0, Line: 273}}, + FirstLine: 273, Super: "", }, }, @@ -644,8 +681,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 232}}, - FirstLine: 231, + Lines: []bytecode.LineEntry{{PC: 0, Line: 277}}, + FirstLine: 276, Super: "", }, &bytecode.ISeq{ @@ -661,8 +698,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 236}, {PC: 10, Line: 237}}, - FirstLine: 235, + Lines: []bytecode.LineEntry{{PC: 0, Line: 281}, {PC: 10, Line: 282}}, + FirstLine: 280, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in sort_by", @@ -677,8 +714,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 236}}, - FirstLine: 236, + Lines: []bytecode.LineEntry{{PC: 0, Line: 281}}, + FirstLine: 281, Super: "", }, &bytecode.ISeq{ @@ -692,8 +729,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 237}}, - FirstLine: 237, + Lines: []bytecode.LineEntry{{PC: 0, Line: 282}}, + FirstLine: 282, Super: "", }, }, @@ -713,8 +750,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 241}, {PC: 10, Line: 242}, {PC: 13, Line: 243}, {PC: 16, Line: 244}}, - FirstLine: 240, + Lines: []bytecode.LineEntry{{PC: 0, Line: 286}, {PC: 10, Line: 287}, {PC: 13, Line: 288}, {PC: 16, Line: 289}}, + FirstLine: 285, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select", @@ -729,8 +766,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 241}}, - FirstLine: 241, + Lines: []bytecode.LineEntry{{PC: 0, Line: 286}}, + FirstLine: 286, Super: "", }, &bytecode.ISeq{ @@ -745,8 +782,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 243}}, - FirstLine: 243, + Lines: []bytecode.LineEntry{{PC: 0, Line: 288}}, + FirstLine: 288, Super: "", }, }, @@ -766,8 +803,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 249}, {PC: 10, Line: 250}, {PC: 13, Line: 251}, {PC: 16, Line: 252}}, - FirstLine: 248, + Lines: []bytecode.LineEntry{{PC: 0, Line: 294}, {PC: 10, Line: 295}, {PC: 13, Line: 296}, {PC: 16, Line: 297}}, + FirstLine: 293, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject", @@ -782,8 +819,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 249}}, - FirstLine: 249, + Lines: []bytecode.LineEntry{{PC: 0, Line: 294}}, + FirstLine: 294, Super: "", }, &bytecode.ISeq{ @@ -798,8 +835,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 251}}, - FirstLine: 251, + Lines: []bytecode.LineEntry{{PC: 0, Line: 296}}, + FirstLine: 296, Super: "", }, }, @@ -820,8 +857,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"ifnone", "found", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 258}, {PC: 2, Line: 259}, {PC: 16, Line: 260}, {PC: 19, Line: 259}, {PC: 22, Line: 262}, {PC: 25, Line: 270}, {PC: 32, Line: 271}, {PC: 35, Line: 259}}, - FirstLine: 258, + Lines: []bytecode.LineEntry{{PC: 0, Line: 303}, {PC: 2, Line: 304}, {PC: 16, Line: 305}, {PC: 19, Line: 304}, {PC: 22, Line: 307}, {PC: 25, Line: 315}, {PC: 32, Line: 316}, {PC: 35, Line: 304}}, + FirstLine: 303, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in find", @@ -832,8 +869,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 259, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 304, Super: "", }, &bytecode.ISeq{ @@ -847,8 +884,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 263}, {PC: 3, Line: 264}, {PC: 6, Line: 265}, {PC: 9, Line: 266}}, - FirstLine: 262, + Lines: []bytecode.LineEntry{{PC: 0, Line: 308}, {PC: 3, Line: 309}, {PC: 6, Line: 310}, {PC: 9, Line: 311}}, + FirstLine: 307, Super: "", }, }, @@ -866,8 +903,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"value", "found"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 276}, {PC: 3, Line: 277}, {PC: 6, Line: 278}}, - FirstLine: 275, + Lines: []bytecode.LineEntry{{PC: 0, Line: 321}, {PC: 3, Line: 322}, {PC: 6, Line: 323}}, + FirstLine: 320, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in include?", @@ -880,8 +917,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 277}}, - FirstLine: 277, + Lines: []bytecode.LineEntry{{PC: 0, Line: 322}}, + FirstLine: 322, Super: "", }, }, @@ -903,8 +940,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"init", "total", "compensation", "float_mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 285}, {PC: 5, Line: 286}, {PC: 8, Line: 287}, {PC: 11, Line: 288}, {PC: 16, Line: 289}, {PC: 19, Line: 303}}, - FirstLine: 285, + Lines: []bytecode.LineEntry{{PC: 0, Line: 330}, {PC: 5, Line: 331}, {PC: 8, Line: 332}, {PC: 11, Line: 333}, {PC: 16, Line: 334}, {PC: 19, Line: 348}}, + FirstLine: 330, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in sum", @@ -918,8 +955,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"x", "v", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 290}, {PC: 8, Line: 291}, {PC: 17, Line: 292}, {PC: 21, Line: 293}, {PC: 26, Line: 295}, {PC: 34, Line: 296}, {PC: 39, Line: 297}, {PC: 60, Line: 298}, {PC: 63, Line: 300}}, - FirstLine: 289, + Lines: []bytecode.LineEntry{{PC: 0, Line: 335}, {PC: 8, Line: 336}, {PC: 17, Line: 337}, {PC: 21, Line: 338}, {PC: 26, Line: 340}, {PC: 34, Line: 341}, {PC: 39, Line: 342}, {PC: 60, Line: 343}, {PC: 63, Line: 345}}, + FirstLine: 334, Super: "", }, }, @@ -937,8 +974,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 4, Locals: []string{"n", "block", "result", "first"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 310}, {PC: 2, Line: 259}, {PC: 5, Line: 311}, {PC: 19, Line: 259}, {PC: 22, Line: 313}, {PC: 25, Line: 314}, {PC: 28, Line: 324}}, - FirstLine: 310, + Lines: []bytecode.LineEntry{{PC: 0, Line: 355}, {PC: 2, Line: 304}, {PC: 5, Line: 356}, {PC: 19, Line: 304}, {PC: 22, Line: 358}, {PC: 25, Line: 359}, {PC: 28, Line: 369}}, + FirstLine: 355, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in min", @@ -958,8 +995,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "c"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 315}, {PC: 2, Line: 316}, {PC: 5, Line: 317}, {PC: 8, Line: 319}, {PC: 20, Line: 320}, {PC: 39, Line: 321}}, - FirstLine: 314, + Lines: []bytecode.LineEntry{{PC: 0, Line: 360}, {PC: 2, Line: 361}, {PC: 5, Line: 362}, {PC: 8, Line: 364}, {PC: 20, Line: 365}, {PC: 39, Line: 366}}, + FirstLine: 359, Super: "", }, }, @@ -977,8 +1014,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 4, Locals: []string{"n", "block", "result", "first"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 327}, {PC: 2, Line: 259}, {PC: 5, Line: 328}, {PC: 20, Line: 259}, {PC: 23, Line: 330}, {PC: 26, Line: 331}, {PC: 29, Line: 341}}, - FirstLine: 327, + Lines: []bytecode.LineEntry{{PC: 0, Line: 372}, {PC: 2, Line: 304}, {PC: 5, Line: 373}, {PC: 20, Line: 304}, {PC: 23, Line: 375}, {PC: 26, Line: 376}, {PC: 29, Line: 386}}, + FirstLine: 372, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in max", @@ -998,8 +1035,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "c"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 332}, {PC: 2, Line: 333}, {PC: 5, Line: 334}, {PC: 8, Line: 336}, {PC: 20, Line: 337}, {PC: 39, Line: 338}}, - FirstLine: 331, + Lines: []bytecode.LineEntry{{PC: 0, Line: 377}, {PC: 2, Line: 378}, {PC: 5, Line: 379}, {PC: 8, Line: 381}, {PC: 20, Line: 382}, {PC: 39, Line: 383}}, + FirstLine: 376, Super: "", }, }, @@ -1016,8 +1053,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 345}}, - FirstLine: 344, + Lines: []bytecode.LineEntry{{PC: 0, Line: 390}}, + FirstLine: 389, Super: "", }, &bytecode.ISeq{ @@ -1045,8 +1082,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 6, Locals: []string{"args", "sym", "has_init", "init", "acc", "started"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 353}, {PC: 17, Line: 259}, {PC: 20, Line: 355}, {PC: 23, Line: 259}, {PC: 26, Line: 357}, {PC: 31, Line: 362}, {PC: 46, Line: 363}, {PC: 51, Line: 364}, {PC: 56, Line: 365}, {PC: 64, Line: 367}, {PC: 66, Line: 368}, {PC: 71, Line: 369}, {PC: 74, Line: 371}, {PC: 82, Line: 374}, {PC: 89, Line: 376}, {PC: 105, Line: 377}, {PC: 109, Line: 378}, {PC: 113, Line: 380}, {PC: 125, Line: 383}, {PC: 128, Line: 384}, {PC: 131, Line: 385}, {PC: 134, Line: 395}}, - FirstLine: 348, + Lines: []bytecode.LineEntry{{PC: 0, Line: 398}, {PC: 17, Line: 304}, {PC: 20, Line: 400}, {PC: 23, Line: 304}, {PC: 26, Line: 402}, {PC: 31, Line: 407}, {PC: 46, Line: 408}, {PC: 51, Line: 409}, {PC: 56, Line: 410}, {PC: 64, Line: 412}, {PC: 66, Line: 413}, {PC: 71, Line: 414}, {PC: 74, Line: 416}, {PC: 82, Line: 419}, {PC: 89, Line: 421}, {PC: 105, Line: 422}, {PC: 109, Line: 423}, {PC: 113, Line: 425}, {PC: 125, Line: 428}, {PC: 128, Line: 429}, {PC: 131, Line: 430}, {PC: 134, Line: 440}}, + FirstLine: 393, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reduce", @@ -1060,8 +1097,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 386}, {PC: 3, Line: 387}, {PC: 6, Line: 388}, {PC: 11, Line: 390}, {PC: 17, Line: 392}}, - FirstLine: 385, + Lines: []bytecode.LineEntry{{PC: 0, Line: 431}, {PC: 3, Line: 432}, {PC: 6, Line: 433}, {PC: 11, Line: 435}, {PC: 17, Line: 437}}, + FirstLine: 430, Super: "", }, }, @@ -1085,8 +1122,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 404}, {PC: 5, Line: 259}, {PC: 8, Line: 405}, {PC: 11, Line: 408}, {PC: 27, Line: 409}}, - FirstLine: 404, + Lines: []bytecode.LineEntry{{PC: 0, Line: 449}, {PC: 5, Line: 304}, {PC: 8, Line: 450}, {PC: 11, Line: 453}, {PC: 27, Line: 454}}, + FirstLine: 449, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in any?", @@ -1098,8 +1135,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 410}, {PC: 3, Line: 414}}, - FirstLine: 409, + Lines: []bytecode.LineEntry{{PC: 0, Line: 455}, {PC: 3, Line: 459}}, + FirstLine: 454, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in any?", @@ -1116,8 +1153,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 411}, {PC: 21, Line: 412}}, - FirstLine: 410, + Lines: []bytecode.LineEntry{{PC: 0, Line: 456}, {PC: 21, Line: 457}}, + FirstLine: 455, Super: "", }, }, @@ -1144,8 +1181,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 418}, {PC: 5, Line: 259}, {PC: 8, Line: 419}, {PC: 11, Line: 422}, {PC: 27, Line: 423}}, - FirstLine: 418, + Lines: []bytecode.LineEntry{{PC: 0, Line: 463}, {PC: 5, Line: 304}, {PC: 8, Line: 464}, {PC: 11, Line: 467}, {PC: 27, Line: 468}}, + FirstLine: 463, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in all?", @@ -1157,8 +1194,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 424}, {PC: 3, Line: 428}}, - FirstLine: 423, + Lines: []bytecode.LineEntry{{PC: 0, Line: 469}, {PC: 3, Line: 473}}, + FirstLine: 468, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in all?", @@ -1175,8 +1212,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 425}, {PC: 21, Line: 426}}, - FirstLine: 424, + Lines: []bytecode.LineEntry{{PC: 0, Line: 470}, {PC: 21, Line: 471}}, + FirstLine: 469, Super: "", }, }, @@ -1203,8 +1240,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 432}, {PC: 5, Line: 259}, {PC: 8, Line: 433}, {PC: 11, Line: 436}, {PC: 27, Line: 437}}, - FirstLine: 432, + Lines: []bytecode.LineEntry{{PC: 0, Line: 477}, {PC: 5, Line: 304}, {PC: 8, Line: 478}, {PC: 11, Line: 481}, {PC: 27, Line: 482}}, + FirstLine: 477, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in none?", @@ -1216,8 +1253,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 438}, {PC: 3, Line: 442}}, - FirstLine: 437, + Lines: []bytecode.LineEntry{{PC: 0, Line: 483}, {PC: 3, Line: 487}}, + FirstLine: 482, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in none?", @@ -1234,8 +1271,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 439}, {PC: 21, Line: 440}}, - FirstLine: 438, + Lines: []bytecode.LineEntry{{PC: 0, Line: 484}, {PC: 21, Line: 485}}, + FirstLine: 483, Super: "", }, }, @@ -1263,8 +1300,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"pattern", "no_pat", "blk", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 450}, {PC: 5, Line: 259}, {PC: 8, Line: 451}, {PC: 11, Line: 453}, {PC: 27, Line: 454}, {PC: 30, Line: 455}, {PC: 34, Line: 464}}, - FirstLine: 450, + Lines: []bytecode.LineEntry{{PC: 0, Line: 495}, {PC: 5, Line: 304}, {PC: 8, Line: 496}, {PC: 11, Line: 498}, {PC: 27, Line: 499}, {PC: 30, Line: 500}, {PC: 34, Line: 509}}, + FirstLine: 495, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in one?", @@ -1276,8 +1313,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 456}}, - FirstLine: 455, + Lines: []bytecode.LineEntry{{PC: 0, Line: 501}}, + FirstLine: 500, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in one?", @@ -1295,8 +1332,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 457}, {PC: 21, Line: 458}, {PC: 23, Line: 459}, {PC: 28, Line: 460}}, - FirstLine: 456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 502}, {PC: 21, Line: 503}, {PC: 23, Line: 504}, {PC: 28, Line: 505}}, + FirstLine: 501, Super: "", }, }, @@ -1316,8 +1353,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"result", "keys", "hashes"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 472}, {PC: 3, Line: 473}, {PC: 6, Line: 474}, {PC: 9, Line: 475}, {PC: 12, Line: 493}}, - FirstLine: 471, + Lines: []bytecode.LineEntry{{PC: 0, Line: 517}, {PC: 3, Line: 518}, {PC: 6, Line: 519}, {PC: 9, Line: 520}, {PC: 12, Line: 538}}, + FirstLine: 516, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in uniq", @@ -1335,8 +1372,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 6, Locals: []string{"x", "key", "h", "seen", "i", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 476}, {PC: 8, Line: 477}, {PC: 12, Line: 478}, {PC: 15, Line: 479}, {PC: 18, Line: 480}, {PC: 23, Line: 481}, {PC: 37, Line: 482}, {PC: 40, Line: 483}, {PC: 47, Line: 485}, {PC: 57, Line: 487}, {PC: 60, Line: 488}, {PC: 64, Line: 489}, {PC: 68, Line: 490}}, - FirstLine: 475, + Lines: []bytecode.LineEntry{{PC: 0, Line: 521}, {PC: 8, Line: 522}, {PC: 12, Line: 523}, {PC: 15, Line: 524}, {PC: 18, Line: 525}, {PC: 23, Line: 526}, {PC: 37, Line: 527}, {PC: 40, Line: 528}, {PC: 47, Line: 530}, {PC: 57, Line: 532}, {PC: 60, Line: 533}, {PC: 64, Line: 534}, {PC: 68, Line: 535}}, + FirstLine: 520, Super: "", }, }, @@ -1353,8 +1390,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 499}, {PC: 3, Line: 500}, {PC: 6, Line: 501}}, - FirstLine: 498, + Lines: []bytecode.LineEntry{{PC: 0, Line: 544}, {PC: 3, Line: 545}, {PC: 6, Line: 546}}, + FirstLine: 543, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in compact", @@ -1368,8 +1405,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 500}}, - FirstLine: 500, + Lines: []bytecode.LineEntry{{PC: 0, Line: 545}}, + FirstLine: 545, Super: "", }, }, @@ -1391,8 +1428,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 505}, {PC: 16, Line: 506}, {PC: 19, Line: 507}, {PC: 26, Line: 109}}, - FirstLine: 504, + Lines: []bytecode.LineEntry{{PC: 0, Line: 550}, {PC: 16, Line: 551}, {PC: 19, Line: 552}, {PC: 26, Line: 109}}, + FirstLine: 549, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_with_index", @@ -1407,8 +1444,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 505}}, - FirstLine: 505, + Lines: []bytecode.LineEntry{{PC: 0, Line: 550}}, + FirstLine: 550, Super: "", }, &bytecode.ISeq{ @@ -1426,8 +1463,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 508}, {PC: 6, Line: 509}}, - FirstLine: 507, + Lines: []bytecode.LineEntry{{PC: 0, Line: 553}, {PC: 6, Line: 554}}, + FirstLine: 552, Super: "", }, }, @@ -1447,8 +1484,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 10, Line: 520}, {PC: 15, Line: 109}}, - FirstLine: 518, + Lines: []bytecode.LineEntry{{PC: 0, Line: 564}, {PC: 10, Line: 565}, {PC: 15, Line: 109}}, + FirstLine: 563, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reverse_each", @@ -1463,8 +1500,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 7, Line: 259}}, - FirstLine: 519, + Lines: []bytecode.LineEntry{{PC: 0, Line: 564}, {PC: 7, Line: 304}}, + FirstLine: 564, Super: "", }, }, @@ -1484,8 +1521,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 525}, {PC: 10, Line: 526}, {PC: 13, Line: 527}, {PC: 16, Line: 536}}, - FirstLine: 524, + Lines: []bytecode.LineEntry{{PC: 0, Line: 570}, {PC: 10, Line: 571}, {PC: 13, Line: 572}, {PC: 16, Line: 581}}, + FirstLine: 569, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flat_map", @@ -1500,8 +1537,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 525}}, - FirstLine: 525, + Lines: []bytecode.LineEntry{{PC: 0, Line: 570}}, + FirstLine: 570, Super: "", }, &bytecode.ISeq{ @@ -1516,8 +1553,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"x", "v", "ary"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 528}, {PC: 4, Line: 529}, {PC: 9, Line: 530}, {PC: 12, Line: 531}, {PC: 16, Line: 533}}, - FirstLine: 527, + Lines: []bytecode.LineEntry{{PC: 0, Line: 573}, {PC: 4, Line: 574}, {PC: 9, Line: 575}, {PC: 12, Line: 576}, {PC: 16, Line: 578}}, + FirstLine: 572, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in flat_map", @@ -1531,8 +1568,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"e"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 533}}, - FirstLine: 533, + Lines: []bytecode.LineEntry{{PC: 0, Line: 578}}, + FirstLine: 578, Super: "", }, }, @@ -1556,8 +1593,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 548}, {PC: 16, Line: 549}, {PC: 23, Line: 109}}, - FirstLine: 547, + Lines: []bytecode.LineEntry{{PC: 0, Line: 593}, {PC: 16, Line: 594}, {PC: 23, Line: 109}}, + FirstLine: 592, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_entry", @@ -1572,8 +1609,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 548}}, - FirstLine: 548, + Lines: []bytecode.LineEntry{{PC: 0, Line: 593}}, + FirstLine: 593, Super: "", }, &bytecode.ISeq{ @@ -1588,8 +1625,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 549}}, - FirstLine: 549, + Lines: []bytecode.LineEntry{{PC: 0, Line: 594}}, + FirstLine: 594, Super: "", }, }, @@ -1610,8 +1647,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"memo"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 554}, {PC: 11, Line: 555}, {PC: 14, Line: 556}}, - FirstLine: 553, + Lines: []bytecode.LineEntry{{PC: 0, Line: 599}, {PC: 11, Line: 600}, {PC: 14, Line: 601}}, + FirstLine: 598, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_with_object", @@ -1626,8 +1663,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 554}}, - FirstLine: 554, + Lines: []bytecode.LineEntry{{PC: 0, Line: 599}}, + FirstLine: 599, Super: "", }, &bytecode.ISeq{ @@ -1641,8 +1678,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 555}}, - FirstLine: 555, + Lines: []bytecode.LineEntry{{PC: 0, Line: 600}}, + FirstLine: 600, Super: "", }, }, @@ -1662,8 +1699,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 560}, {PC: 10, Line: 561}, {PC: 13, Line: 562}, {PC: 16, Line: 566}}, - FirstLine: 559, + Lines: []bytecode.LineEntry{{PC: 0, Line: 605}, {PC: 10, Line: 606}, {PC: 13, Line: 607}, {PC: 16, Line: 611}}, + FirstLine: 604, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in filter_map", @@ -1678,8 +1715,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 560}}, - FirstLine: 560, + Lines: []bytecode.LineEntry{{PC: 0, Line: 605}}, + FirstLine: 605, Super: "", }, &bytecode.ISeq{ @@ -1694,8 +1731,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 563}, {PC: 4, Line: 564}}, - FirstLine: 562, + Lines: []bytecode.LineEntry{{PC: 0, Line: 608}, {PC: 4, Line: 609}}, + FirstLine: 607, Super: "", }, }, @@ -1715,8 +1752,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"yes", "no"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 570}, {PC: 10, Line: 571}, {PC: 13, Line: 572}, {PC: 16, Line: 573}, {PC: 19, Line: 580}}, - FirstLine: 569, + Lines: []bytecode.LineEntry{{PC: 0, Line: 615}, {PC: 10, Line: 616}, {PC: 13, Line: 617}, {PC: 16, Line: 618}, {PC: 19, Line: 625}}, + FirstLine: 614, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in partition", @@ -1731,8 +1768,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 570}}, - FirstLine: 570, + Lines: []bytecode.LineEntry{{PC: 0, Line: 615}}, + FirstLine: 615, Super: "", }, &bytecode.ISeq{ @@ -1747,8 +1784,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 574}, {PC: 3, Line: 575}, {PC: 7, Line: 577}}, - FirstLine: 573, + Lines: []bytecode.LineEntry{{PC: 0, Line: 619}, {PC: 3, Line: 620}, {PC: 7, Line: 622}}, + FirstLine: 618, Super: "", }, }, @@ -1768,8 +1805,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 584}, {PC: 10, Line: 585}, {PC: 13, Line: 586}, {PC: 16, Line: 590}}, - FirstLine: 583, + Lines: []bytecode.LineEntry{{PC: 0, Line: 629}, {PC: 10, Line: 630}, {PC: 13, Line: 631}, {PC: 16, Line: 635}}, + FirstLine: 628, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in group_by", @@ -1784,8 +1821,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 584}}, - FirstLine: 584, + Lines: []bytecode.LineEntry{{PC: 0, Line: 629}}, + FirstLine: 629, Super: "", }, &bytecode.ISeq{ @@ -1800,8 +1837,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"x", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 587}, {PC: 4, Line: 588}}, - FirstLine: 586, + Lines: []bytecode.LineEntry{{PC: 0, Line: 632}, {PC: 4, Line: 633}}, + FirstLine: 631, Super: "", }, }, @@ -1833,8 +1870,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "h", "a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 598}, {PC: 17, Line: 599}, {PC: 20, Line: 600}, {PC: 23, Line: 602}, {PC: 28, Line: 603}, {PC: 33, Line: 604}, {PC: 37, Line: 605}, {PC: 41, Line: 606}, {PC: 70, Line: 608}, {PC: 87, Line: 611}, {PC: 90, Line: 613}, {PC: 93, Line: 625}}, - FirstLine: 597, + Lines: []bytecode.LineEntry{{PC: 0, Line: 643}, {PC: 17, Line: 644}, {PC: 20, Line: 645}, {PC: 23, Line: 647}, {PC: 28, Line: 648}, {PC: 33, Line: 649}, {PC: 37, Line: 650}, {PC: 41, Line: 651}, {PC: 70, Line: 653}, {PC: 87, Line: 656}, {PC: 90, Line: 658}, {PC: 93, Line: 670}}, + FirstLine: 642, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in tally", @@ -1857,8 +1894,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"x", "c", "tn", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 614}, {PC: 4, Line: 615}, {PC: 9, Line: 616}, {PC: 14, Line: 617}, {PC: 35, Line: 618}, {PC: 46, Line: 621}, {PC: 49, Line: 623}}, - FirstLine: 613, + Lines: []bytecode.LineEntry{{PC: 0, Line: 659}, {PC: 4, Line: 660}, {PC: 9, Line: 661}, {PC: 14, Line: 662}, {PC: 35, Line: 663}, {PC: 46, Line: 666}, {PC: 49, Line: 668}}, + FirstLine: 658, Super: "", }, }, @@ -1879,8 +1916,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"others", "blk", "r", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 634}, {PC: 4, Line: 643}, {PC: 7, Line: 644}, {PC: 9, Line: 259}, {PC: 14, Line: 645}, {PC: 17, Line: 646}, {PC: 20, Line: 656}}, - FirstLine: 633, + Lines: []bytecode.LineEntry{{PC: 0, Line: 679}, {PC: 4, Line: 688}, {PC: 7, Line: 689}, {PC: 9, Line: 304}, {PC: 14, Line: 690}, {PC: 17, Line: 691}, {PC: 20, Line: 701}}, + FirstLine: 678, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in zip", @@ -1900,8 +1937,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 635}, {PC: 4, Line: 636}, {PC: 11, Line: 638}, {PC: 16, Line: 640}}, - FirstLine: 634, + Lines: []bytecode.LineEntry{{PC: 0, Line: 680}, {PC: 4, Line: 681}, {PC: 11, Line: 683}, {PC: 16, Line: 685}}, + FirstLine: 679, Super: "", }, &bytecode.ISeq{ @@ -1919,8 +1956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "row"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 647}, {PC: 4, Line: 648}, {PC: 7, Line: 649}, {PC: 9, Line: 650}, {PC: 12, Line: 652}, {PC: 16, Line: 654}}, - FirstLine: 646, + Lines: []bytecode.LineEntry{{PC: 0, Line: 692}, {PC: 4, Line: 693}, {PC: 7, Line: 694}, {PC: 9, Line: 695}, {PC: 12, Line: 697}, {PC: 16, Line: 699}}, + FirstLine: 691, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in zip", @@ -1934,8 +1971,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 648}}, - FirstLine: 648, + Lines: []bytecode.LineEntry{{PC: 0, Line: 693}}, + FirstLine: 693, Super: "", }, }, @@ -1965,8 +2002,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "idx", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 663}, {PC: 17, Line: 664}, {PC: 32, Line: 666}, {PC: 49, Line: 259}, {PC: 52, Line: 668}, {PC: 55, Line: 669}, {PC: 58, Line: 673}}, - FirstLine: 662, + Lines: []bytecode.LineEntry{{PC: 0, Line: 708}, {PC: 17, Line: 709}, {PC: 32, Line: 711}, {PC: 49, Line: 304}, {PC: 52, Line: 713}, {PC: 55, Line: 714}, {PC: 58, Line: 718}}, + FirstLine: 707, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in find_index", @@ -1977,8 +2014,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 664, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 709, Super: "", }, &bytecode.ISeq{ @@ -1997,8 +2034,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 670}, {PC: 27, Line: 671}}, - FirstLine: 669, + Lines: []bytecode.LineEntry{{PC: 0, Line: 715}, {PC: 27, Line: 716}}, + FirstLine: 714, Super: "", }, }, @@ -2016,8 +2053,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"pattern", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 681}, {PC: 3, Line: 682}, {PC: 6, Line: 683}}, - FirstLine: 680, + Lines: []bytecode.LineEntry{{PC: 0, Line: 726}, {PC: 3, Line: 727}, {PC: 6, Line: 728}}, + FirstLine: 725, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in grep", @@ -2031,8 +2068,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 682}}, - FirstLine: 682, + Lines: []bytecode.LineEntry{{PC: 0, Line: 727}}, + FirstLine: 727, Super: "", }, }, @@ -2050,8 +2087,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"pattern", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 687}, {PC: 3, Line: 688}, {PC: 6, Line: 689}}, - FirstLine: 686, + Lines: []bytecode.LineEntry{{PC: 0, Line: 732}, {PC: 3, Line: 733}, {PC: 6, Line: 734}}, + FirstLine: 731, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in grep_v", @@ -2065,8 +2102,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 688}}, - FirstLine: 688, + Lines: []bytecode.LineEntry{{PC: 0, Line: 733}}, + FirstLine: 733, Super: "", }, }, @@ -2086,8 +2123,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"r", "taking"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 693}, {PC: 10, Line: 694}, {PC: 13, Line: 695}, {PC: 16, Line: 696}, {PC: 19, Line: 704}}, - FirstLine: 692, + Lines: []bytecode.LineEntry{{PC: 0, Line: 738}, {PC: 10, Line: 739}, {PC: 13, Line: 740}, {PC: 16, Line: 741}, {PC: 19, Line: 749}}, + FirstLine: 737, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in take_while", @@ -2098,8 +2135,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 693, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 738, Super: "", }, &bytecode.ISeq{ @@ -2114,8 +2151,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 697}, {PC: 8, Line: 698}, {PC: 14, Line: 699}, {PC: 20, Line: 701}}, - FirstLine: 696, + Lines: []bytecode.LineEntry{{PC: 0, Line: 742}, {PC: 8, Line: 743}, {PC: 14, Line: 744}, {PC: 20, Line: 746}}, + FirstLine: 741, Super: "", }, }, @@ -2135,8 +2172,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"r", "dropping"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 708}, {PC: 10, Line: 709}, {PC: 13, Line: 710}, {PC: 16, Line: 711}, {PC: 19, Line: 715}}, - FirstLine: 707, + Lines: []bytecode.LineEntry{{PC: 0, Line: 753}, {PC: 10, Line: 754}, {PC: 13, Line: 755}, {PC: 16, Line: 756}, {PC: 19, Line: 760}}, + FirstLine: 752, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in drop_while", @@ -2147,8 +2184,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 708, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 753, Super: "", }, &bytecode.ISeq{ @@ -2163,8 +2200,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 712}, {PC: 13, Line: 713}}, - FirstLine: 711, + Lines: []bytecode.LineEntry{{PC: 0, Line: 757}, {PC: 13, Line: 758}}, + FirstLine: 756, Super: "", }, }, @@ -2187,8 +2224,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "buf"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 725}, {PC: 5, Line: 726}, {PC: 16, Line: 727}, {PC: 19, Line: 728}, {PC: 27, Line: 732}, {PC: 30, Line: 733}, {PC: 33, Line: 740}, {PC: 42, Line: 109}}, - FirstLine: 724, + Lines: []bytecode.LineEntry{{PC: 0, Line: 770}, {PC: 5, Line: 771}, {PC: 16, Line: 772}, {PC: 19, Line: 773}, {PC: 27, Line: 777}, {PC: 30, Line: 778}, {PC: 33, Line: 785}, {PC: 42, Line: 109}}, + FirstLine: 769, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_slice", @@ -2205,8 +2242,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 729}, {PC: 18, Line: 259}}, - FirstLine: 728, + Lines: []bytecode.LineEntry{{PC: 0, Line: 774}, {PC: 18, Line: 304}}, + FirstLine: 773, Super: "", }, &bytecode.ISeq{ @@ -2221,8 +2258,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 734}, {PC: 4, Line: 735}, {PC: 9, Line: 736}, {PC: 12, Line: 737}}, - FirstLine: 733, + Lines: []bytecode.LineEntry{{PC: 0, Line: 779}, {PC: 4, Line: 780}, {PC: 9, Line: 781}, {PC: 12, Line: 782}}, + FirstLine: 778, Super: "", }, }, @@ -2245,8 +2282,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "window"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 745}, {PC: 5, Line: 746}, {PC: 16, Line: 747}, {PC: 19, Line: 748}, {PC: 27, Line: 754}, {PC: 30, Line: 755}, {PC: 33, Line: 109}}, - FirstLine: 744, + Lines: []bytecode.LineEntry{{PC: 0, Line: 790}, {PC: 5, Line: 791}, {PC: 16, Line: 792}, {PC: 19, Line: 793}, {PC: 27, Line: 799}, {PC: 30, Line: 800}, {PC: 33, Line: 109}}, + FirstLine: 789, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_cons", @@ -2264,8 +2301,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 749}, {PC: 10, Line: 750}}, - FirstLine: 748, + Lines: []bytecode.LineEntry{{PC: 0, Line: 794}, {PC: 10, Line: 795}}, + FirstLine: 793, Super: "", }, &bytecode.ISeq{ @@ -2280,8 +2317,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 756}, {PC: 4, Line: 757}, {PC: 14, Line: 758}}, - FirstLine: 755, + Lines: []bytecode.LineEntry{{PC: 0, Line: 801}, {PC: 4, Line: 802}, {PC: 14, Line: 803}}, + FirstLine: 800, Super: "", }, }, @@ -2307,8 +2344,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "result", "n", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 769}, {PC: 17, Line: 770}, {PC: 20, Line: 259}, {PC: 23, Line: 772}, {PC: 27, Line: 775}, {PC: 32, Line: 777}, {PC: 39, Line: 778}, {PC: 50, Line: 779}, {PC: 59, Line: 780}, {PC: 62, Line: 781}, {PC: 66, Line: 787}}, - FirstLine: 768, + Lines: []bytecode.LineEntry{{PC: 0, Line: 814}, {PC: 17, Line: 815}, {PC: 20, Line: 304}, {PC: 23, Line: 817}, {PC: 27, Line: 820}, {PC: 32, Line: 822}, {PC: 39, Line: 823}, {PC: 50, Line: 824}, {PC: 59, Line: 825}, {PC: 62, Line: 826}, {PC: 66, Line: 832}}, + FirstLine: 813, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in first", @@ -2320,8 +2357,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 773}}, - FirstLine: 772, + Lines: []bytecode.LineEntry{{PC: 0, Line: 818}}, + FirstLine: 817, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in first", @@ -2338,8 +2375,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 773}}, - FirstLine: 773, + Lines: []bytecode.LineEntry{{PC: 0, Line: 818}}, + FirstLine: 818, Super: "", }, }, @@ -2355,8 +2392,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 782}}, - FirstLine: 781, + Lines: []bytecode.LineEntry{{PC: 0, Line: 827}}, + FirstLine: 826, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in first", @@ -2373,8 +2410,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 783}, {PC: 4, Line: 784}}, - FirstLine: 782, + Lines: []bytecode.LineEntry{{PC: 0, Line: 828}, {PC: 4, Line: 829}}, + FirstLine: 827, Super: "", }, }, @@ -2400,8 +2437,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 791}, {PC: 5, Line: 792}, {PC: 16, Line: 793}, {PC: 25, Line: 794}, {PC: 28, Line: 795}, {PC: 32, Line: 801}}, - FirstLine: 790, + Lines: []bytecode.LineEntry{{PC: 0, Line: 836}, {PC: 5, Line: 837}, {PC: 16, Line: 838}, {PC: 25, Line: 839}, {PC: 28, Line: 840}, {PC: 32, Line: 846}}, + FirstLine: 835, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in take", @@ -2413,8 +2450,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 796}}, - FirstLine: 795, + Lines: []bytecode.LineEntry{{PC: 0, Line: 841}}, + FirstLine: 840, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in take", @@ -2431,8 +2468,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 797}, {PC: 4, Line: 798}}, - FirstLine: 796, + Lines: []bytecode.LineEntry{{PC: 0, Line: 842}, {PC: 4, Line: 843}}, + FirstLine: 841, Super: "", }, }, @@ -2457,8 +2494,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"n", "r", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 805}, {PC: 5, Line: 806}, {PC: 16, Line: 807}, {PC: 19, Line: 808}, {PC: 22, Line: 809}, {PC: 25, Line: 813}}, - FirstLine: 804, + Lines: []bytecode.LineEntry{{PC: 0, Line: 850}, {PC: 5, Line: 851}, {PC: 16, Line: 852}, {PC: 19, Line: 853}, {PC: 22, Line: 854}, {PC: 25, Line: 858}}, + FirstLine: 849, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in drop", @@ -2475,8 +2512,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 810}, {PC: 10, Line: 811}}, - FirstLine: 809, + Lines: []bytecode.LineEntry{{PC: 0, Line: 855}, {PC: 10, Line: 856}}, + FirstLine: 854, Super: "", }, }, @@ -2499,8 +2536,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"a", "chunks", "cur", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 822}, {PC: 10, Line: 823}, {PC: 14, Line: 824}, {PC: 24, Line: 825}, {PC: 27, Line: 826}, {PC: 33, Line: 827}, {PC: 36, Line: 828}, {PC: 41, Line: 829}, {PC: 51, Line: 830}, {PC: 57, Line: 832}, {PC: 61, Line: 833}, {PC: 67, Line: 835}, {PC: 75, Line: 837}, {PC: 79, Line: 838}}, - FirstLine: 821, + Lines: []bytecode.LineEntry{{PC: 0, Line: 867}, {PC: 10, Line: 868}, {PC: 14, Line: 869}, {PC: 24, Line: 870}, {PC: 27, Line: 871}, {PC: 33, Line: 872}, {PC: 36, Line: 873}, {PC: 41, Line: 874}, {PC: 51, Line: 875}, {PC: 57, Line: 877}, {PC: 61, Line: 878}, {PC: 67, Line: 880}, {PC: 75, Line: 882}, {PC: 79, Line: 883}}, + FirstLine: 866, Super: "", }, &bytecode.ISeq{ @@ -2520,8 +2557,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"a", "chunks", "cur", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 842}, {PC: 10, Line: 843}, {PC: 14, Line: 844}, {PC: 24, Line: 845}, {PC: 27, Line: 846}, {PC: 33, Line: 847}, {PC: 36, Line: 848}, {PC: 41, Line: 849}, {PC: 51, Line: 850}, {PC: 55, Line: 851}, {PC: 61, Line: 853}, {PC: 67, Line: 855}, {PC: 75, Line: 857}, {PC: 79, Line: 858}}, - FirstLine: 841, + Lines: []bytecode.LineEntry{{PC: 0, Line: 887}, {PC: 10, Line: 888}, {PC: 14, Line: 889}, {PC: 24, Line: 890}, {PC: 27, Line: 891}, {PC: 33, Line: 892}, {PC: 36, Line: 893}, {PC: 41, Line: 894}, {PC: 51, Line: 895}, {PC: 55, Line: 896}, {PC: 61, Line: 898}, {PC: 67, Line: 900}, {PC: 75, Line: 902}, {PC: 79, Line: 903}}, + FirstLine: 886, Super: "", }, &bytecode.ISeq{ @@ -2539,8 +2576,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"result", "open"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 868}, {PC: 10, Line: 869}, {PC: 13, Line: 870}, {PC: 16, Line: 871}, {PC: 19, Line: 890}}, - FirstLine: 867, + Lines: []bytecode.LineEntry{{PC: 0, Line: 913}, {PC: 10, Line: 914}, {PC: 13, Line: 915}, {PC: 16, Line: 916}, {PC: 19, Line: 935}}, + FirstLine: 912, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in chunk", @@ -2551,8 +2588,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 868, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 913, Super: "", }, &bytecode.ISeq{ @@ -2576,8 +2613,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 872}, {PC: 4, Line: 873}, {PC: 13, Line: 874}, {PC: 20, Line: 876}, {PC: 27, Line: 877}, {PC: 30, Line: 879}, {PC: 41, Line: 880}, {PC: 48, Line: 882}, {PC: 60, Line: 883}, {PC: 68, Line: 885}, {PC: 75, Line: 886}}, - FirstLine: 871, + Lines: []bytecode.LineEntry{{PC: 0, Line: 917}, {PC: 4, Line: 918}, {PC: 13, Line: 919}, {PC: 20, Line: 921}, {PC: 27, Line: 922}, {PC: 30, Line: 924}, {PC: 41, Line: 925}, {PC: 48, Line: 927}, {PC: 60, Line: 928}, {PC: 68, Line: 930}, {PC: 75, Line: 931}}, + FirstLine: 916, Super: "", }, &bytecode.ISeq{ @@ -2589,8 +2626,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 890, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 935, Super: "", }, }, @@ -2617,8 +2654,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "pat", "runs", "cur"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 901}, {PC: 17, Line: 902}, {PC: 19, Line: 903}, {PC: 30, Line: 905}, {PC: 40, Line: 906}, {PC: 45, Line: 908}, {PC: 48, Line: 259}, {PC: 51, Line: 910}, {PC: 54, Line: 919}, {PC: 64, Line: 920}}, - FirstLine: 900, + Lines: []bytecode.LineEntry{{PC: 0, Line: 946}, {PC: 17, Line: 947}, {PC: 19, Line: 948}, {PC: 30, Line: 950}, {PC: 40, Line: 951}, {PC: 45, Line: 953}, {PC: 48, Line: 304}, {PC: 51, Line: 955}, {PC: 54, Line: 964}, {PC: 64, Line: 965}}, + FirstLine: 945, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in slice_before", @@ -2632,8 +2669,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 911}, {PC: 9, Line: 912}, {PC: 19, Line: 913}, {PC: 23, Line: 915}, {PC: 31, Line: 916}}, - FirstLine: 910, + Lines: []bytecode.LineEntry{{PC: 0, Line: 956}, {PC: 9, Line: 957}, {PC: 19, Line: 958}, {PC: 23, Line: 960}, {PC: 31, Line: 961}}, + FirstLine: 955, Super: "", }, &bytecode.ISeq{ @@ -2645,8 +2682,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 920, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 965, Super: "", }, }, @@ -2673,8 +2710,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "pat", "runs", "cur"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 924}, {PC: 17, Line: 925}, {PC: 19, Line: 926}, {PC: 30, Line: 928}, {PC: 40, Line: 929}, {PC: 45, Line: 931}, {PC: 48, Line: 932}, {PC: 51, Line: 933}, {PC: 54, Line: 940}, {PC: 64, Line: 941}}, - FirstLine: 923, + Lines: []bytecode.LineEntry{{PC: 0, Line: 969}, {PC: 17, Line: 970}, {PC: 19, Line: 971}, {PC: 30, Line: 973}, {PC: 40, Line: 974}, {PC: 45, Line: 976}, {PC: 48, Line: 977}, {PC: 51, Line: 978}, {PC: 54, Line: 985}, {PC: 64, Line: 986}}, + FirstLine: 968, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in slice_after", @@ -2688,8 +2725,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 934}, {PC: 4, Line: 935}, {PC: 13, Line: 936}, {PC: 17, Line: 937}}, - FirstLine: 933, + Lines: []bytecode.LineEntry{{PC: 0, Line: 979}, {PC: 4, Line: 980}, {PC: 13, Line: 981}, {PC: 17, Line: 982}}, + FirstLine: 978, Super: "", }, &bytecode.ISeq{ @@ -2701,8 +2738,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 941, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 986, Super: "", }, }, @@ -2721,8 +2758,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 947}, {PC: 10, Line: 948}}, - FirstLine: 946, + Lines: []bytecode.LineEntry{{PC: 0, Line: 992}, {PC: 10, Line: 993}}, + FirstLine: 991, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in minmax_by", @@ -2737,8 +2774,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 947}}, - FirstLine: 947, + Lines: []bytecode.LineEntry{{PC: 0, Line: 992}}, + FirstLine: 992, Super: "", }, &bytecode.ISeq{ @@ -2752,8 +2789,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 948}}, - FirstLine: 948, + Lines: []bytecode.LineEntry{{PC: 0, Line: 993}}, + FirstLine: 993, Super: "", }, &bytecode.ISeq{ @@ -2767,8 +2804,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 948}}, - FirstLine: 948, + Lines: []bytecode.LineEntry{{PC: 0, Line: 993}}, + FirstLine: 993, Super: "", }, }, @@ -2791,8 +2828,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "buffer"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 953}, {PC: 2, Line: 259}, {PC: 5, Line: 954}, {PC: 8, Line: 959}, {PC: 16, Line: 971}, {PC: 20, Line: 972}, {PC: 25, Line: 973}, {PC: 29, Line: 259}, {PC: 36, Line: 977}, {PC: 39, Line: 978}, {PC: 42, Line: 983}, {PC: 45, Line: 259}, {PC: 50, Line: 984}, {PC: 53, Line: 985}, {PC: 56, Line: 987}, {PC: 61, Line: 259}}, - FirstLine: 953, + Lines: []bytecode.LineEntry{{PC: 0, Line: 998}, {PC: 2, Line: 304}, {PC: 5, Line: 999}, {PC: 8, Line: 1004}, {PC: 16, Line: 1016}, {PC: 20, Line: 1017}, {PC: 25, Line: 1018}, {PC: 29, Line: 304}, {PC: 36, Line: 1022}, {PC: 39, Line: 1023}, {PC: 42, Line: 1028}, {PC: 45, Line: 304}, {PC: 50, Line: 1029}, {PC: 53, Line: 1030}, {PC: 56, Line: 1032}, {PC: 61, Line: 304}}, + FirstLine: 998, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in cycle", @@ -2809,8 +2846,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 960}, {PC: 7, Line: 259}, {PC: 10, Line: 961}, {PC: 19, Line: 962}, {PC: 24, Line: 964}, {PC: 27, Line: 966}}, - FirstLine: 959, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1005}, {PC: 7, Line: 304}, {PC: 10, Line: 1006}, {PC: 19, Line: 1007}, {PC: 24, Line: 1009}, {PC: 27, Line: 1011}}, + FirstLine: 1004, Super: "", }, &bytecode.ISeq{ @@ -2825,8 +2862,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 979}, {PC: 5, Line: 980}, {PC: 9, Line: 981}}, - FirstLine: 978, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1024}, {PC: 5, Line: 1025}, {PC: 9, Line: 1026}}, + FirstLine: 1023, Super: "", }, &bytecode.ISeq{ @@ -2839,8 +2876,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 985}}, - FirstLine: 985, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1030}}, + FirstLine: 1030, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in cycle", @@ -2853,8 +2890,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 985}}, - FirstLine: 985, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1030}}, + FirstLine: 1030, Super: "", }, }, @@ -2870,8 +2907,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 987}}, - FirstLine: 987, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1032}}, + FirstLine: 1032, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in cycle", @@ -2884,8 +2921,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 987}}, - FirstLine: 987, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1032}}, + FirstLine: 1032, Super: "", }, }, @@ -2907,8 +2944,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 999}, {PC: 4, Line: 1004}, {PC: 6, Line: 1008}}, - FirstLine: 998, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1044}, {PC: 4, Line: 1049}, {PC: 6, Line: 1053}}, + FirstLine: 1043, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -2920,8 +2957,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1005}}, - FirstLine: 1004, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1050}}, + FirstLine: 1049, Super: "", }, &bytecode.ISeq{ @@ -2934,8 +2971,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1009}}, - FirstLine: 1008, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1054}}, + FirstLine: 1053, Super: "", }, }, @@ -2951,8 +2988,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1015}, {PC: 2, Line: 1019}}, - FirstLine: 1013, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1060}, {PC: 2, Line: 1064}}, + FirstLine: 1058, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -2964,7 +3001,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1015, + FirstLine: 1060, Super: "", }, &bytecode.ISeq{ @@ -2979,8 +3016,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1020}}, - FirstLine: 1019, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1065}}, + FirstLine: 1064, Super: "", }, }, @@ -2996,8 +3033,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1028}, {PC: 2, Line: 1032}}, - FirstLine: 1024, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1073}, {PC: 2, Line: 1077}}, + FirstLine: 1069, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -3009,8 +3046,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1029}, {PC: 7, Line: 109}}, - FirstLine: 1028, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1074}, {PC: 7, Line: 109}}, + FirstLine: 1073, Super: "", }, &bytecode.ISeq{ @@ -3026,8 +3063,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1033}}, - FirstLine: 1032, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1078}}, + FirstLine: 1077, Super: "", }, }, @@ -3043,8 +3080,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1038}}, - FirstLine: 1037, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1083}}, + FirstLine: 1082, Super: "", }, &bytecode.ISeq{ @@ -3057,8 +3094,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1042}}, - FirstLine: 1041, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1087}}, + FirstLine: 1086, Super: "", }, &bytecode.ISeq{ @@ -3071,8 +3108,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1051}, {PC: 4, Line: 1054}, {PC: 6, Line: 1087}}, - FirstLine: 1050, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1096}, {PC: 4, Line: 1099}, {PC: 6, Line: 1132}}, + FirstLine: 1095, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct", @@ -3084,7 +3121,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1054, + FirstLine: 1099, Super: "", }, &bytecode.ISeq{ @@ -3104,8 +3141,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"ifnone", "idx", "elem", "len"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1087}, {PC: 2, Line: 259}, {PC: 5, Line: 1092}, {PC: 16, Line: 1093}, {PC: 20, Line: 1094}, {PC: 24, Line: 1095}, {PC: 29, Line: 109}, {PC: 34, Line: 1097}, {PC: 42, Line: 1098}, {PC: 46, Line: 1099}, {PC: 58, Line: 1103}, {PC: 61, Line: 259}}, - FirstLine: 1087, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1132}, {PC: 2, Line: 304}, {PC: 5, Line: 1137}, {PC: 16, Line: 1138}, {PC: 20, Line: 1139}, {PC: 24, Line: 1140}, {PC: 29, Line: 109}, {PC: 34, Line: 1142}, {PC: 42, Line: 1143}, {PC: 46, Line: 1144}, {PC: 58, Line: 1148}, {PC: 61, Line: 304}}, + FirstLine: 1132, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in rfind", @@ -3116,8 +3153,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, - FirstLine: 1092, + Lines: []bytecode.LineEntry{{PC: 0, Line: 304}}, + FirstLine: 1137, Super: "", }, }, @@ -3136,26 +3173,26 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1143}, {PC: 6, Line: 1153}, {PC: 8, Line: 1160}, {PC: 10, Line: 1170}}, - FirstLine: 1107, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1153}, {PC: 4, Line: 1206}, {PC: 6, Line: 1217}, {PC: 8, Line: 1224}, {PC: 10, Line: 1234}}, + FirstLine: 1152, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "to_set", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 14}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 30, A: 4, B: 2, Flags: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 47, B: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 30, A: 4, B: 1, Flags: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 11, A: 1}, {Op: 30, A: 5, B: 2, Flags: 2}, {Op: 53}}, Consts: []object.Value{ object.FString("cannot convert endless range to a set", ""), }, - Names: []string{"Set", "end", "nil?", "RangeError", "raise"}, - Params: []string{"klass", "args"}, + Names: []string{"end", "nil?", "RangeError", "raise", "__warn_to_set_args", "__to_set_core"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: 1, + SplatIndex: 0, PostCount: 0, KwRestSlot: -1, - BlockSlot: 2, - NumLocals: 3, - Locals: []string{"klass", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1143}, {PC: 5, Line: 109}, {PC: 16, Line: 1145}}, - FirstLine: 1143, + BlockSlot: 1, + NumLocals: 2, + Locals: []string{"args", "block"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 11, Line: 1208}, {PC: 15, Line: 1209}}, + FirstLine: 1206, Super: "", }, &bytecode.ISeq{ @@ -3170,8 +3207,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1154}, {PC: 9, Line: 1155}, {PC: 19, Line: 109}}, - FirstLine: 1153, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1218}, {PC: 9, Line: 1219}, {PC: 19, Line: 109}}, + FirstLine: 1217, Super: "", }, &bytecode.ISeq{ @@ -3186,8 +3223,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1161}, {PC: 9, Line: 1162}, {PC: 19, Line: 109}}, - FirstLine: 1160, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1225}, {PC: 9, Line: 1226}, {PC: 19, Line: 109}}, + FirstLine: 1224, Super: "", }, &bytecode.ISeq{ @@ -3201,7 +3238,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1170, + FirstLine: 1234, Super: "", }, }, @@ -3217,8 +3254,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1179}, {PC: 4, Line: 1182}}, - FirstLine: 1178, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1243}, {PC: 4, Line: 1246}}, + FirstLine: 1242, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct_keys", @@ -3232,7 +3269,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"keys"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1182, + FirstLine: 1246, Super: "", }, }, @@ -3254,8 +3291,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}, {PC: 4, Line: 1200}, {PC: 6, Line: 1209}, {PC: 10, Line: 1213}, {PC: 12, Line: 1221}, {PC: 16, Line: 1225}, {PC: 18, Line: 1231}, {PC: 20, Line: 1237}, {PC: 22, Line: 1241}, {PC: 24, Line: 1247}, {PC: 26, Line: 1252}, {PC: 28, Line: 1253}, {PC: 30, Line: 1257}, {PC: 32, Line: 1262}, {PC: 34, Line: 1266}, {PC: 36, Line: 1271}, {PC: 38, Line: 1275}, {PC: 40, Line: 1282}, {PC: 42, Line: 1288}, {PC: 44, Line: 1296}, {PC: 46, Line: 1310}, {PC: 48, Line: 1318}, {PC: 50, Line: 1323}, {PC: 52, Line: 1326}, {PC: 54, Line: 1331}, {PC: 56, Line: 1334}, {PC: 58, Line: 1339}, {PC: 60, Line: 1342}, {PC: 62, Line: 1347}, {PC: 64, Line: 1351}, {PC: 66, Line: 1362}, {PC: 68, Line: 1371}, {PC: 70, Line: 1375}, {PC: 72, Line: 1381}, {PC: 74, Line: 1389}, {PC: 76, Line: 1395}, {PC: 78, Line: 1401}, {PC: 80, Line: 1409}, {PC: 82, Line: 1415}, {PC: 84, Line: 1417}, {PC: 86, Line: 1426}, {PC: 88, Line: 1433}, {PC: 90, Line: 1437}, {PC: 92, Line: 1456}, {PC: 94, Line: 1479}, {PC: 96, Line: 1521}, {PC: 100, Line: 1527}, {PC: 102, Line: 1531}, {PC: 104, Line: 1542}, {PC: 106, Line: 1555}, {PC: 110, Line: 1558}, {PC: 112, Line: 1579}}, - FirstLine: 1193, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1258}, {PC: 4, Line: 1264}, {PC: 6, Line: 1273}, {PC: 10, Line: 1277}, {PC: 12, Line: 1285}, {PC: 16, Line: 1289}, {PC: 18, Line: 1295}, {PC: 20, Line: 1301}, {PC: 22, Line: 1305}, {PC: 24, Line: 1311}, {PC: 26, Line: 1316}, {PC: 28, Line: 1317}, {PC: 30, Line: 1321}, {PC: 32, Line: 1326}, {PC: 34, Line: 1330}, {PC: 36, Line: 1335}, {PC: 38, Line: 1339}, {PC: 40, Line: 1346}, {PC: 42, Line: 1352}, {PC: 44, Line: 1360}, {PC: 46, Line: 1374}, {PC: 48, Line: 1382}, {PC: 50, Line: 1387}, {PC: 52, Line: 1390}, {PC: 54, Line: 1395}, {PC: 56, Line: 1398}, {PC: 58, Line: 1403}, {PC: 60, Line: 1406}, {PC: 62, Line: 1411}, {PC: 64, Line: 1415}, {PC: 66, Line: 1426}, {PC: 68, Line: 1435}, {PC: 70, Line: 1439}, {PC: 72, Line: 1445}, {PC: 74, Line: 1453}, {PC: 76, Line: 1459}, {PC: 78, Line: 1465}, {PC: 80, Line: 1473}, {PC: 82, Line: 1479}, {PC: 84, Line: 1481}, {PC: 86, Line: 1490}, {PC: 88, Line: 1497}, {PC: 90, Line: 1501}, {PC: 92, Line: 1520}, {PC: 94, Line: 1543}, {PC: 96, Line: 1585}, {PC: 100, Line: 1591}, {PC: 102, Line: 1595}, {PC: 104, Line: 1606}, {PC: 106, Line: 1619}, {PC: 110, Line: 1622}, {PC: 112, Line: 1643}}, + FirstLine: 1257, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__do_with_enum", @@ -3274,8 +3311,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1201}, {PC: 4, Line: 1202}, {PC: 12, Line: 1204}, {PC: 16, Line: 1206}}, - FirstLine: 1200, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1265}, {PC: 4, Line: 1266}, {PC: 12, Line: 1268}, {PC: 16, Line: 1270}}, + FirstLine: 1264, Super: "", }, &bytecode.ISeq{ @@ -3290,8 +3327,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1213}, {PC: 2, Line: 259}, {PC: 5, Line: 1214}, {PC: 13, Line: 1215}, {PC: 15, Line: 1216}, {PC: 19, Line: 1218}}, - FirstLine: 1213, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1277}, {PC: 2, Line: 304}, {PC: 5, Line: 1278}, {PC: 13, Line: 1279}, {PC: 15, Line: 1280}, {PC: 19, Line: 1282}}, + FirstLine: 1277, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -3305,8 +3342,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1216}}, - FirstLine: 1216, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1280}}, + FirstLine: 1280, Super: "", }, &bytecode.ISeq{ @@ -3321,8 +3358,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1218}}, - FirstLine: 1218, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1282}}, + FirstLine: 1282, Super: "", }, }, @@ -3342,8 +3379,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1226}, {PC: 10, Line: 1227}, {PC: 14, Line: 109}}, - FirstLine: 1225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1290}, {PC: 10, Line: 1291}, {PC: 14, Line: 109}}, + FirstLine: 1289, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each", @@ -3355,8 +3392,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1226}}, - FirstLine: 1226, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1290}}, + FirstLine: 1290, Super: "", }, }, @@ -3375,8 +3412,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1232}}, - FirstLine: 1231, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1296}}, + FirstLine: 1295, Super: "", }, &bytecode.ISeq{ @@ -3391,8 +3428,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1238}, {PC: 4, Line: 259}}, - FirstLine: 1237, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1302}, {PC: 4, Line: 304}}, + FirstLine: 1301, Super: "", }, &bytecode.ISeq{ @@ -3407,8 +3444,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1242}, {PC: 8, Line: 259}}, - FirstLine: 1241, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1306}, {PC: 8, Line: 304}}, + FirstLine: 1305, Super: "", }, &bytecode.ISeq{ @@ -3423,8 +3460,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1248}, {PC: 4, Line: 1249}, {PC: 8, Line: 1250}}, - FirstLine: 1247, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1312}, {PC: 4, Line: 1313}, {PC: 8, Line: 1314}}, + FirstLine: 1311, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in |", @@ -3438,8 +3475,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1249}}, - FirstLine: 1249, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1313}}, + FirstLine: 1313, Super: "", }, }, @@ -3457,8 +3494,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1259}, {PC: 9, Line: 1260}}, - FirstLine: 1257, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1323}, {PC: 9, Line: 1324}}, + FirstLine: 1321, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in &", @@ -3472,8 +3509,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1259}}, - FirstLine: 1259, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1323}}, + FirstLine: 1323, Super: "", }, }, @@ -3491,8 +3528,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1267}, {PC: 4, Line: 1268}, {PC: 8, Line: 1269}}, - FirstLine: 1266, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1331}, {PC: 4, Line: 1332}, {PC: 8, Line: 1333}}, + FirstLine: 1330, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in -", @@ -3506,8 +3543,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1268}}, - FirstLine: 1268, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1332}}, + FirstLine: 1332, Super: "", }, }, @@ -3525,8 +3562,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1277}, {PC: 9, Line: 1278}}, - FirstLine: 1275, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1341}, {PC: 9, Line: 1342}}, + FirstLine: 1339, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ^", @@ -3540,8 +3577,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1277}}, - FirstLine: 1277, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1341}}, + FirstLine: 1341, Super: "", }, }, @@ -3559,8 +3596,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enums"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}, {PC: 3, Line: 109}}, - FirstLine: 1282, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1347}, {PC: 3, Line: 109}}, + FirstLine: 1346, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in merge", @@ -3574,8 +3611,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enum"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, - FirstLine: 1283, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1347}}, + FirstLine: 1347, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in merge", @@ -3589,8 +3626,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, - FirstLine: 1283, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1347}}, + FirstLine: 1347, Super: "", }, }, @@ -3611,8 +3648,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1289}, {PC: 4, Line: 109}}, - FirstLine: 1288, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1353}, {PC: 4, Line: 109}}, + FirstLine: 1352, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subtract", @@ -3626,8 +3663,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1289}}, - FirstLine: 1289, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1353}}, + FirstLine: 1353, Super: "", }, }, @@ -3650,8 +3687,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}, {PC: 4, Line: 1298}, {PC: 9, Line: 1299}, {PC: 12, Line: 1301}, {PC: 30, Line: 1302}, {PC: 35, Line: 1303}, {PC: 39, Line: 109}}, - FirstLine: 1296, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1361}, {PC: 4, Line: 1362}, {PC: 9, Line: 1363}, {PC: 12, Line: 1365}, {PC: 30, Line: 1366}, {PC: 35, Line: 1367}, {PC: 39, Line: 109}}, + FirstLine: 1360, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in replace", @@ -3665,8 +3702,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1299}}, - FirstLine: 1299, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1363}}, + FirstLine: 1363, Super: "", }, &bytecode.ISeq{ @@ -3681,8 +3718,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1303}}, - FirstLine: 1303, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1367}}, + FirstLine: 1367, Super: "", }, }, @@ -3699,8 +3736,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1311}, {PC: 4, Line: 1312}, {PC: 9, Line: 1313}, {PC: 12, Line: 109}}, - FirstLine: 1310, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1375}, {PC: 4, Line: 1376}, {PC: 9, Line: 1377}, {PC: 12, Line: 109}}, + FirstLine: 1374, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reset", @@ -3714,8 +3751,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1313}}, - FirstLine: 1313, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1377}}, + FirstLine: 1377, Super: "", }, }, @@ -3736,8 +3773,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1319}, {PC: 12, Line: 1320}, {PC: 23, Line: 1321}}, - FirstLine: 1318, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1383}, {PC: 12, Line: 1384}, {PC: 23, Line: 1385}}, + FirstLine: 1382, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subset?", @@ -3751,8 +3788,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1321}}, - FirstLine: 1321, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1385}}, + FirstLine: 1385, Super: "", }, }, @@ -3773,8 +3810,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1327}, {PC: 12, Line: 1328}, {PC: 23, Line: 1329}}, - FirstLine: 1326, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1391}, {PC: 12, Line: 1392}, {PC: 23, Line: 1393}}, + FirstLine: 1390, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_subset?", @@ -3788,8 +3825,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1329}}, - FirstLine: 1329, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1393}}, + FirstLine: 1393, Super: "", }, }, @@ -3810,8 +3847,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1335}, {PC: 12, Line: 1336}, {PC: 23, Line: 1337}}, - FirstLine: 1334, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1399}, {PC: 12, Line: 1400}, {PC: 23, Line: 1401}}, + FirstLine: 1398, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in superset?", @@ -3825,8 +3862,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1337}}, - FirstLine: 1337, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1401}}, + FirstLine: 1401, Super: "", }, }, @@ -3847,8 +3884,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1343}, {PC: 12, Line: 1344}, {PC: 23, Line: 1345}}, - FirstLine: 1342, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1407}, {PC: 12, Line: 1408}, {PC: 23, Line: 1409}}, + FirstLine: 1406, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_superset?", @@ -3862,8 +3899,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1345}}, - FirstLine: 1345, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1409}}, + FirstLine: 1409, Super: "", }, }, @@ -3886,8 +3923,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 5, Line: 259}, {PC: 10, Line: 1353}, {PC: 22, Line: 1354}, {PC: 28, Line: 259}, {PC: 35, Line: 1355}, {PC: 41, Line: 259}, {PC: 43, Line: 109}, {PC: 49, Line: 259}}, - FirstLine: 1351, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1416}, {PC: 5, Line: 304}, {PC: 10, Line: 1417}, {PC: 22, Line: 1418}, {PC: 28, Line: 304}, {PC: 35, Line: 1419}, {PC: 41, Line: 304}, {PC: 43, Line: 109}, {PC: 49, Line: 304}}, + FirstLine: 1415, Super: "", }, &bytecode.ISeq{ @@ -3905,8 +3942,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1363}, {PC: 9, Line: 1364}, {PC: 19, Line: 1365}, {PC: 31, Line: 1366}, {PC: 36, Line: 1368}, {PC: 48, Line: 1369}}, - FirstLine: 1362, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}, {PC: 9, Line: 1428}, {PC: 19, Line: 1429}, {PC: 31, Line: 1430}, {PC: 36, Line: 1432}, {PC: 48, Line: 1433}}, + FirstLine: 1426, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ==", @@ -3920,8 +3957,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1369}}, - FirstLine: 1369, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1433}}, + FirstLine: 1433, Super: "", }, }, @@ -3940,8 +3977,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1376}}, - FirstLine: 1375, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1440}}, + FirstLine: 1439, Super: "", }, &bytecode.ISeq{ @@ -3956,8 +3993,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1382}, {PC: 6, Line: 1383}, {PC: 9, Line: 1385}}, - FirstLine: 1381, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1446}, {PC: 6, Line: 1447}, {PC: 9, Line: 1449}}, + FirstLine: 1445, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in disjoint?", @@ -3971,8 +4008,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1383}}, - FirstLine: 1383, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1447}}, + FirstLine: 1447, Super: "", }, &bytecode.ISeq{ @@ -3987,8 +4024,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1385}}, - FirstLine: 1385, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1449}}, + FirstLine: 1449, Super: "", }, }, @@ -4006,8 +4043,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1390}}, - FirstLine: 1389, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1454}}, + FirstLine: 1453, Super: "", }, &bytecode.ISeq{ @@ -4024,8 +4061,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1396}, {PC: 10, Line: 1397}, {PC: 14, Line: 109}}, - FirstLine: 1395, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1460}, {PC: 10, Line: 1461}, {PC: 14, Line: 109}}, + FirstLine: 1459, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in delete_if", @@ -4037,8 +4074,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1396}}, - FirstLine: 1396, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1460}}, + FirstLine: 1460, Super: "", }, &bytecode.ISeq{ @@ -4053,8 +4090,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1397}}, - FirstLine: 1397, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1461}}, + FirstLine: 1461, Super: "", }, }, @@ -4074,8 +4111,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1402}, {PC: 10, Line: 1403}, {PC: 14, Line: 109}}, - FirstLine: 1401, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1466}, {PC: 10, Line: 1467}, {PC: 14, Line: 109}}, + FirstLine: 1465, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in keep_if", @@ -4087,8 +4124,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1402}}, - FirstLine: 1402, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1466}}, + FirstLine: 1466, Super: "", }, &bytecode.ISeq{ @@ -4103,8 +4140,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1403}}, - FirstLine: 1403, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1467}}, + FirstLine: 1467, Super: "", }, }, @@ -4124,8 +4161,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1410}, {PC: 10, Line: 1411}, {PC: 14, Line: 1412}, {PC: 18, Line: 1413}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, - FirstLine: 1409, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1474}, {PC: 10, Line: 1475}, {PC: 14, Line: 1476}, {PC: 18, Line: 1477}, {PC: 23, Line: 304}, {PC: 25, Line: 109}}, + FirstLine: 1473, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select!", @@ -4137,8 +4174,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1410}}, - FirstLine: 1410, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1474}}, + FirstLine: 1474, Super: "", }, }, @@ -4158,8 +4195,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1418}, {PC: 10, Line: 1419}, {PC: 14, Line: 1420}, {PC: 18, Line: 1421}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, - FirstLine: 1417, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1482}, {PC: 10, Line: 1483}, {PC: 14, Line: 1484}, {PC: 18, Line: 1485}, {PC: 23, Line: 304}, {PC: 25, Line: 109}}, + FirstLine: 1481, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject!", @@ -4171,8 +4208,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1418}}, - FirstLine: 1418, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1482}}, + FirstLine: 1482, Super: "", }, }, @@ -4192,8 +4229,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}, {PC: 10, Line: 1428}, {PC: 16, Line: 1429}, {PC: 20, Line: 1430}, {PC: 23, Line: 109}}, - FirstLine: 1426, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1491}, {PC: 10, Line: 1492}, {PC: 16, Line: 1493}, {PC: 20, Line: 1494}, {PC: 23, Line: 109}}, + FirstLine: 1490, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in map!", @@ -4205,8 +4242,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1427}}, - FirstLine: 1427, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1491}}, + FirstLine: 1491, Super: "", }, &bytecode.ISeq{ @@ -4221,8 +4258,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1430}}, - FirstLine: 1430, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1494}}, + FirstLine: 1494, Super: "", }, }, @@ -4242,8 +4279,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1438}, {PC: 10, Line: 1439}, {PC: 13, Line: 1440}, {PC: 16, Line: 1444}}, - FirstLine: 1437, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1502}, {PC: 10, Line: 1503}, {PC: 13, Line: 1504}, {PC: 16, Line: 1508}}, + FirstLine: 1501, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in classify", @@ -4255,8 +4292,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1438}}, - FirstLine: 1438, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1502}}, + FirstLine: 1502, Super: "", }, &bytecode.ISeq{ @@ -4271,8 +4308,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"o", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1441}, {PC: 5, Line: 1442}, {PC: 17, Line: 109}}, - FirstLine: 1440, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1505}, {PC: 5, Line: 1506}, {PC: 17, Line: 109}}, + FirstLine: 1504, Super: "", }, }, @@ -4293,8 +4330,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"func"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1457}, {PC: 10, Line: 1458}, {PC: 15, Line: 1459}, {PC: 19, Line: 1461}}, - FirstLine: 1456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1521}, {PC: 10, Line: 1522}, {PC: 15, Line: 1523}, {PC: 19, Line: 1525}}, + FirstLine: 1520, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in divide", @@ -4306,8 +4343,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1457}}, - FirstLine: 1457, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1521}}, + FirstLine: 1521, Super: "", }, }, @@ -4328,8 +4365,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 7, Locals: []string{"func", "items", "n", "parents", "root", "groups", "order"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1480}, {PC: 4, Line: 1481}, {PC: 8, Line: 1482}, {PC: 13, Line: 1484}, {PC: 17, Line: 1494}, {PC: 23, Line: 1509}, {PC: 26, Line: 1510}, {PC: 29, Line: 1511}, {PC: 32, Line: 1519}}, - FirstLine: 1479, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1544}, {PC: 4, Line: 1545}, {PC: 8, Line: 1546}, {PC: 13, Line: 1548}, {PC: 17, Line: 1558}, {PC: 23, Line: 1573}, {PC: 26, Line: 1574}, {PC: 29, Line: 1575}, {PC: 32, Line: 1583}}, + FirstLine: 1543, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in __divide_graph", @@ -4342,8 +4379,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1482}}, - FirstLine: 1482, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1546}}, + FirstLine: 1546, Super: "", }, &bytecode.ISeq{ @@ -4358,8 +4395,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"i", "r", "nxt", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1485}, {PC: 3, Line: 1486}, {PC: 17, Line: 1487}, {PC: 23, Line: 1488}, {PC: 28, Line: 1489}, {PC: 36, Line: 1490}, {PC: 42, Line: 1492}}, - FirstLine: 1484, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1549}, {PC: 3, Line: 1550}, {PC: 17, Line: 1551}, {PC: 23, Line: 1552}, {PC: 28, Line: 1553}, {PC: 36, Line: 1554}, {PC: 42, Line: 1556}}, + FirstLine: 1548, Super: "", }, &bytecode.ISeq{ @@ -4377,8 +4414,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"i", "item1"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1495}, {PC: 5, Line: 1496}}, - FirstLine: 1494, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1559}, {PC: 5, Line: 1560}}, + FirstLine: 1558, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4392,8 +4429,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"j", "item2", "ri", "rj", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1497}, {PC: 5, Line: 1501}, {PC: 23, Line: 1502}, {PC: 28, Line: 1503}, {PC: 33, Line: 1504}}, - FirstLine: 1496, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1561}, {PC: 5, Line: 1565}, {PC: 23, Line: 1566}, {PC: 28, Line: 1567}, {PC: 33, Line: 1568}}, + FirstLine: 1560, Super: "", }, }, @@ -4411,8 +4448,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"i", "r", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1512}, {PC: 5, Line: 1513}, {PC: 10, Line: 1514}, {PC: 18, Line: 1515}, {PC: 24, Line: 1517}}, - FirstLine: 1511, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1576}, {PC: 5, Line: 1577}, {PC: 10, Line: 1578}, {PC: 18, Line: 1579}, {PC: 24, Line: 1581}}, + FirstLine: 1575, Super: "", }, &bytecode.ISeq{ @@ -4428,7 +4465,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1519, + FirstLine: 1583, Super: "", }, }, @@ -4445,7 +4482,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1527, + FirstLine: 1591, Super: "", }, &bytecode.ISeq{ @@ -4458,8 +4495,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1532}, {PC: 3, Line: 1533}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, - FirstLine: 1531, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1596}, {PC: 3, Line: 1597}, {PC: 8, Line: 109}, {PC: 10, Line: 304}}, + FirstLine: 1595, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten!", @@ -4473,8 +4510,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1532}}, - FirstLine: 1532, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1596}}, + FirstLine: 1596, Super: "", }, }, @@ -4492,8 +4529,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "seen"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1542}, {PC: 5, Line: 1543}, {PC: 8, Line: 109}}, - FirstLine: 1542, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1606}, {PC: 5, Line: 1607}, {PC: 8, Line: 109}}, + FirstLine: 1606, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten_merge", @@ -4510,8 +4547,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"o", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1544}, {PC: 4, Line: 1545}, {PC: 16, Line: 1546}, {PC: 25, Line: 1547}, {PC: 30, Line: 1548}, {PC: 35, Line: 1550}}, - FirstLine: 1543, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1608}, {PC: 4, Line: 1609}, {PC: 16, Line: 1610}, {PC: 25, Line: 1611}, {PC: 30, Line: 1612}, {PC: 35, Line: 1614}}, + FirstLine: 1607, Super: "", }, }, @@ -4529,8 +4566,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sep"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1558}, {PC: 2, Line: 259}, {PC: 5, Line: 1559}}, - FirstLine: 1558, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1622}, {PC: 2, Line: 304}, {PC: 5, Line: 1623}}, + FirstLine: 1622, Super: "", }, &bytecode.ISeq{ @@ -4545,8 +4582,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"klass", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1579}, {PC: 5, Line: 1580}, {PC: 25, Line: 109}, {PC: 30, Line: 1581}, {PC: 32, Line: 109}}, - FirstLine: 1579, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1643}, {PC: 5, Line: 1644}, {PC: 25, Line: 109}, {PC: 30, Line: 1645}, {PC: 32, Line: 109}}, + FirstLine: 1643, Super: "", }, }, @@ -4562,8 +4599,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1603}, {PC: 2, Line: 1727}, {PC: 4, Line: 1784}, {PC: 6, Line: 1788}, {PC: 8, Line: 1794}, {PC: 10, Line: 1798}}, - FirstLine: 1599, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1667}, {PC: 2, Line: 1791}, {PC: 4, Line: 1848}, {PC: 6, Line: 1852}, {PC: 8, Line: 1858}, {PC: 10, Line: 1862}}, + FirstLine: 1663, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4581,8 +4618,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1604}, {PC: 4, Line: 1606}, {PC: 7, Line: 1607}, {PC: 16, Line: 1611}, {PC: 18, Line: 1616}, {PC: 20, Line: 1626}, {PC: 24, Line: 1628}, {PC: 26, Line: 1636}, {PC: 28, Line: 1640}, {PC: 30, Line: 1646}, {PC: 32, Line: 1653}, {PC: 34, Line: 1657}, {PC: 36, Line: 1666}, {PC: 38, Line: 1674}, {PC: 40, Line: 1694}, {PC: 42, Line: 1700}, {PC: 44, Line: 1704}, {PC: 46, Line: 1708}, {PC: 49, Line: 1712}}, - FirstLine: 1603, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1668}, {PC: 4, Line: 1670}, {PC: 7, Line: 1671}, {PC: 16, Line: 1675}, {PC: 18, Line: 1680}, {PC: 20, Line: 1690}, {PC: 24, Line: 1692}, {PC: 26, Line: 1700}, {PC: 28, Line: 1704}, {PC: 30, Line: 1710}, {PC: 32, Line: 1717}, {PC: 34, Line: 1721}, {PC: 36, Line: 1730}, {PC: 38, Line: 1738}, {PC: 40, Line: 1758}, {PC: 42, Line: 1764}, {PC: 44, Line: 1768}, {PC: 46, Line: 1772}, {PC: 49, Line: 1776}}, + FirstLine: 1667, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4596,8 +4633,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1612}, {PC: 8, Line: 1613}}, - FirstLine: 1611, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1676}, {PC: 8, Line: 1677}}, + FirstLine: 1675, Super: "", }, &bytecode.ISeq{ @@ -4612,8 +4649,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1617}, {PC: 4, Line: 1618}, {PC: 9, Line: 259}, {PC: 11, Line: 1622}}, - FirstLine: 1616, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1681}, {PC: 4, Line: 1682}, {PC: 9, Line: 304}, {PC: 11, Line: 1686}}, + FirstLine: 1680, Super: "", }, &bytecode.ISeq{ @@ -4635,8 +4672,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1630}, {PC: 17, Line: 1632}, {PC: 25, Line: 1633}}, - FirstLine: 1628, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1694}, {PC: 17, Line: 1696}, {PC: 25, Line: 1697}}, + FirstLine: 1692, Super: "", }, &bytecode.ISeq{ @@ -4649,8 +4686,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1637}}, - FirstLine: 1636, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1701}}, + FirstLine: 1700, Super: "", }, &bytecode.ISeq{ @@ -4668,8 +4705,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1641}, {PC: 1, Line: 109}, {PC: 6, Line: 1641}}, - FirstLine: 1640, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1705}, {PC: 1, Line: 109}, {PC: 6, Line: 1705}}, + FirstLine: 1704, Super: "", }, &bytecode.ISeq{ @@ -4682,8 +4719,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1647}}, - FirstLine: 1646, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1711}}, + FirstLine: 1710, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4697,8 +4734,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1648}}, - FirstLine: 1647, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1712}}, + FirstLine: 1711, Super: "", }, }, @@ -4714,8 +4751,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1654}}, - FirstLine: 1653, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1718}}, + FirstLine: 1717, Super: "", }, &bytecode.ISeq{ @@ -4732,8 +4769,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}, {PC: 4, Line: 109}, {PC: 9, Line: 1659}, {PC: 13, Line: 1660}, {PC: 31, Line: 109}}, - FirstLine: 1657, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1722}, {PC: 4, Line: 109}, {PC: 9, Line: 1723}, {PC: 13, Line: 1724}, {PC: 31, Line: 109}}, + FirstLine: 1721, Super: "", }, &bytecode.ISeq{ @@ -4752,8 +4789,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1667}, {PC: 5, Line: 1668}, {PC: 23, Line: 1669}, {PC: 33, Line: 1670}, {PC: 45, Line: 109}}, - FirstLine: 1666, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1731}, {PC: 5, Line: 1732}, {PC: 23, Line: 1733}, {PC: 33, Line: 1734}, {PC: 45, Line: 109}}, + FirstLine: 1730, Super: "", }, &bytecode.ISeq{ @@ -4772,8 +4809,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 8, Locals: []string{"other", "lhs", "rhs", "limit", "i", "l", "r", "c"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1676}, {PC: 9, Line: 259}, {PC: 14, Line: 1677}, {PC: 18, Line: 1678}, {PC: 22, Line: 1679}, {PC: 35, Line: 1680}, {PC: 38, Line: 1681}, {PC: 42, Line: 1682}, {PC: 47, Line: 1683}, {PC: 52, Line: 1685}, {PC: 60, Line: 1686}, {PC: 68, Line: 1687}, {PC: 74, Line: 1688}, {PC: 84, Line: 1689}, {PC: 92, Line: 1691}}, - FirstLine: 1674, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1740}, {PC: 9, Line: 304}, {PC: 14, Line: 1741}, {PC: 18, Line: 1742}, {PC: 22, Line: 1743}, {PC: 35, Line: 1744}, {PC: 38, Line: 1745}, {PC: 42, Line: 1746}, {PC: 47, Line: 1747}, {PC: 52, Line: 1749}, {PC: 60, Line: 1750}, {PC: 68, Line: 1751}, {PC: 74, Line: 1752}, {PC: 84, Line: 1753}, {PC: 92, Line: 1755}}, + FirstLine: 1738, Super: "", }, &bytecode.ISeq{ @@ -4791,8 +4828,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1696}, {PC: 14, Line: 109}}, - FirstLine: 1694, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1760}, {PC: 14, Line: 109}}, + FirstLine: 1758, Super: "", }, &bytecode.ISeq{ @@ -4807,8 +4844,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1701}}, - FirstLine: 1700, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1765}}, + FirstLine: 1764, Super: "", }, &bytecode.ISeq{ @@ -4821,8 +4858,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1705}}, - FirstLine: 1704, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1769}}, + FirstLine: 1768, Super: "", }, &bytecode.ISeq{ @@ -4841,8 +4878,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}, {PC: 10, Line: 1714}, {PC: 24, Line: 1716}, {PC: 32, Line: 1718}, {PC: 34, Line: 1720}}, - FirstLine: 1712, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1777}, {PC: 10, Line: 1778}, {PC: 24, Line: 1780}, {PC: 32, Line: 1782}, {PC: 34, Line: 1784}}, + FirstLine: 1776, Super: "", }, }, @@ -4870,8 +4907,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}, {PC: 24, Line: 1741}, {PC: 34, Line: 1743}, {PC: 36, Line: 1747}, {PC: 38, Line: 1751}, {PC: 42, Line: 1753}, {PC: 44, Line: 1761}, {PC: 46, Line: 1770}, {PC: 48, Line: 1774}, {PC: 50, Line: 1775}, {PC: 52, Line: 1777}}, - FirstLine: 1727, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1792}, {PC: 24, Line: 1805}, {PC: 34, Line: 1807}, {PC: 36, Line: 1811}, {PC: 38, Line: 1815}, {PC: 42, Line: 1817}, {PC: 44, Line: 1825}, {PC: 46, Line: 1834}, {PC: 48, Line: 1838}, {PC: 50, Line: 1839}, {PC: 52, Line: 1841}}, + FirstLine: 1791, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4884,8 +4921,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1729}}, - FirstLine: 1729, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1793}}, + FirstLine: 1793, Super: "", }, &bytecode.ISeq{ @@ -4899,8 +4936,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1730}}, - FirstLine: 1730, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1794}}, + FirstLine: 1794, Super: "", }, &bytecode.ISeq{ @@ -4914,8 +4951,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1731}}, - FirstLine: 1731, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1795}}, + FirstLine: 1795, Super: "", }, &bytecode.ISeq{ @@ -4929,8 +4966,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1732}}, - FirstLine: 1732, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1796}}, + FirstLine: 1796, Super: "", }, &bytecode.ISeq{ @@ -4944,8 +4981,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1733}}, - FirstLine: 1733, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1797}}, + FirstLine: 1797, Super: "", }, &bytecode.ISeq{ @@ -4959,8 +4996,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1734}}, - FirstLine: 1734, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1798}}, + FirstLine: 1798, Super: "", }, &bytecode.ISeq{ @@ -4975,8 +5012,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1735}}, - FirstLine: 1735, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1799}}, + FirstLine: 1799, Super: "", }, &bytecode.ISeq{ @@ -4991,8 +5028,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, - FirstLine: 1743, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1808}}, + FirstLine: 1807, Super: "", }, &bytecode.ISeq{ @@ -5008,8 +5045,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1748}}, - FirstLine: 1747, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1812}}, + FirstLine: 1811, Super: "", }, &bytecode.ISeq{ @@ -5027,8 +5064,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1754}, {PC: 4, Line: 1755}, {PC: 13, Line: 1756}}, - FirstLine: 1753, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1818}, {PC: 4, Line: 1819}, {PC: 13, Line: 1820}}, + FirstLine: 1817, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5043,7 +5080,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1756, + FirstLine: 1820, Super: "", }, }, @@ -5068,8 +5105,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1762}, {PC: 11, Line: 1763}, {PC: 17, Line: 1764}, {PC: 32, Line: 1765}, {PC: 41, Line: 1766}}, - FirstLine: 1761, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1826}, {PC: 11, Line: 1827}, {PC: 17, Line: 1828}, {PC: 32, Line: 1829}, {PC: 41, Line: 1830}}, + FirstLine: 1825, Super: "", }, &bytecode.ISeq{ @@ -5084,8 +5121,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1771}, {PC: 5, Line: 1772}}, - FirstLine: 1770, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1835}, {PC: 5, Line: 1836}}, + FirstLine: 1834, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5099,8 +5136,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1772}}, - FirstLine: 1772, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1836}}, + FirstLine: 1836, Super: "", }, }, @@ -5119,8 +5156,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, - FirstLine: 1777, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1842}}, + FirstLine: 1841, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5137,8 +5174,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, - FirstLine: 1778, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1842}}, + FirstLine: 1842, Super: "", }, }, @@ -5157,8 +5194,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1785}}, - FirstLine: 1784, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1849}}, + FirstLine: 1848, Super: "", }, &bytecode.ISeq{ @@ -5170,8 +5207,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1789}}, - FirstLine: 1788, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1853}}, + FirstLine: 1852, Super: "", }, &bytecode.ISeq{ @@ -5183,8 +5220,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1794}}, - FirstLine: 1794, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}}, + FirstLine: 1858, Super: "", }, &bytecode.ISeq{ @@ -5197,8 +5234,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1799}}, - FirstLine: 1798, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}}, + FirstLine: 1862, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5209,8 +5246,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1800}}, - FirstLine: 1799, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1864}}, + FirstLine: 1863, Super: "", }, }, @@ -5229,8 +5266,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}, {PC: 2, Line: 1827}, {PC: 4, Line: 1831}, {PC: 6, Line: 1835}, {PC: 8, Line: 1839}, {PC: 10, Line: 1845}, {PC: 12, Line: 1849}, {PC: 14, Line: 1853}, {PC: 16, Line: 1857}, {PC: 18, Line: 1862}, {PC: 20, Line: 1874}, {PC: 22, Line: 1877}, {PC: 24, Line: 1879}, {PC: 26, Line: 1883}, {PC: 28, Line: 1886}}, - FirstLine: 1819, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 2, Line: 1891}, {PC: 4, Line: 1895}, {PC: 6, Line: 1899}, {PC: 8, Line: 1903}, {PC: 10, Line: 1909}, {PC: 12, Line: 1913}, {PC: 14, Line: 1917}, {PC: 16, Line: 1921}, {PC: 18, Line: 1926}, {PC: 20, Line: 1938}, {PC: 22, Line: 1941}, {PC: 24, Line: 1943}, {PC: 26, Line: 1947}, {PC: 28, Line: 1950}}, + FirstLine: 1883, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5244,8 +5281,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}, {PC: 2, Line: 259}, {PC: 5, Line: 1821}, {PC: 8, Line: 1822}, {PC: 10, Line: 1823}}, - FirstLine: 1820, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 2, Line: 304}, {PC: 5, Line: 1885}, {PC: 8, Line: 1886}, {PC: 10, Line: 1887}}, + FirstLine: 1884, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5259,8 +5296,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}}, - FirstLine: 1823, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1887}}, + FirstLine: 1887, Super: "", }, }, @@ -5278,8 +5315,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1828}}, - FirstLine: 1827, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1892}}, + FirstLine: 1891, Super: "", }, &bytecode.ISeq{ @@ -5294,8 +5331,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1832}}, - FirstLine: 1831, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}}, + FirstLine: 1895, Super: "", }, &bytecode.ISeq{ @@ -5308,8 +5345,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1836}}, - FirstLine: 1835, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1900}}, + FirstLine: 1899, Super: "", }, &bytecode.ISeq{ @@ -5325,8 +5362,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 10, Line: 1841}, {PC: 13, Line: 109}}, - FirstLine: 1839, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1904}, {PC: 10, Line: 1905}, {PC: 13, Line: 109}}, + FirstLine: 1903, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5339,8 +5376,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, - FirstLine: 1841, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1905}}, + FirstLine: 1905, Super: "", }, }, @@ -5356,8 +5393,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1846}}, - FirstLine: 1845, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1910}}, + FirstLine: 1909, Super: "", }, &bytecode.ISeq{ @@ -5372,8 +5409,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1850}}, - FirstLine: 1849, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1914}}, + FirstLine: 1913, Super: "", }, &bytecode.ISeq{ @@ -5388,8 +5425,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1854}}, - FirstLine: 1853, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1918}}, + FirstLine: 1917, Super: "", }, &bytecode.ISeq{ @@ -5407,8 +5444,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1857}, {PC: 5, Line: 1858}, {PC: 9, Line: 1859}}, - FirstLine: 1857, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1921}, {PC: 5, Line: 1922}, {PC: 9, Line: 1923}}, + FirstLine: 1921, Super: "", }, &bytecode.ISeq{ @@ -5431,8 +5468,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}, {PC: 4, Line: 1864}, {PC: 8, Line: 1865}, {PC: 26, Line: 1866}, {PC: 44, Line: 1868}, {PC: 48, Line: 1870}}, - FirstLine: 1862, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1927}, {PC: 4, Line: 1928}, {PC: 8, Line: 1929}, {PC: 26, Line: 1930}, {PC: 44, Line: 1932}, {PC: 48, Line: 1934}}, + FirstLine: 1926, Super: "", }, &bytecode.ISeq{ @@ -5447,8 +5484,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1875}, {PC: 9, Line: 259}}, - FirstLine: 1874, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1939}, {PC: 9, Line: 304}}, + FirstLine: 1938, Super: "", }, &bytecode.ISeq{ @@ -5463,8 +5500,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}, {PC: 5, Line: 1880}}, - FirstLine: 1879, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1943}, {PC: 5, Line: 1944}}, + FirstLine: 1943, Super: "", }, &bytecode.ISeq{ @@ -5477,8 +5514,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}}, - FirstLine: 1883, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1948}}, + FirstLine: 1947, Super: "", }, }, @@ -5494,8 +5531,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1901}, {PC: 2, Line: 1909}, {PC: 4, Line: 1912}, {PC: 6, Line: 1918}}, - FirstLine: 1898, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1965}, {PC: 2, Line: 1973}, {PC: 4, Line: 1976}, {PC: 6, Line: 1982}}, + FirstLine: 1962, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5509,8 +5546,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1901}, {PC: 5, Line: 1902}, {PC: 9, Line: 1903}, {PC: 13, Line: 1907}}, - FirstLine: 1901, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1965}, {PC: 5, Line: 1966}, {PC: 9, Line: 1967}, {PC: 13, Line: 1971}}, + FirstLine: 1965, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5524,8 +5561,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1904}, {PC: 1, Line: 109}, {PC: 6, Line: 1905}}, - FirstLine: 1903, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1968}, {PC: 1, Line: 109}, {PC: 6, Line: 1969}}, + FirstLine: 1967, Super: "", }, }, @@ -5543,8 +5580,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}}, - FirstLine: 1912, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1977}}, + FirstLine: 1976, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5558,8 +5595,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}}, - FirstLine: 1913, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1977}}, + FirstLine: 1977, Super: "", }, }, @@ -5580,8 +5617,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1919}, {PC: 4, Line: 1920}, {PC: 9, Line: 1922}}, - FirstLine: 1918, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1983}, {PC: 4, Line: 1984}, {PC: 9, Line: 1986}}, + FirstLine: 1982, Super: "", }, }, @@ -5597,8 +5634,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1930}, {PC: 2, Line: 1938}, {PC: 4, Line: 1940}}, - FirstLine: 1929, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1994}, {PC: 2, Line: 2002}, {PC: 4, Line: 2004}}, + FirstLine: 1993, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5612,8 +5649,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1930}, {PC: 5, Line: 1931}, {PC: 9, Line: 1932}, {PC: 13, Line: 1936}}, - FirstLine: 1930, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1994}, {PC: 5, Line: 1995}, {PC: 9, Line: 1996}, {PC: 13, Line: 2000}}, + FirstLine: 1994, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5627,8 +5664,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 1, Line: 109}, {PC: 6, Line: 1934}}, - FirstLine: 1932, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1997}, {PC: 1, Line: 109}, {PC: 6, Line: 1998}}, + FirstLine: 1996, Super: "", }, }, @@ -5646,8 +5683,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1941}}, - FirstLine: 1940, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2005}}, + FirstLine: 2004, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5661,8 +5698,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1941}}, - FirstLine: 1941, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2005}}, + FirstLine: 2005, Super: "", }, }, @@ -5681,8 +5718,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1950}, {PC: 2, Line: 1956}, {PC: 4, Line: 1965}, {PC: 6, Line: 1969}, {PC: 8, Line: 1973}, {PC: 10, Line: 1978}, {PC: 12, Line: 1982}}, - FirstLine: 1949, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2014}, {PC: 2, Line: 2020}, {PC: 4, Line: 2029}, {PC: 6, Line: 2033}, {PC: 8, Line: 2037}, {PC: 10, Line: 2042}, {PC: 12, Line: 2046}}, + FirstLine: 2013, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5696,8 +5733,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1951}}, - FirstLine: 1950, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2015}}, + FirstLine: 2014, Super: "", }, &bytecode.ISeq{ @@ -5712,8 +5749,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}, {PC: 4, Line: 1958}, {PC: 8, Line: 1959}, {PC: 19, Line: 1961}}, - FirstLine: 1956, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2021}, {PC: 4, Line: 2022}, {PC: 8, Line: 2023}, {PC: 19, Line: 2025}}, + FirstLine: 2020, Super: "", }, &bytecode.ISeq{ @@ -5728,8 +5765,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1965}, {PC: 5, Line: 1966}}, - FirstLine: 1965, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2029}, {PC: 5, Line: 2030}}, + FirstLine: 2029, Super: "", }, &bytecode.ISeq{ @@ -5744,8 +5781,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1969}, {PC: 5, Line: 1970}}, - FirstLine: 1969, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2033}, {PC: 5, Line: 2034}}, + FirstLine: 2033, Super: "", }, &bytecode.ISeq{ @@ -5760,8 +5797,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1974}, {PC: 1, Line: 109}, {PC: 9, Line: 1975}}, - FirstLine: 1973, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2038}, {PC: 1, Line: 109}, {PC: 9, Line: 2039}}, + FirstLine: 2037, Super: "", }, &bytecode.ISeq{ @@ -5778,8 +5815,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1979}, {PC: 3, Line: 109}}, - FirstLine: 1978, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2043}, {PC: 3, Line: 109}}, + FirstLine: 2042, Super: "", }, &bytecode.ISeq{ @@ -5798,8 +5835,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1983}, {PC: 3, Line: 109}}, - FirstLine: 1982, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2047}, {PC: 3, Line: 109}}, + FirstLine: 2046, Super: "", }, }, @@ -5815,8 +5852,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1990}, {PC: 2, Line: 1994}}, - FirstLine: 1989, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}, {PC: 2, Line: 2058}}, + FirstLine: 2053, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5828,8 +5865,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1991}}, - FirstLine: 1990, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2055}}, + FirstLine: 2054, Super: "", }, &bytecode.ISeq{ @@ -5844,8 +5881,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1995}}, - FirstLine: 1994, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2059}}, + FirstLine: 2058, Super: "", }, }, @@ -5888,8 +5925,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2003}, {PC: 5, Line: 2004}, {PC: 8, Line: 2022}, {PC: 34, Line: 2029}, {PC: 38, Line: 2035}}, - FirstLine: 2002, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2067}, {PC: 5, Line: 2068}, {PC: 8, Line: 2086}, {PC: 34, Line: 2093}, {PC: 38, Line: 2099}}, + FirstLine: 2066, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5901,8 +5938,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2005}, {PC: 2, Line: 2009}}, - FirstLine: 2004, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2069}, {PC: 2, Line: 2073}}, + FirstLine: 2068, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5914,8 +5951,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2006}}, - FirstLine: 2005, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2070}}, + FirstLine: 2069, Super: "", }, &bytecode.ISeq{ @@ -5930,8 +5967,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2010}}, - FirstLine: 2009, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2074}}, + FirstLine: 2073, Super: "", }, }, @@ -5952,8 +5989,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2030}, {PC: 9, Line: 2031}}, - FirstLine: 2029, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2094}, {PC: 9, Line: 2095}}, + FirstLine: 2093, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5967,8 +6004,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2032}}, - FirstLine: 2031, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2096}}, + FirstLine: 2095, Super: "", }, }, @@ -5990,8 +6027,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2043}, {PC: 4, Line: 2044}, {PC: 7, Line: 2046}, {PC: 9, Line: 2052}, {PC: 11, Line: 2055}, {PC: 13, Line: 2057}, {PC: 15, Line: 2061}, {PC: 17, Line: 2065}, {PC: 19, Line: 2070}, {PC: 21, Line: 2073}, {PC: 23, Line: 2075}, {PC: 25, Line: 2080}, {PC: 27, Line: 2090}, {PC: 29, Line: 2094}, {PC: 31, Line: 2098}, {PC: 33, Line: 2105}, {PC: 35, Line: 2122}, {PC: 37, Line: 2124}, {PC: 39, Line: 2132}, {PC: 41, Line: 2136}, {PC: 43, Line: 2139}, {PC: 45, Line: 2141}, {PC: 47, Line: 2145}, {PC: 49, Line: 2149}, {PC: 51, Line: 2156}, {PC: 53, Line: 2162}, {PC: 55, Line: 2169}, {PC: 57, Line: 2173}, {PC: 59, Line: 2181}, {PC: 61, Line: 2190}, {PC: 63, Line: 2194}, {PC: 65, Line: 2198}, {PC: 67, Line: 2202}, {PC: 69, Line: 2206}, {PC: 71, Line: 2210}, {PC: 73, Line: 2214}}, - FirstLine: 2042, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2107}, {PC: 4, Line: 2108}, {PC: 7, Line: 2110}, {PC: 9, Line: 2116}, {PC: 11, Line: 2119}, {PC: 13, Line: 2121}, {PC: 15, Line: 2125}, {PC: 17, Line: 2129}, {PC: 19, Line: 2134}, {PC: 21, Line: 2137}, {PC: 23, Line: 2139}, {PC: 25, Line: 2144}, {PC: 27, Line: 2154}, {PC: 29, Line: 2158}, {PC: 31, Line: 2162}, {PC: 33, Line: 2169}, {PC: 35, Line: 2186}, {PC: 37, Line: 2188}, {PC: 39, Line: 2196}, {PC: 41, Line: 2200}, {PC: 43, Line: 2203}, {PC: 45, Line: 2205}, {PC: 47, Line: 2209}, {PC: 49, Line: 2213}, {PC: 51, Line: 2220}, {PC: 53, Line: 2226}, {PC: 55, Line: 2233}, {PC: 57, Line: 2237}, {PC: 59, Line: 2245}, {PC: 61, Line: 2254}, {PC: 63, Line: 2258}, {PC: 65, Line: 2262}, {PC: 67, Line: 2266}, {PC: 69, Line: 2270}, {PC: 71, Line: 2274}, {PC: 73, Line: 2278}}, + FirstLine: 2106, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6008,8 +6045,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2047}, {PC: 10, Line: 2048}, {PC: 22, Line: 2049}}, - FirstLine: 2046, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2111}, {PC: 10, Line: 2112}, {PC: 22, Line: 2113}}, + FirstLine: 2110, Super: "", }, &bytecode.ISeq{ @@ -6022,8 +6059,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2053}}, - FirstLine: 2052, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2117}}, + FirstLine: 2116, Super: "", }, &bytecode.ISeq{ @@ -6040,8 +6077,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2058}}, - FirstLine: 2057, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2122}}, + FirstLine: 2121, Super: "", }, &bytecode.ISeq{ @@ -6054,8 +6091,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2062}}, - FirstLine: 2061, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2126}}, + FirstLine: 2125, Super: "", }, &bytecode.ISeq{ @@ -6068,8 +6105,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2066}, {PC: 3, Line: 2067}}, - FirstLine: 2065, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2130}, {PC: 3, Line: 2131}}, + FirstLine: 2129, Super: "", }, &bytecode.ISeq{ @@ -6084,8 +6121,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2071}}, - FirstLine: 2070, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2135}}, + FirstLine: 2134, Super: "", }, &bytecode.ISeq{ @@ -6100,8 +6137,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2076}, {PC: 5, Line: 259}, {PC: 10, Line: 2077}}, - FirstLine: 2075, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2140}, {PC: 5, Line: 304}, {PC: 10, Line: 2141}}, + FirstLine: 2139, Super: "", }, &bytecode.ISeq{ @@ -6114,8 +6151,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2081}}, - FirstLine: 2080, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2145}}, + FirstLine: 2144, Super: "", }, &bytecode.ISeq{ @@ -6128,8 +6165,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2091}}, - FirstLine: 2090, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2155}}, + FirstLine: 2154, Super: "", }, &bytecode.ISeq{ @@ -6142,8 +6179,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2095}}, - FirstLine: 2094, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2159}}, + FirstLine: 2158, Super: "", }, &bytecode.ISeq{ @@ -6156,8 +6193,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2099}}, - FirstLine: 2098, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2163}}, + FirstLine: 2162, Super: "", }, &bytecode.ISeq{ @@ -6172,8 +6209,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2106}, {PC: 12, Line: 2107}}, - FirstLine: 2105, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2170}, {PC: 12, Line: 2171}}, + FirstLine: 2169, Super: "", }, &bytecode.ISeq{ @@ -6188,8 +6225,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2126}, {PC: 6, Line: 2127}}, - FirstLine: 2124, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2190}, {PC: 6, Line: 2191}}, + FirstLine: 2188, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6202,8 +6239,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2126}}, - FirstLine: 2126, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2190}}, + FirstLine: 2190, Super: "", }, }, @@ -6224,8 +6261,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2132}, {PC: 5, Line: 2133}}, - FirstLine: 2132, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2196}, {PC: 5, Line: 2197}}, + FirstLine: 2196, Super: "", }, &bytecode.ISeq{ @@ -6238,8 +6275,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2137}}, - FirstLine: 2136, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2201}}, + FirstLine: 2200, Super: "", }, &bytecode.ISeq{ @@ -6252,8 +6289,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2142}}, - FirstLine: 2141, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2206}}, + FirstLine: 2205, Super: "", }, &bytecode.ISeq{ @@ -6266,8 +6303,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2146}}, - FirstLine: 2145, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2210}}, + FirstLine: 2209, Super: "", }, &bytecode.ISeq{ @@ -6283,8 +6320,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2150}, {PC: 10, Line: 2151}}, - FirstLine: 2149, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2214}, {PC: 10, Line: 2215}}, + FirstLine: 2213, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6297,8 +6334,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2151}}, - FirstLine: 2151, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2215}}, + FirstLine: 2215, Super: "", }, }, @@ -6317,8 +6354,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}, {PC: 10, Line: 2158}, {PC: 15, Line: 109}}, - FirstLine: 2156, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2221}, {PC: 10, Line: 2222}, {PC: 15, Line: 109}}, + FirstLine: 2220, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6332,8 +6369,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2158}}, - FirstLine: 2158, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2222}}, + FirstLine: 2222, Super: "", }, }, @@ -6352,8 +6389,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2163}, {PC: 10, Line: 2164}, {PC: 15, Line: 109}}, - FirstLine: 2162, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2227}, {PC: 10, Line: 2228}, {PC: 15, Line: 109}}, + FirstLine: 2226, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6367,8 +6404,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2164}}, - FirstLine: 2164, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2228}}, + FirstLine: 2228, Super: "", }, }, @@ -6384,8 +6421,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2170}}, - FirstLine: 2169, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2234}}, + FirstLine: 2233, Super: "", }, &bytecode.ISeq{ @@ -6400,8 +6437,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2174}}, - FirstLine: 2173, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2238}}, + FirstLine: 2237, Super: "", }, &bytecode.ISeq{ @@ -6416,8 +6453,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2182}, {PC: 12, Line: 2183}}, - FirstLine: 2181, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2246}, {PC: 12, Line: 2247}}, + FirstLine: 2245, Super: "", }, &bytecode.ISeq{ @@ -6432,8 +6469,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2191}}, - FirstLine: 2190, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2255}}, + FirstLine: 2254, Super: "", }, &bytecode.ISeq{ @@ -6448,8 +6485,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2195}}, - FirstLine: 2194, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2259}}, + FirstLine: 2258, Super: "", }, &bytecode.ISeq{ @@ -6464,8 +6501,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2199}}, - FirstLine: 2198, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2263}}, + FirstLine: 2262, Super: "", }, &bytecode.ISeq{ @@ -6478,8 +6515,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2203}}, - FirstLine: 2202, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2267}}, + FirstLine: 2266, Super: "", }, &bytecode.ISeq{ @@ -6492,8 +6529,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2207}}, - FirstLine: 2206, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2271}}, + FirstLine: 2270, Super: "", }, &bytecode.ISeq{ @@ -6506,8 +6543,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2211}}, - FirstLine: 2210, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2275}}, + FirstLine: 2274, Super: "", }, &bytecode.ISeq{ @@ -6522,8 +6559,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2215}}, - FirstLine: 2214, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, + FirstLine: 2278, Super: "", }, }, @@ -6539,8 +6576,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2225}, {PC: 2, Line: 2236}}, - FirstLine: 2223, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2289}, {PC: 2, Line: 2300}}, + FirstLine: 2287, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6552,8 +6589,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2228}}, - FirstLine: 2225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2292}}, + FirstLine: 2289, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6565,8 +6602,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2229}}, - FirstLine: 2228, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2293}}, + FirstLine: 2292, Super: "", }, }, @@ -6588,8 +6625,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2237}, {PC: 4, Line: 2238}}, - FirstLine: 2236, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2301}, {PC: 4, Line: 2302}}, + FirstLine: 2300, Super: "", }, }, @@ -6611,8 +6648,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2268}, {PC: 5, Line: 2269}, {PC: 10, Line: 2275}, {PC: 12, Line: 2288}, {PC: 14, Line: 2295}, {PC: 16, Line: 2304}, {PC: 18, Line: 2308}, {PC: 21, Line: 2312}}, - FirstLine: 2266, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2332}, {PC: 5, Line: 2333}, {PC: 10, Line: 2339}, {PC: 12, Line: 2352}, {PC: 14, Line: 2359}, {PC: 16, Line: 2368}, {PC: 18, Line: 2372}, {PC: 21, Line: 2376}}, + FirstLine: 2330, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6633,8 +6670,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2275}, {PC: 2, Line: 259}, {PC: 13, Line: 2277}, {PC: 16, Line: 2278}, {PC: 19, Line: 2282}}, - FirstLine: 2275, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}, {PC: 2, Line: 304}, {PC: 13, Line: 2341}, {PC: 16, Line: 2342}, {PC: 19, Line: 2346}}, + FirstLine: 2339, Super: "", }, &bytecode.ISeq{ @@ -6652,8 +6689,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2288}, {PC: 6, Line: 2289}}, - FirstLine: 2288, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2352}, {PC: 6, Line: 2353}}, + FirstLine: 2352, Super: "", }, &bytecode.ISeq{ @@ -6668,8 +6705,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2296}, {PC: 4, Line: 2297}, {PC: 7, Line: 2300}}, - FirstLine: 2295, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 4, Line: 2361}, {PC: 7, Line: 2364}}, + FirstLine: 2359, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6683,8 +6720,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2298}}, - FirstLine: 2297, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2362}}, + FirstLine: 2361, Super: "", }, }, @@ -6702,8 +6739,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2304}, {PC: 6, Line: 2305}}, - FirstLine: 2304, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2368}, {PC: 6, Line: 2369}}, + FirstLine: 2368, Super: "", }, &bytecode.ISeq{ @@ -6715,8 +6752,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2313}}, - FirstLine: 2312, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2377}}, + FirstLine: 2376, Super: "", }, }, @@ -6732,8 +6769,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2333}, {PC: 2, Line: 2402}}, - FirstLine: 2332, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2397}, {PC: 2, Line: 2466}}, + FirstLine: 2396, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6745,8 +6782,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2336}, {PC: 2, Line: 2343}, {PC: 4, Line: 2350}, {PC: 6, Line: 2359}, {PC: 8, Line: 2372}}, - FirstLine: 2333, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2400}, {PC: 2, Line: 2407}, {PC: 4, Line: 2414}, {PC: 6, Line: 2423}, {PC: 8, Line: 2436}}, + FirstLine: 2397, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6761,8 +6798,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2337}, {PC: 4, Line: 2338}}, - FirstLine: 2336, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2401}, {PC: 4, Line: 2402}}, + FirstLine: 2400, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6776,8 +6813,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}}, - FirstLine: 2338, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2403}}, + FirstLine: 2402, Super: "", }, }, @@ -6795,8 +6832,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2344}}, - FirstLine: 2343, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2408}}, + FirstLine: 2407, Super: "", }, &bytecode.ISeq{ @@ -6823,8 +6860,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2351}}, - FirstLine: 2350, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2415}}, + FirstLine: 2414, Super: "", }, &bytecode.ISeq{ @@ -6846,8 +6883,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 14, Line: 2361}, {PC: 19, Line: 1}, {PC: 27, Line: 2362}, {PC: 32, Line: 1}, {PC: 44, Line: 2364}, {PC: 45, Line: 1}}, - FirstLine: 2359, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2424}, {PC: 14, Line: 2425}, {PC: 19, Line: 1}, {PC: 27, Line: 2426}, {PC: 32, Line: 1}, {PC: 44, Line: 2428}, {PC: 45, Line: 1}}, + FirstLine: 2423, Super: "", }, &bytecode.ISeq{ @@ -6865,8 +6902,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 3, Line: 2374}, {PC: 7, Line: 2386}, {PC: 10, Line: 2387}, {PC: 13, Line: 2389}, {PC: 17, Line: 2390}, {PC: 22, Line: 2393}}, - FirstLine: 2372, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2437}, {PC: 3, Line: 2438}, {PC: 7, Line: 2450}, {PC: 10, Line: 2451}, {PC: 13, Line: 2453}, {PC: 17, Line: 2454}, {PC: 22, Line: 2457}}, + FirstLine: 2436, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6885,8 +6922,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2375}, {PC: 4, Line: 2376}, {PC: 8, Line: 2377}, {PC: 13, Line: 2378}, {PC: 24, Line: 2379}, {PC: 42, Line: 2381}, {PC: 50, Line: 2383}}, - FirstLine: 2374, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2439}, {PC: 4, Line: 2440}, {PC: 8, Line: 2441}, {PC: 13, Line: 2442}, {PC: 24, Line: 2443}, {PC: 42, Line: 2445}, {PC: 50, Line: 2447}}, + FirstLine: 2438, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6902,8 +6939,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2379}}, - FirstLine: 2379, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2443}}, + FirstLine: 2443, Super: "", }, }, @@ -6921,8 +6958,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2386}}, - FirstLine: 2386, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2450}}, + FirstLine: 2450, Super: "", }, &bytecode.ISeq{ @@ -6937,8 +6974,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2387}}, - FirstLine: 2387, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2451}}, + FirstLine: 2451, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6952,8 +6989,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2387}}, - FirstLine: 2387, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2451}}, + FirstLine: 2451, Super: "", }, }, @@ -6971,8 +7008,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2391}}, - FirstLine: 2390, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2455}}, + FirstLine: 2454, Super: "", }, }, @@ -6994,8 +7031,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2403}, {PC: 4, Line: 2407}, {PC: 6, Line: 2416}}, - FirstLine: 2402, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2467}, {PC: 4, Line: 2471}, {PC: 6, Line: 2480}}, + FirstLine: 2466, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7009,8 +7046,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2407}, {PC: 2, Line: 259}, {PC: 5, Line: 2408}, {PC: 18, Line: 2409}}, - FirstLine: 2407, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2471}, {PC: 2, Line: 304}, {PC: 5, Line: 2472}, {PC: 18, Line: 2473}}, + FirstLine: 2471, Super: "", }, &bytecode.ISeq{ @@ -7029,8 +7066,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2416}, {PC: 11, Line: 2417}, {PC: 14, Line: 2418}, {PC: 17, Line: 2419}}, - FirstLine: 2416, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2480}, {PC: 11, Line: 2481}, {PC: 14, Line: 2482}, {PC: 17, Line: 2483}}, + FirstLine: 2480, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7044,8 +7081,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2418}}, - FirstLine: 2418, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2482}}, + FirstLine: 2482, Super: "", }, }, @@ -7067,8 +7104,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2443}, {PC: 2, Line: 2456}, {PC: 4, Line: 2496}}, - FirstLine: 2442, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2507}, {PC: 2, Line: 2520}, {PC: 4, Line: 2560}}, + FirstLine: 2506, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7080,8 +7117,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2446}}, - FirstLine: 2443, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2510}}, + FirstLine: 2507, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7107,8 +7144,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2447}}, - FirstLine: 2446, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}}, + FirstLine: 2510, Super: "", }, }, @@ -7144,8 +7181,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2457}, {PC: 22, Line: 2461}}, - FirstLine: 2456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2521}, {PC: 22, Line: 2525}}, + FirstLine: 2520, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7162,8 +7199,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2462}, {PC: 3, Line: 2463}, {PC: 6, Line: 2478}, {PC: 10, Line: 2479}, {PC: 15, Line: 2489}}, - FirstLine: 2461, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2526}, {PC: 3, Line: 2527}, {PC: 6, Line: 2542}, {PC: 10, Line: 2543}, {PC: 15, Line: 2553}}, + FirstLine: 2525, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7184,8 +7221,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2464}, {PC: 4, Line: 2465}, {PC: 14, Line: 2466}, {PC: 21, Line: 2468}, {PC: 26, Line: 2469}, {PC: 42, Line: 2470}, {PC: 54, Line: 2472}, {PC: 59, Line: 2473}, {PC: 72, Line: 2475}}, - FirstLine: 2463, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2528}, {PC: 4, Line: 2529}, {PC: 14, Line: 2530}, {PC: 21, Line: 2532}, {PC: 26, Line: 2533}, {PC: 42, Line: 2534}, {PC: 54, Line: 2536}, {PC: 59, Line: 2537}, {PC: 72, Line: 2539}}, + FirstLine: 2527, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7203,8 +7240,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2466}}, - FirstLine: 2466, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2530}}, + FirstLine: 2530, Super: "", }, }, @@ -7228,8 +7265,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2480}, {PC: 5, Line: 2481}, {PC: 9, Line: 2482}, {PC: 27, Line: 2484}, {PC: 35, Line: 2486}, {PC: 37, Line: 1}}, - FirstLine: 2479, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2544}, {PC: 5, Line: 2545}, {PC: 9, Line: 2546}, {PC: 27, Line: 2548}, {PC: 35, Line: 2550}, {PC: 37, Line: 1}}, + FirstLine: 2543, Super: "", }, }, @@ -7251,8 +7288,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2497}, {PC: 4, Line: 2501}, {PC: 6, Line: 2509}}, - FirstLine: 2496, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2561}, {PC: 4, Line: 2565}, {PC: 6, Line: 2573}}, + FirstLine: 2560, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7266,8 +7303,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}, {PC: 2, Line: 259}, {PC: 5, Line: 2502}, {PC: 18, Line: 2503}}, - FirstLine: 2501, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2565}, {PC: 2, Line: 304}, {PC: 5, Line: 2566}, {PC: 18, Line: 2567}}, + FirstLine: 2565, Super: "", }, &bytecode.ISeq{ @@ -7286,8 +7323,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2509}, {PC: 11, Line: 2510}, {PC: 14, Line: 2511}, {PC: 17, Line: 2512}}, - FirstLine: 2509, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2573}, {PC: 11, Line: 2574}, {PC: 14, Line: 2575}, {PC: 17, Line: 2576}}, + FirstLine: 2573, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7301,8 +7338,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}}, - FirstLine: 2511, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2575}}, + FirstLine: 2575, Super: "", }, }, @@ -7335,8 +7372,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}, {PC: 2, Line: 2566}, {PC: 4, Line: 2569}, {PC: 6, Line: 2572}, {PC: 8, Line: 2575}, {PC: 10, Line: 2578}, {PC: 12, Line: 2581}, {PC: 14, Line: 2585}}, - FirstLine: 2544, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2609}, {PC: 2, Line: 2630}, {PC: 4, Line: 2633}, {PC: 6, Line: 2636}, {PC: 8, Line: 2639}, {PC: 10, Line: 2642}, {PC: 12, Line: 2645}, {PC: 14, Line: 2649}}, + FirstLine: 2608, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7351,8 +7388,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2546}, {PC: 4, Line: 2547}, {PC: 6, Line: 2554}, {PC: 8, Line: 2555}, {PC: 10, Line: 2556}, {PC: 12, Line: 2559}, {PC: 14, Line: 2560}}, - FirstLine: 2545, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2610}, {PC: 4, Line: 2611}, {PC: 6, Line: 2618}, {PC: 8, Line: 2619}, {PC: 10, Line: 2620}, {PC: 12, Line: 2623}, {PC: 14, Line: 2624}}, + FirstLine: 2609, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7370,8 +7407,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}, {PC: 3, Line: 2552}}, - FirstLine: 2547, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2612}, {PC: 3, Line: 2616}}, + FirstLine: 2611, Super: "", }, &bytecode.ISeq{ @@ -7386,8 +7423,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2554}}, - FirstLine: 2554, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2618}}, + FirstLine: 2618, Super: "", }, &bytecode.ISeq{ @@ -7401,7 +7438,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2555, + FirstLine: 2619, Super: "", }, &bytecode.ISeq{ @@ -7418,8 +7455,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2557}}, - FirstLine: 2556, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2621}}, + FirstLine: 2620, Super: "", }, &bytecode.ISeq{ @@ -7437,8 +7474,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2561}, {PC: 9, Line: 2562}}, - FirstLine: 2560, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2625}, {PC: 9, Line: 2626}}, + FirstLine: 2624, Super: "", }, }, @@ -7454,8 +7491,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2567}}, - FirstLine: 2566, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2631}}, + FirstLine: 2630, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7469,8 +7506,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2567}}, - FirstLine: 2567, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2631}}, + FirstLine: 2631, Super: "", }, }, @@ -7486,8 +7523,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2570}}, - FirstLine: 2569, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2634}}, + FirstLine: 2633, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7501,8 +7538,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2570}}, - FirstLine: 2570, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2634}}, + FirstLine: 2634, Super: "", }, }, @@ -7518,8 +7555,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2573}}, - FirstLine: 2572, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2637}}, + FirstLine: 2636, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7533,8 +7570,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2573}}, - FirstLine: 2573, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2637}}, + FirstLine: 2637, Super: "", }, }, @@ -7550,8 +7587,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2576}}, - FirstLine: 2575, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}}, + FirstLine: 2639, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7565,8 +7602,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2576}}, - FirstLine: 2576, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}}, + FirstLine: 2640, Super: "", }, }, @@ -7582,8 +7619,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2579}}, - FirstLine: 2578, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2643}}, + FirstLine: 2642, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7597,8 +7634,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2579}}, - FirstLine: 2579, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2643}}, + FirstLine: 2643, Super: "", }, }, @@ -7614,8 +7651,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2582}}, - FirstLine: 2581, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2646}}, + FirstLine: 2645, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7629,8 +7666,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2582}}, - FirstLine: 2582, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2646}}, + FirstLine: 2646, Super: "", }, }, @@ -7652,8 +7689,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2602}, {PC: 4, Line: 2604}, {PC: 6, Line: 2625}, {PC: 8, Line: 2656}, {PC: 10, Line: 2662}, {PC: 12, Line: 2671}, {PC: 14, Line: 2686}, {PC: 16, Line: 2693}, {PC: 18, Line: 2697}, {PC: 20, Line: 2704}, {PC: 22, Line: 2706}, {PC: 24, Line: 2710}, {PC: 26, Line: 2714}}, - FirstLine: 2601, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2666}, {PC: 4, Line: 2668}, {PC: 6, Line: 2689}, {PC: 8, Line: 2720}, {PC: 10, Line: 2726}, {PC: 12, Line: 2735}, {PC: 14, Line: 2750}, {PC: 16, Line: 2757}, {PC: 18, Line: 2761}, {PC: 20, Line: 2768}, {PC: 22, Line: 2770}, {PC: 24, Line: 2774}, {PC: 26, Line: 2778}}, + FirstLine: 2665, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7669,8 +7706,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2605}}, - FirstLine: 2604, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2669}}, + FirstLine: 2668, Super: "", }, &bytecode.ISeq{ @@ -7695,8 +7732,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 9, Locals: []string{"basename", "tmpdir", "mode", "opts", "prefix", "suffix", "dir", "fopts", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2625}, {PC: 7, Line: 259}, {PC: 15, Line: 2626}, {PC: 19, Line: 2627}, {PC: 36, Line: 2628}, {PC: 44, Line: 259}, {PC: 47, Line: 2630}, {PC: 50, Line: 2638}, {PC: 62, Line: 2639}, {PC: 65, Line: 2640}, {PC: 68, Line: 2641}, {PC: 76, Line: 2642}, {PC: 92, Line: 2643}, {PC: 94, Line: 2644}, {PC: 95, Line: 109}, {PC: 98, Line: 2647}, {PC: 101, Line: 2648}, {PC: 105, Line: 2647}, {PC: 108, Line: 2648}}, - FirstLine: 2625, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2689}, {PC: 7, Line: 304}, {PC: 15, Line: 2690}, {PC: 19, Line: 2691}, {PC: 36, Line: 2692}, {PC: 44, Line: 304}, {PC: 47, Line: 2694}, {PC: 50, Line: 2702}, {PC: 62, Line: 2703}, {PC: 65, Line: 2704}, {PC: 68, Line: 2705}, {PC: 76, Line: 2706}, {PC: 92, Line: 2707}, {PC: 94, Line: 2708}, {PC: 95, Line: 109}, {PC: 98, Line: 2711}, {PC: 101, Line: 2712}, {PC: 105, Line: 2711}, {PC: 108, Line: 2712}}, + FirstLine: 2689, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7715,8 +7752,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2631}, {PC: 25, Line: 2632}, {PC: 31, Line: 2633}, {PC: 36, Line: 2634}, {PC: 39, Line: 2635}}, - FirstLine: 2630, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2695}, {PC: 25, Line: 2696}, {PC: 31, Line: 2697}, {PC: 36, Line: 2698}, {PC: 39, Line: 2699}}, + FirstLine: 2694, Super: "", }, &bytecode.ISeq{ @@ -7734,8 +7771,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}}, - FirstLine: 2640, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2704}}, + FirstLine: 2704, Super: "", }, }, @@ -7754,8 +7791,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2657}, {PC: 16, Line: 2658}, {PC: 19, Line: 2659}}, - FirstLine: 2656, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2721}, {PC: 16, Line: 2722}, {PC: 19, Line: 2723}}, + FirstLine: 2720, Super: "", }, &bytecode.ISeq{ @@ -7770,8 +7807,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2663}}, - FirstLine: 2662, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2727}}, + FirstLine: 2726, Super: "", }, &bytecode.ISeq{ @@ -7789,8 +7826,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2671}, {PC: 7, Line: 259}, {PC: 10, Line: 2672}, {PC: 13, Line: 2673}, {PC: 16, Line: 2674}, {PC: 32, Line: 2675}, {PC: 34, Line: 2676}, {PC: 35, Line: 2677}, {PC: 39, Line: 2679}, {PC: 42, Line: 2680}, {PC: 46, Line: 2679}, {PC: 49, Line: 2680}, {PC: 56, Line: 2683}}, - FirstLine: 2671, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2735}, {PC: 7, Line: 304}, {PC: 10, Line: 2736}, {PC: 13, Line: 2737}, {PC: 16, Line: 2738}, {PC: 32, Line: 2739}, {PC: 34, Line: 2740}, {PC: 35, Line: 2741}, {PC: 39, Line: 2743}, {PC: 42, Line: 2744}, {PC: 46, Line: 2743}, {PC: 49, Line: 2744}, {PC: 56, Line: 2747}}, + FirstLine: 2735, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7807,8 +7844,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2673}}, - FirstLine: 2673, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2737}}, + FirstLine: 2737, Super: "", }, }, @@ -7826,8 +7863,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2686}, {PC: 5, Line: 2687}, {PC: 17, Line: 2688}, {PC: 20, Line: 2689}, {PC: 27, Line: 259}}, - FirstLine: 2686, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2750}, {PC: 5, Line: 2751}, {PC: 17, Line: 2752}, {PC: 20, Line: 2753}, {PC: 27, Line: 304}}, + FirstLine: 2750, Super: "", }, &bytecode.ISeq{ @@ -7840,8 +7877,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2694}}, - FirstLine: 2693, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2758}}, + FirstLine: 2757, Super: "", }, &bytecode.ISeq{ @@ -7854,8 +7891,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2698}, {PC: 8, Line: 2699}, {PC: 14, Line: 259}}, - FirstLine: 2697, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2762}, {PC: 8, Line: 2763}, {PC: 14, Line: 304}}, + FirstLine: 2761, Super: "", }, &bytecode.ISeq{ @@ -7873,8 +7910,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2707}}, - FirstLine: 2706, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2771}}, + FirstLine: 2770, Super: "", }, &bytecode.ISeq{ @@ -7889,8 +7926,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2710}, {PC: 5, Line: 2711}}, - FirstLine: 2710, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2774}, {PC: 5, Line: 2775}}, + FirstLine: 2774, Super: "", }, &bytecode.ISeq{ @@ -7905,8 +7942,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2715}, {PC: 8, Line: 2716}, {PC: 19, Line: 2718}}, - FirstLine: 2714, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2779}, {PC: 8, Line: 2780}, {PC: 19, Line: 2782}}, + FirstLine: 2778, Super: "", }, }, @@ -7928,8 +7965,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2727}, {PC: 11, Line: 109}, {PC: 14, Line: 2767}, {PC: 16, Line: 2771}, {PC: 17, Line: 109}}, - FirstLine: 2726, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2791}, {PC: 11, Line: 109}, {PC: 14, Line: 2831}, {PC: 16, Line: 2835}, {PC: 17, Line: 109}}, + FirstLine: 2790, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7941,8 +7978,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2737}, {PC: 2, Line: 2749}, {PC: 4, Line: 2760}}, - FirstLine: 2734, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2801}, {PC: 2, Line: 2813}, {PC: 4, Line: 2824}}, + FirstLine: 2798, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7962,8 +7999,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2738}, {PC: 5, Line: 2739}, {PC: 17, Line: 2741}, {PC: 22, Line: 2742}, {PC: 33, Line: 2744}}, - FirstLine: 2737, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2802}, {PC: 5, Line: 2803}, {PC: 17, Line: 2805}, {PC: 22, Line: 2806}, {PC: 33, Line: 2808}}, + FirstLine: 2801, Super: "", }, &bytecode.ISeq{ @@ -7984,8 +8021,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2750}, {PC: 5, Line: 2751}, {PC: 17, Line: 2753}, {PC: 22, Line: 2754}, {PC: 33, Line: 2756}}, - FirstLine: 2749, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2814}, {PC: 5, Line: 2815}, {PC: 17, Line: 2817}, {PC: 22, Line: 2818}, {PC: 33, Line: 2820}}, + FirstLine: 2813, Super: "", }, &bytecode.ISeq{ @@ -7998,8 +8035,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2761}}, - FirstLine: 2760, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2825}}, + FirstLine: 2824, Super: "", }, }, @@ -8019,8 +8056,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2767}, {PC: 2, Line: 259}, {PC: 5, Line: 2768}, {PC: 9, Line: 259}}, - FirstLine: 2767, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2831}, {PC: 2, Line: 304}, {PC: 5, Line: 2832}, {PC: 9, Line: 304}}, + FirstLine: 2831, Super: "", }, }, @@ -8036,8 +8073,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2785}}, - FirstLine: 2784, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2849}}, + FirstLine: 2848, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8052,7 +8089,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2785, + FirstLine: 2849, Super: "", }, }, diff --git a/internal/vm/to_set_deprecation_test.go b/internal/vm/to_set_deprecation_test.go new file mode 100644 index 00000000..bbbe7cea --- /dev/null +++ b/internal/vm/to_set_deprecation_test.go @@ -0,0 +1,85 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +//go:build !rbgo_core + +package vm + +import "testing" + +// ⛔ #909: MRI 4.0 warns when Enumerable#to_set is passed arguments, and rbgo was +// silent. Measured through cmd/oracle against MRI 4.0.7, and THREE of the six +// cases are not what "with arguments warns" would lead one to write: +// +// [1,2].to_set silent +// [1,2].to_set(Set) warns <- even though Set IS the default value +// [1,2].to_set { … } SILENT <- a block alone is not "arguments" +// (1..3).to_set silent +// (1..3).to_set(Set) warns <- through Range#to_set +// Set[1,2].to_set(Set) SILENT <- Set#to_set does not warn at all +// +// A default parameter cannot express the first two: inside +// `def to_set(klass = Set, …)`, `to_set` and `to_set(Set)` are identical. The +// test is arity. +// +// ⛔ AND THE LINE NUMBER IS PART OF THE CONTRACT, in a way that is worse than +// "the wrong frame". With the warning at `uplevel: 1` the prefix mixes the +// CALLER'S PATH with the PRELUDE'S LINE: +// +// MRI probe.rb:15 and probe.rb:16 +// rbgo probe.rb:214 and probe.rb:1208 <- a 16-line file +// +// So the message names a real file at an impossible line. In MRI both to_set +// are C and add no Ruby frame; rbgo's prelude is Ruby and does. Same shape as +// [a line number that belongs to the parser, not the document]. +// +// ⚠ The first version of this test asserted `msg.include?("prelude") == false` +// and PASSED under that mutation, because the message never says "prelude" — +// it says the user's filename with the prelude's line. A test written for a +// property it cannot see is worse than no test, so the assertion is now on the +// NUMBER, taken from `__LINE__` at the call site. +func TestEnumerableToSetWarnsOnlyWhereMRIDoes(t *testing.T) { + got := runSrc(t, `require "set" +require "stringio" + +class MySet < Set; end + +def warned(&blk) + prev = $stderr + $stderr = StringIO.new + begin + blk.call + $stderr.string + ensure + captured = $stderr.string + $stderr = prev + captured + end +end + +p warned { [1, 2].to_set }.empty? +p warned { [1, 2].to_set(Set) }.include?("passing arguments to Enumerable#to_set is deprecated") +p warned { [1, 2].to_set(MySet) }.empty? == false +p warned { [1, 2].to_set { |x| x } }.empty? +p warned { (1..3).to_set }.empty? +p warned { (1..3).to_set(Set) }.empty? == false +p warned { Set[1, 2].to_set(Set) }.empty? +p warned { Set[1, 2].to_set(MySet) }.empty? + +# ⛔ The prefix must name the CALLER'S line. Asserting on the NUMBER, because +# the filename is the caller's either way -- that is what made the first +# version of this check pass under a broken uplevel. +direct_line = nil +msg = warned { direct_line = __LINE__; [1, 2].to_set(Set) } +p msg.include?(":#{direct_line}:") + +range_line = nil +msg = warned { range_line = __LINE__; (1..3).to_set(Set) } +p msg.include?(":#{range_line}:") +`) + want := "true\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue\ntrue" + if got != want { + t.Errorf("Enumerable#to_set deprecation:\ngot %q\nwant %q", got, want) + } +}