diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index 585da1ff..f120e593 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -1446,60 +1446,77 @@ def classify(&block) # divide(&block): partition self into a Set of subsets. With a 1-argument block # each subset shares a block value; with a 2-argument block the block is a - # relation and the subsets are the strongly-connected components of the induced - # digraph (an Enumerator without a block). + # relation and the subsets are its MUTUALLY-related groups (an Enumerator + # without a block). + # + # The outer Set is a plain Set even for a subclass receiver, on both paths: + # set_i_divide builds it with set_alloc_with_size(rb_cSet, ...) (set.c:1002 at + # v4.0.9) and set_divide_arity2 with set_s_create(0, 0, rb_cSet) (set.c:946). + # Only the SUBSETS take the receiver's class. def divide(&func) return enum_for(:divide) { size } unless func if func.arity == 2 __divide_graph(&func) else - self.class.new(classify(&func).values) + Set.new(classify(&func).values) end end + # ⛔ Ruby 4.0 replaced the ALGORITHM here, not just the yield pattern. This was + # Tarjan's strongly-connected components over the full n x n relation, which is + # what MRI's lib/set.rb did up to 3.x. set_divide_arity2 (set.c:923 at v4.0.9) + # is union-find over each UNORDERED pair once, merging i and j only when the + # block is truthy BOTH ways. + # + # The two are different functions, not two spellings of one. A directed cycle + # 1->2->3->1 with no reverse edge is a single strongly-connected component and + # has no mutually-related pair at all: SCC answers [[1, 2, 3]], union-find + # answers [[1], [2], [3]]. Measured on MRI 4.0.7, it is the latter. + # + # ruby/spec sees only the yields, and asserts them both ways five lines apart + # (core/set/divide_spec.rb:35 from 4.0, :43 below it) — that pair is how a + # reader tells a version swap from a defect. def __divide_graph(&func) items = to_a n = items.size - adj = Array.new(n) { [] } - n.times do |i| - n.times do |j| - adj[i] << j if func.call(items[i], items[j]) + parents = Array.new(n) { |i| i } + # Union-find with path compression, set.c:898. + root = lambda do |i| + r = i + r = parents[r] while parents[r] != r + while parents[i] != r + nxt = parents[i] + parents[i] = r + i = nxt end - end - idx = 0 - indices = Array.new(n) - low = Array.new(n, 0) - onstack = Array.new(n, false) - stack = [] - comps = [] - connect = nil - connect = lambda do |v| - indices[v] = idx - low[v] = idx - idx += 1 - stack.push(v) - onstack[v] = true - adj[v].each do |w| - if indices[w].nil? - connect.call(w) - low[v] = low[w] if low[w] < low[v] - elsif onstack[w] - low[v] = indices[w] if indices[w] < low[v] - end + r + end + 0.upto(n - 2) do |i| + item1 = items[i] + (i + 1).upto(n - 1) do |j| + item2 = items[j] + # ⛔ && SHORT-CIRCUITS, and that is observable: a falsy first answer + # means the reversed pair is never yielded at all. The spec's example + # cannot see it, because its block body `ret << [x, y]` is truthy. + next unless func.call(item1, item2) && func.call(item2, item1) + ri = root.call(i) + rj = root.call(j) + parents[rj] = ri if ri != rj end - if low[v] == indices[v] - comp = [] - loop do - w = stack.pop - onstack[w] = false - comp << items[w] - break if w == v - end - comps << comp + end + # Grouped in index order, so the subsets come out in the order their first + # member appears — MRI walks i ascending and keys a Hash by root (set.c:948). + groups = {} + order = [] + n.times do |i| + r = root.call(i) + unless groups.key?(r) + groups[r] = [] + order << r end + groups[r] << items[i] end - n.times { |v| connect.call(v) if indices[v].nil? } - self.class.new(comps.map { |c| self.class.new(c) }) + Set.new(order.map { |r| self.class.new(groups[r]) }) end private :__divide_graph diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index f1820d94..1adcd657 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: 1565}, {PC: 24, Line: 1785}, {PC: 26, Line: 1864}, {PC: 28, Line: 1895}, {PC: 30, Line: 1915}, {PC: 32, Line: 1955}, {PC: 34, Line: 1968}, {PC: 36, Line: 2008}, {PC: 38, Line: 2189}, {PC: 40, Line: 2231}, {PC: 42, Line: 2232}, {PC: 46, Line: 2297}, {PC: 48, Line: 2298}, {PC: 52, Line: 2407}, {PC: 54, Line: 2408}, {PC: 58, Line: 2509}, {PC: 60, Line: 2510}, {PC: 64, Line: 2567}, {PC: 66, Line: 2692}, {PC: 68, Line: 2750}}, + 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: 1582}, {PC: 24, Line: 1802}, {PC: 26, Line: 1881}, {PC: 28, Line: 1912}, {PC: 30, Line: 1932}, {PC: 32, Line: 1972}, {PC: 34, Line: 1985}, {PC: 36, Line: 2025}, {PC: 38, Line: 2206}, {PC: 40, Line: 2248}, {PC: 42, Line: 2249}, {PC: 46, Line: 2314}, {PC: 48, Line: 2315}, {PC: 52, Line: 2424}, {PC: 54, Line: 2425}, {PC: 58, Line: 2526}, {PC: 60, Line: 2527}, {PC: 64, Line: 2584}, {PC: 66, Line: 2709}, {PC: 68, Line: 2767}}, FirstLine: 1, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -3254,7 +3254,7 @@ 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: 1451}, {PC: 94, Line: 1460}, {PC: 96, Line: 1504}, {PC: 100, Line: 1510}, {PC: 102, Line: 1514}, {PC: 104, Line: 1525}, {PC: 106, Line: 1538}, {PC: 110, Line: 1541}, {PC: 112, Line: 1546}}, + 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: 1563}}, FirstLine: 1193, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -4280,12 +4280,12 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "divide", - Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 26, A: 26}, {Op: 5}, {Op: 30, A: 3}, {Op: 5}, {Op: 11}, {Op: 66, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 1, A: 1}, {Op: 22}, {Op: 28, A: 19}, {Op: 5}, {Op: 11}, {Op: 66, A: 2}, {Op: 26, A: 25}, {Op: 33, A: 3}, {Op: 5}, {Op: 11}, {Op: 66, A: 4}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 53}}, Consts: []object.Value{ object.Symbol("divide"), object.IntValue(2), }, - Names: []string{"enum_for", "arity", "__divide_graph", "class", "classify", "values", "new"}, + Names: []string{"enum_for", "arity", "__divide_graph", "Set", "classify", "values", "new"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, @@ -4293,8 +4293,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"func"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1452}, {PC: 10, Line: 1453}, {PC: 15, Line: 1454}, {PC: 19, Line: 109}}, - FirstLine: 1451, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1457}, {PC: 10, Line: 1458}, {PC: 15, Line: 1459}, {PC: 19, Line: 1461}}, + FirstLine: 1456, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in divide", @@ -4306,8 +4306,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1452}}, - FirstLine: 1452, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1457}}, + FirstLine: 1457, Super: "", }, }, @@ -4315,115 +4315,85 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "__divide_graph", - Insns: []bytecode.Instr{{Op: 5}, {Op: 30, Flags: 8}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, C: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 2, Flags: 1}, {Op: 9}, {Op: 1}, {Op: 12, A: 4}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 12, A: 5}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 1}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 12, A: 6}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 4}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 12, A: 7}, {Op: 9}, {Op: 6}, {Op: 12, A: 8}, {Op: 9}, {Op: 6}, {Op: 12, A: 9}, {Op: 9}, {Op: 2}, {Op: 12, A: 10}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 12, A: 10}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 4, Flags: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 6}, {Op: 11, A: 9}, {Op: 30, A: 7, C: 5, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 30, Flags: 8}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 11, A: 2}, {Op: 30, A: 3, B: 1, C: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 12, A: 4}, {Op: 9}, {Op: 1}, {Op: 11, A: 2}, {Op: 1, A: 1}, {Op: 14}, {Op: 30, A: 5, B: 1, C: 3, Flags: 3}, {Op: 9}, {Op: 7}, {Op: 12, A: 5}, {Op: 9}, {Op: 6}, {Op: 12, A: 6}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 6, C: 4, Flags: 1}, {Op: 9}, {Op: 33, A: 7}, {Op: 11, A: 6}, {Op: 30, A: 8, C: 5, Flags: 1}, {Op: 30, A: 3, B: 1, Flags: 3}, {Op: 53}}, Consts: []object.Value{ object.IntValue(0), + object.IntValue(2), }, - Names: []string{"to_a", "size", "Array", "new", "times", "lambda", "class", "map"}, + Names: []string{"to_a", "size", "Array", "new", "lambda", "upto", "times", "Set", "map"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: 0, - NumLocals: 11, - Locals: []string{"func", "items", "n", "adj", "idx", "indices", "low", "onstack", "stack", "comps", "connect"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1461}, {PC: 4, Line: 1462}, {PC: 8, Line: 1463}, {PC: 13, Line: 1464}, {PC: 16, Line: 1469}, {PC: 19, Line: 1470}, {PC: 24, Line: 1471}, {PC: 30, Line: 1472}, {PC: 36, Line: 1473}, {PC: 39, Line: 1474}, {PC: 42, Line: 259}, {PC: 45, Line: 1476}, {PC: 49, Line: 1501}, {PC: 52, Line: 109}}, - FirstLine: 1460, + 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, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in __divide_graph", - Insns: []bytecode.Instr{{Op: 6}, {Op: 53}}, - NumRequired: 0, + Insns: []bytecode.Instr{{Op: 11}, {Op: 53}}, + Params: []string{"i"}, + NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1463}}, - FirstLine: 1463, + NumLocals: 1, + Locals: []string{"i"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1482}}, + FirstLine: 1482, Super: "", }, &bytecode.ISeq{ Name: "block in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 30, C: 1, Flags: 1}, {Op: 53}}, - Names: []string{"times"}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 1}, {Op: 23}, {Op: 28, A: 15}, {Op: 11, A: 3, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 26, A: 3}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 1}, {Op: 23}, {Op: 28, A: 40}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 11, A: 1}, {Op: 12, A: 3}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 12}, {Op: 9}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Names: []string{"[]", "[]="}, Params: []string{"i"}, NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1465}}, - FirstLine: 1464, - Children: []*bytecode.ISeq{ - &bytecode.ISeq{ - Name: "block (2 levels) in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, B: 2}, {Op: 11, A: 1, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 28, A: 15}, {Op: 11, A: 3, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}}, - Names: []string{"[]", "call", "<<"}, - Params: []string{"j"}, - NumRequired: 1, - SplatIndex: -1, - PostCount: 0, - KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 1, - Locals: []string{"j"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1466}}, - FirstLine: 1465, - Super: "", - }, - }, - Super: "", + 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, + Super: "", }, &bytecode.ISeq{ Name: "block in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 1}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 11, A: 4, B: 1}, {Op: 12, A: 2}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 4, B: 1}, {Op: 9}, {Op: 11, A: 8, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 9}, {Op: 11, A: 7, B: 1}, {Op: 11}, {Op: 3}, {Op: 12, A: 3}, {Op: 30, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 3}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, C: 1, Flags: 1}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 22}, {Op: 28, A: 56}, {Op: 6}, {Op: 12, A: 4}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 9}, {Op: 11, A: 9, B: 1}, {Op: 11, A: 4}, {Op: 30, A: 5, B: 1}, {Op: 26, A: 57}, {Op: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 1}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 1}, {Op: 14}, {Op: 30, A: 1, B: 1, C: 1, Flags: 3}, {Op: 53}}, Consts: []object.Value{ object.IntValue(1), }, - Names: []string{"[]=", "push", "[]", "each", "loop", "<<"}, - Params: []string{"v"}, + Names: []string{"[]", "upto"}, + Params: []string{"i"}, NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 5, - Locals: []string{"v", "", "", "", "comp"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1477}, {PC: 8, Line: 1478}, {PC: 16, Line: 1479}, {PC: 21, Line: 1480}, {PC: 25, Line: 1481}, {PC: 33, Line: 1482}, {PC: 38, Line: 1490}, {PC: 46, Line: 1491}, {PC: 49, Line: 1492}, {PC: 52, Line: 1498}}, - FirstLine: 1476, + NumLocals: 2, + Locals: []string{"i", "item1"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1495}, {PC: 5, Line: 1496}}, + FirstLine: 1494, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 29}, {Op: 11, A: 10, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 9}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 18}, {Op: 28, A: 27}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 6, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 26, A: 28}, {Op: 2}, {Op: 26, A: 54}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 28, A: 53}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 30, B: 1, Flags: 3}, {Op: 18}, {Op: 28, A: 51}, {Op: 11, A: 6, B: 2}, {Op: 11, B: 1}, {Op: 11, A: 5, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 30, A: 3, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 26, A: 52}, {Op: 2}, {Op: 26, A: 54}, {Op: 2}, {Op: 53}}, - Names: []string{"[]", "nil?", "call", "[]="}, - Params: []string{"w"}, + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 2}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, B: 2}, {Op: 11, A: 1}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 25}, {Op: 28, A: 21}, {Op: 2}, {Op: 53}, {Op: 26, A: 22}, {Op: 2}, {Op: 9}, {Op: 11, A: 4, B: 2}, {Op: 11, B: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 4, B: 2}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 11, A: 3}, {Op: 23}, {Op: 28, A: 45}, {Op: 11, A: 3, B: 2}, {Op: 11, A: 3}, {Op: 11, A: 2}, {Op: 12, A: 4}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 4}, {Op: 26, A: 46}, {Op: 2}, {Op: 53}}, + Names: []string{"[]", "call", "[]="}, + Params: []string{"j"}, NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 3, - Locals: []string{"w", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1483}, {PC: 5, Line: 1484}, {PC: 9, Line: 1485}, {PC: 33, Line: 1487}}, - FirstLine: 1482, - Super: "", - }, - &bytecode.ISeq{ - Name: "block (2 levels) in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, A: 8, B: 2}, {Op: 30, Flags: 1}, {Op: 12}, {Op: 9}, {Op: 11, A: 7, B: 2}, {Op: 11}, {Op: 4}, {Op: 12, A: 1}, {Op: 30, A: 1, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 9}, {Op: 11, A: 4, B: 1}, {Op: 11, A: 1, B: 2}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 30, A: 3, B: 1}, {Op: 9}, {Op: 11}, {Op: 11, B: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 2}, {Op: 55}, {Op: 26, A: 26}, {Op: 2}, {Op: 53}}, - Names: []string{"pop", "[]=", "[]", "<<"}, - NumRequired: 0, - SplatIndex: -1, - PostCount: 0, - KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 2, - Locals: []string{"w", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1493}, {PC: 4, Line: 1494}, {PC: 12, Line: 1495}, {PC: 18, Line: 1496}}, - FirstLine: 1492, + 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, Super: "", }, }, @@ -4431,34 +4401,34 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "block in __divide_graph", - Insns: []bytecode.Instr{{Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 9}, {Op: 11, A: 10, B: 1}, {Op: 11}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 26, A: 10}, {Op: 2}, {Op: 53}}, - Names: []string{"[]", "nil?", "call"}, - Params: []string{"v"}, + Insns: []bytecode.Instr{{Op: 11, A: 4, B: 1}, {Op: 11}, {Op: 30, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 5, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 22}, {Op: 11, A: 5, B: 1}, {Op: 11, A: 1}, {Op: 6}, {Op: 12, A: 2}, {Op: 30, A: 2, B: 2, Flags: 3}, {Op: 9}, {Op: 11, A: 2}, {Op: 9}, {Op: 11, A: 6, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 26, A: 23}, {Op: 2}, {Op: 9}, {Op: 11, A: 5, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, A: 4, B: 1, Flags: 3}, {Op: 30, A: 3, B: 1}, {Op: 53}}, + Names: []string{"call", "key?", "[]=", "<<", "[]"}, + Params: []string{"i"}, NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1501}}, - FirstLine: 1501, + 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, Super: "", }, &bytecode.ISeq{ Name: "block in __divide_graph", - Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 53}}, - Names: []string{"class", "new"}, - Params: []string{"c"}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 11, A: 5, B: 1}, {Op: 11}, {Op: 30, A: 1, B: 1, Flags: 3}, {Op: 30, A: 2, B: 1, Flags: 3}, {Op: 53}}, + Names: []string{"class", "[]", "new"}, + Params: []string{"r"}, NumRequired: 1, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 1, - Locals: []string{"c"}, + Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1502, + FirstLine: 1519, Super: "", }, }, @@ -4475,7 +4445,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1510, + FirstLine: 1527, Super: "", }, &bytecode.ISeq{ @@ -4488,8 +4458,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1515}, {PC: 3, Line: 1516}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, - FirstLine: 1514, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1532}, {PC: 3, Line: 1533}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, + FirstLine: 1531, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten!", @@ -4503,8 +4473,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1515}}, - FirstLine: 1515, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1532}}, + FirstLine: 1532, Super: "", }, }, @@ -4522,8 +4492,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "seen"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1525}, {PC: 5, Line: 1526}, {PC: 8, Line: 109}}, - FirstLine: 1525, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1542}, {PC: 5, Line: 1543}, {PC: 8, Line: 109}}, + FirstLine: 1542, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten_merge", @@ -4540,8 +4510,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"o", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1527}, {PC: 4, Line: 1528}, {PC: 16, Line: 1529}, {PC: 25, Line: 1530}, {PC: 30, Line: 1531}, {PC: 35, Line: 1533}}, - FirstLine: 1526, + 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, Super: "", }, }, @@ -4559,8 +4529,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sep"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1541}, {PC: 2, Line: 259}, {PC: 5, Line: 1542}}, - FirstLine: 1541, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1558}, {PC: 2, Line: 259}, {PC: 5, Line: 1559}}, + FirstLine: 1558, Super: "", }, &bytecode.ISeq{ @@ -4573,7 +4543,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1546, + FirstLine: 1563, Super: "", }, }, @@ -4589,8 +4559,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1569}, {PC: 2, Line: 1693}, {PC: 4, Line: 1750}, {PC: 6, Line: 1754}, {PC: 8, Line: 1760}, {PC: 10, Line: 1764}}, - FirstLine: 1565, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1586}, {PC: 2, Line: 1710}, {PC: 4, Line: 1767}, {PC: 6, Line: 1771}, {PC: 8, Line: 1777}, {PC: 10, Line: 1781}}, + FirstLine: 1582, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4608,8 +4578,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1570}, {PC: 4, Line: 1572}, {PC: 7, Line: 1573}, {PC: 16, Line: 1577}, {PC: 18, Line: 1582}, {PC: 20, Line: 1592}, {PC: 24, Line: 1594}, {PC: 26, Line: 1602}, {PC: 28, Line: 1606}, {PC: 30, Line: 1612}, {PC: 32, Line: 1619}, {PC: 34, Line: 1623}, {PC: 36, Line: 1632}, {PC: 38, Line: 1640}, {PC: 40, Line: 1660}, {PC: 42, Line: 1666}, {PC: 44, Line: 1670}, {PC: 46, Line: 1674}, {PC: 49, Line: 1678}}, - FirstLine: 1569, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1587}, {PC: 4, Line: 1589}, {PC: 7, Line: 1590}, {PC: 16, Line: 1594}, {PC: 18, Line: 1599}, {PC: 20, Line: 1609}, {PC: 24, Line: 1611}, {PC: 26, Line: 1619}, {PC: 28, Line: 1623}, {PC: 30, Line: 1629}, {PC: 32, Line: 1636}, {PC: 34, Line: 1640}, {PC: 36, Line: 1649}, {PC: 38, Line: 1657}, {PC: 40, Line: 1677}, {PC: 42, Line: 1683}, {PC: 44, Line: 1687}, {PC: 46, Line: 1691}, {PC: 49, Line: 1695}}, + FirstLine: 1586, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4623,8 +4593,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1578}, {PC: 8, Line: 1579}}, - FirstLine: 1577, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1595}, {PC: 8, Line: 1596}}, + FirstLine: 1594, Super: "", }, &bytecode.ISeq{ @@ -4639,8 +4609,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1583}, {PC: 4, Line: 1584}, {PC: 9, Line: 259}, {PC: 11, Line: 1588}}, - FirstLine: 1582, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1600}, {PC: 4, Line: 1601}, {PC: 9, Line: 259}, {PC: 11, Line: 1605}}, + FirstLine: 1599, Super: "", }, &bytecode.ISeq{ @@ -4662,8 +4632,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1596}, {PC: 17, Line: 1598}, {PC: 25, Line: 1599}}, - FirstLine: 1594, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1613}, {PC: 17, Line: 1615}, {PC: 25, Line: 1616}}, + FirstLine: 1611, Super: "", }, &bytecode.ISeq{ @@ -4676,8 +4646,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1603}}, - FirstLine: 1602, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1620}}, + FirstLine: 1619, Super: "", }, &bytecode.ISeq{ @@ -4695,8 +4665,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1607}, {PC: 1, Line: 109}, {PC: 6, Line: 1607}}, - FirstLine: 1606, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}, {PC: 1, Line: 109}, {PC: 6, Line: 1624}}, + FirstLine: 1623, Super: "", }, &bytecode.ISeq{ @@ -4709,8 +4679,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1613}}, - FirstLine: 1612, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1630}}, + FirstLine: 1629, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4724,8 +4694,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1614}}, - FirstLine: 1613, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1631}}, + FirstLine: 1630, Super: "", }, }, @@ -4741,8 +4711,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1620}}, - FirstLine: 1619, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1637}}, + FirstLine: 1636, Super: "", }, &bytecode.ISeq{ @@ -4759,8 +4729,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}, {PC: 4, Line: 109}, {PC: 9, Line: 1625}, {PC: 13, Line: 1626}, {PC: 31, Line: 109}}, - FirstLine: 1623, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1641}, {PC: 4, Line: 109}, {PC: 9, Line: 1642}, {PC: 13, Line: 1643}, {PC: 31, Line: 109}}, + FirstLine: 1640, Super: "", }, &bytecode.ISeq{ @@ -4779,8 +4749,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1633}, {PC: 5, Line: 1634}, {PC: 23, Line: 1635}, {PC: 33, Line: 1636}, {PC: 45, Line: 109}}, - FirstLine: 1632, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1650}, {PC: 5, Line: 1651}, {PC: 23, Line: 1652}, {PC: 33, Line: 1653}, {PC: 45, Line: 109}}, + FirstLine: 1649, Super: "", }, &bytecode.ISeq{ @@ -4799,8 +4769,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: 1642}, {PC: 9, Line: 259}, {PC: 14, Line: 1643}, {PC: 18, Line: 1644}, {PC: 22, Line: 1645}, {PC: 35, Line: 1646}, {PC: 38, Line: 1647}, {PC: 42, Line: 1648}, {PC: 47, Line: 1649}, {PC: 52, Line: 1651}, {PC: 60, Line: 1652}, {PC: 68, Line: 1653}, {PC: 74, Line: 1654}, {PC: 84, Line: 1655}, {PC: 92, Line: 1657}}, - FirstLine: 1640, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1659}, {PC: 9, Line: 259}, {PC: 14, Line: 1660}, {PC: 18, Line: 1661}, {PC: 22, Line: 1662}, {PC: 35, Line: 1663}, {PC: 38, Line: 1664}, {PC: 42, Line: 1665}, {PC: 47, Line: 1666}, {PC: 52, Line: 1668}, {PC: 60, Line: 1669}, {PC: 68, Line: 1670}, {PC: 74, Line: 1671}, {PC: 84, Line: 1672}, {PC: 92, Line: 1674}}, + FirstLine: 1657, Super: "", }, &bytecode.ISeq{ @@ -4818,8 +4788,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1662}, {PC: 14, Line: 109}}, - FirstLine: 1660, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1679}, {PC: 14, Line: 109}}, + FirstLine: 1677, Super: "", }, &bytecode.ISeq{ @@ -4834,8 +4804,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1667}}, - FirstLine: 1666, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1684}}, + FirstLine: 1683, Super: "", }, &bytecode.ISeq{ @@ -4848,8 +4818,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1671}}, - FirstLine: 1670, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1688}}, + FirstLine: 1687, Super: "", }, &bytecode.ISeq{ @@ -4868,8 +4838,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1679}, {PC: 10, Line: 1680}, {PC: 24, Line: 1682}, {PC: 32, Line: 1684}, {PC: 34, Line: 1686}}, - FirstLine: 1678, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1696}, {PC: 10, Line: 1697}, {PC: 24, Line: 1699}, {PC: 32, Line: 1701}, {PC: 34, Line: 1703}}, + FirstLine: 1695, Super: "", }, }, @@ -4897,8 +4867,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1694}, {PC: 24, Line: 1707}, {PC: 34, Line: 1709}, {PC: 36, Line: 1713}, {PC: 38, Line: 1717}, {PC: 42, Line: 1719}, {PC: 44, Line: 1727}, {PC: 46, Line: 1736}, {PC: 48, Line: 1740}, {PC: 50, Line: 1741}, {PC: 52, Line: 1743}}, - FirstLine: 1693, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1711}, {PC: 24, Line: 1724}, {PC: 34, Line: 1726}, {PC: 36, Line: 1730}, {PC: 38, Line: 1734}, {PC: 42, Line: 1736}, {PC: 44, Line: 1744}, {PC: 46, Line: 1753}, {PC: 48, Line: 1757}, {PC: 50, Line: 1758}, {PC: 52, Line: 1760}}, + FirstLine: 1710, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4911,8 +4881,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1695}}, - FirstLine: 1695, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1712}}, + FirstLine: 1712, Super: "", }, &bytecode.ISeq{ @@ -4926,8 +4896,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1696}}, - FirstLine: 1696, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}}, + FirstLine: 1713, Super: "", }, &bytecode.ISeq{ @@ -4941,8 +4911,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1697}}, - FirstLine: 1697, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1714}}, + FirstLine: 1714, Super: "", }, &bytecode.ISeq{ @@ -4956,8 +4926,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1698}}, - FirstLine: 1698, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1715}}, + FirstLine: 1715, Super: "", }, &bytecode.ISeq{ @@ -4971,8 +4941,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1699}}, - FirstLine: 1699, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1716}}, + FirstLine: 1716, Super: "", }, &bytecode.ISeq{ @@ -4986,8 +4956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}}, - FirstLine: 1700, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1717}}, + FirstLine: 1717, Super: "", }, &bytecode.ISeq{ @@ -5002,8 +4972,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1701}}, - FirstLine: 1701, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1718}}, + FirstLine: 1718, Super: "", }, &bytecode.ISeq{ @@ -5018,8 +4988,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1710}}, - FirstLine: 1709, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1727}}, + FirstLine: 1726, Super: "", }, &bytecode.ISeq{ @@ -5035,8 +5005,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1714}}, - FirstLine: 1713, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1731}}, + FirstLine: 1730, Super: "", }, &bytecode.ISeq{ @@ -5054,8 +5024,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 4, Line: 1721}, {PC: 13, Line: 1722}}, - FirstLine: 1719, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 4, Line: 1738}, {PC: 13, Line: 1739}}, + FirstLine: 1736, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5070,7 +5040,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1722, + FirstLine: 1739, Super: "", }, }, @@ -5095,8 +5065,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}, {PC: 11, Line: 1729}, {PC: 17, Line: 1730}, {PC: 32, Line: 1731}, {PC: 41, Line: 1732}}, - FirstLine: 1727, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1745}, {PC: 11, Line: 1746}, {PC: 17, Line: 1747}, {PC: 32, Line: 1748}, {PC: 41, Line: 1749}}, + FirstLine: 1744, Super: "", }, &bytecode.ISeq{ @@ -5111,8 +5081,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 5, Line: 1738}}, - FirstLine: 1736, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1754}, {PC: 5, Line: 1755}}, + FirstLine: 1753, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5126,8 +5096,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1738}}, - FirstLine: 1738, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}}, + FirstLine: 1755, Super: "", }, }, @@ -5146,8 +5116,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, - FirstLine: 1743, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1761}}, + FirstLine: 1760, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5164,8 +5134,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, - FirstLine: 1744, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1761}}, + FirstLine: 1761, Super: "", }, }, @@ -5184,8 +5154,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1751}}, - FirstLine: 1750, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1768}}, + FirstLine: 1767, Super: "", }, &bytecode.ISeq{ @@ -5197,8 +5167,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}}, - FirstLine: 1754, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1772}}, + FirstLine: 1771, Super: "", }, &bytecode.ISeq{ @@ -5210,8 +5180,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1760}}, - FirstLine: 1760, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1777}}, + FirstLine: 1777, Super: "", }, &bytecode.ISeq{ @@ -5224,8 +5194,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1765}}, - FirstLine: 1764, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1782}}, + FirstLine: 1781, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5236,8 +5206,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1766}}, - FirstLine: 1765, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1783}}, + FirstLine: 1782, Super: "", }, }, @@ -5256,8 +5226,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1786}, {PC: 2, Line: 1793}, {PC: 4, Line: 1797}, {PC: 6, Line: 1801}, {PC: 8, Line: 1805}, {PC: 10, Line: 1811}, {PC: 12, Line: 1815}, {PC: 14, Line: 1819}, {PC: 16, Line: 1823}, {PC: 18, Line: 1828}, {PC: 20, Line: 1840}, {PC: 22, Line: 1843}, {PC: 24, Line: 1845}, {PC: 26, Line: 1849}, {PC: 28, Line: 1852}}, - FirstLine: 1785, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1803}, {PC: 2, Line: 1810}, {PC: 4, Line: 1814}, {PC: 6, Line: 1818}, {PC: 8, Line: 1822}, {PC: 10, Line: 1828}, {PC: 12, Line: 1832}, {PC: 14, Line: 1836}, {PC: 16, Line: 1840}, {PC: 18, Line: 1845}, {PC: 20, Line: 1857}, {PC: 22, Line: 1860}, {PC: 24, Line: 1862}, {PC: 26, Line: 1866}, {PC: 28, Line: 1869}}, + FirstLine: 1802, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5271,8 +5241,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1786}, {PC: 2, Line: 259}, {PC: 5, Line: 1787}, {PC: 8, Line: 1788}, {PC: 10, Line: 1789}}, - FirstLine: 1786, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1803}, {PC: 2, Line: 259}, {PC: 5, Line: 1804}, {PC: 8, Line: 1805}, {PC: 10, Line: 1806}}, + FirstLine: 1803, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5286,8 +5256,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1789}}, - FirstLine: 1789, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1806}}, + FirstLine: 1806, Super: "", }, }, @@ -5305,8 +5275,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1794}}, - FirstLine: 1793, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1811}}, + FirstLine: 1810, Super: "", }, &bytecode.ISeq{ @@ -5321,8 +5291,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1798}}, - FirstLine: 1797, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1815}}, + FirstLine: 1814, Super: "", }, &bytecode.ISeq{ @@ -5335,8 +5305,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1802}}, - FirstLine: 1801, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1819}}, + FirstLine: 1818, Super: "", }, &bytecode.ISeq{ @@ -5352,8 +5322,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1806}, {PC: 10, Line: 1807}, {PC: 13, Line: 109}}, - FirstLine: 1805, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}, {PC: 10, Line: 1824}, {PC: 13, Line: 109}}, + FirstLine: 1822, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5366,8 +5336,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1807}}, - FirstLine: 1807, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1824}}, + FirstLine: 1824, Super: "", }, }, @@ -5383,8 +5353,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1812}}, - FirstLine: 1811, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}}, + FirstLine: 1828, Super: "", }, &bytecode.ISeq{ @@ -5399,8 +5369,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1816}}, - FirstLine: 1815, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1833}}, + FirstLine: 1832, Super: "", }, &bytecode.ISeq{ @@ -5415,8 +5385,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}}, - FirstLine: 1819, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1837}}, + FirstLine: 1836, Super: "", }, &bytecode.ISeq{ @@ -5434,8 +5404,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}, {PC: 5, Line: 1824}, {PC: 9, Line: 1825}}, - FirstLine: 1823, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 5, Line: 1841}, {PC: 9, Line: 1842}}, + FirstLine: 1840, Super: "", }, &bytecode.ISeq{ @@ -5458,8 +5428,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}, {PC: 4, Line: 1830}, {PC: 8, Line: 1831}, {PC: 26, Line: 1832}, {PC: 44, Line: 1834}, {PC: 48, Line: 1836}}, - FirstLine: 1828, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1846}, {PC: 4, Line: 1847}, {PC: 8, Line: 1848}, {PC: 26, Line: 1849}, {PC: 44, Line: 1851}, {PC: 48, Line: 1853}}, + FirstLine: 1845, Super: "", }, &bytecode.ISeq{ @@ -5474,8 +5444,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}, {PC: 9, Line: 259}}, - FirstLine: 1840, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 9, Line: 259}}, + FirstLine: 1857, Super: "", }, &bytecode.ISeq{ @@ -5490,8 +5460,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1845}, {PC: 5, Line: 1846}}, - FirstLine: 1845, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1862}, {PC: 5, Line: 1863}}, + FirstLine: 1862, Super: "", }, &bytecode.ISeq{ @@ -5504,8 +5474,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1850}}, - FirstLine: 1849, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}}, + FirstLine: 1866, Super: "", }, }, @@ -5521,8 +5491,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}, {PC: 2, Line: 1875}, {PC: 4, Line: 1878}, {PC: 6, Line: 1884}}, - FirstLine: 1864, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 2, Line: 1892}, {PC: 4, Line: 1895}, {PC: 6, Line: 1901}}, + FirstLine: 1881, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5536,8 +5506,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}, {PC: 5, Line: 1868}, {PC: 9, Line: 1869}, {PC: 13, Line: 1873}}, - FirstLine: 1867, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 5, Line: 1885}, {PC: 9, Line: 1886}, {PC: 13, Line: 1890}}, + FirstLine: 1884, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5551,8 +5521,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1870}, {PC: 1, Line: 109}, {PC: 6, Line: 1871}}, - FirstLine: 1869, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1887}, {PC: 1, Line: 109}, {PC: 6, Line: 1888}}, + FirstLine: 1886, Super: "", }, }, @@ -5570,8 +5540,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, - FirstLine: 1878, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}}, + FirstLine: 1895, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5585,8 +5555,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}}, - FirstLine: 1879, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}}, + FirstLine: 1896, Super: "", }, }, @@ -5607,8 +5577,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 4, Line: 1886}, {PC: 9, Line: 1888}}, - FirstLine: 1884, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1902}, {PC: 4, Line: 1903}, {PC: 9, Line: 1905}}, + FirstLine: 1901, Super: "", }, }, @@ -5624,8 +5594,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}, {PC: 2, Line: 1904}, {PC: 4, Line: 1906}}, - FirstLine: 1895, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}, {PC: 2, Line: 1921}, {PC: 4, Line: 1923}}, + FirstLine: 1912, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5639,8 +5609,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}, {PC: 5, Line: 1897}, {PC: 9, Line: 1898}, {PC: 13, Line: 1902}}, - FirstLine: 1896, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}, {PC: 5, Line: 1914}, {PC: 9, Line: 1915}, {PC: 13, Line: 1919}}, + FirstLine: 1913, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5654,8 +5624,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1899}, {PC: 1, Line: 109}, {PC: 6, Line: 1900}}, - FirstLine: 1898, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1916}, {PC: 1, Line: 109}, {PC: 6, Line: 1917}}, + FirstLine: 1915, Super: "", }, }, @@ -5673,8 +5643,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}}, - FirstLine: 1906, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1924}}, + FirstLine: 1923, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5688,8 +5658,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1907}}, - FirstLine: 1907, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1924}}, + FirstLine: 1924, Super: "", }, }, @@ -5708,8 +5678,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1916}, {PC: 2, Line: 1922}, {PC: 4, Line: 1931}, {PC: 6, Line: 1935}, {PC: 8, Line: 1939}, {PC: 10, Line: 1944}, {PC: 12, Line: 1948}}, - FirstLine: 1915, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 2, Line: 1939}, {PC: 4, Line: 1948}, {PC: 6, Line: 1952}, {PC: 8, Line: 1956}, {PC: 10, Line: 1961}, {PC: 12, Line: 1965}}, + FirstLine: 1932, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5723,8 +5693,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1917}}, - FirstLine: 1916, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1934}}, + FirstLine: 1933, Super: "", }, &bytecode.ISeq{ @@ -5739,8 +5709,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 4, Line: 1924}, {PC: 8, Line: 1925}, {PC: 19, Line: 1927}}, - FirstLine: 1922, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1940}, {PC: 4, Line: 1941}, {PC: 8, Line: 1942}, {PC: 19, Line: 1944}}, + FirstLine: 1939, Super: "", }, &bytecode.ISeq{ @@ -5755,8 +5725,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1931}, {PC: 5, Line: 1932}}, - FirstLine: 1931, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1948}, {PC: 5, Line: 1949}}, + FirstLine: 1948, Super: "", }, &bytecode.ISeq{ @@ -5771,8 +5741,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1935}, {PC: 5, Line: 1936}}, - FirstLine: 1935, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1952}, {PC: 5, Line: 1953}}, + FirstLine: 1952, Super: "", }, &bytecode.ISeq{ @@ -5787,8 +5757,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1940}, {PC: 1, Line: 109}, {PC: 9, Line: 1941}}, - FirstLine: 1939, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}, {PC: 1, Line: 109}, {PC: 9, Line: 1958}}, + FirstLine: 1956, Super: "", }, &bytecode.ISeq{ @@ -5805,8 +5775,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1945}, {PC: 3, Line: 109}}, - FirstLine: 1944, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1962}, {PC: 3, Line: 109}}, + FirstLine: 1961, Super: "", }, &bytecode.ISeq{ @@ -5825,8 +5795,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1949}, {PC: 3, Line: 109}}, - FirstLine: 1948, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1966}, {PC: 3, Line: 109}}, + FirstLine: 1965, Super: "", }, }, @@ -5842,8 +5812,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1956}, {PC: 2, Line: 1960}}, - FirstLine: 1955, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1973}, {PC: 2, Line: 1977}}, + FirstLine: 1972, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5855,8 +5825,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}}, - FirstLine: 1956, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1974}}, + FirstLine: 1973, Super: "", }, &bytecode.ISeq{ @@ -5871,8 +5841,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1961}}, - FirstLine: 1960, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1978}}, + FirstLine: 1977, Super: "", }, }, @@ -5915,8 +5885,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1969}, {PC: 5, Line: 1970}, {PC: 8, Line: 1988}, {PC: 34, Line: 1995}, {PC: 38, Line: 2001}}, - FirstLine: 1968, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1986}, {PC: 5, Line: 1987}, {PC: 8, Line: 2005}, {PC: 34, Line: 2012}, {PC: 38, Line: 2018}}, + FirstLine: 1985, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5928,8 +5898,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1971}, {PC: 2, Line: 1975}}, - FirstLine: 1970, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1988}, {PC: 2, Line: 1992}}, + FirstLine: 1987, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5941,8 +5911,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1972}}, - FirstLine: 1971, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1989}}, + FirstLine: 1988, Super: "", }, &bytecode.ISeq{ @@ -5957,8 +5927,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1976}}, - FirstLine: 1975, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1993}}, + FirstLine: 1992, Super: "", }, }, @@ -5979,8 +5949,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1996}, {PC: 9, Line: 1997}}, - FirstLine: 1995, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2013}, {PC: 9, Line: 2014}}, + FirstLine: 2012, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5994,8 +5964,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1998}}, - FirstLine: 1997, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2015}}, + FirstLine: 2014, Super: "", }, }, @@ -6017,8 +5987,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2009}, {PC: 4, Line: 2010}, {PC: 7, Line: 2012}, {PC: 9, Line: 2018}, {PC: 11, Line: 2021}, {PC: 13, Line: 2023}, {PC: 15, Line: 2027}, {PC: 17, Line: 2031}, {PC: 19, Line: 2036}, {PC: 21, Line: 2039}, {PC: 23, Line: 2041}, {PC: 25, Line: 2046}, {PC: 27, Line: 2056}, {PC: 29, Line: 2060}, {PC: 31, Line: 2064}, {PC: 33, Line: 2071}, {PC: 35, Line: 2088}, {PC: 37, Line: 2090}, {PC: 39, Line: 2098}, {PC: 41, Line: 2102}, {PC: 43, Line: 2105}, {PC: 45, Line: 2107}, {PC: 47, Line: 2111}, {PC: 49, Line: 2115}, {PC: 51, Line: 2122}, {PC: 53, Line: 2128}, {PC: 55, Line: 2135}, {PC: 57, Line: 2139}, {PC: 59, Line: 2147}, {PC: 61, Line: 2156}, {PC: 63, Line: 2160}, {PC: 65, Line: 2164}, {PC: 67, Line: 2168}, {PC: 69, Line: 2172}, {PC: 71, Line: 2176}, {PC: 73, Line: 2180}}, - FirstLine: 2008, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2026}, {PC: 4, Line: 2027}, {PC: 7, Line: 2029}, {PC: 9, Line: 2035}, {PC: 11, Line: 2038}, {PC: 13, Line: 2040}, {PC: 15, Line: 2044}, {PC: 17, Line: 2048}, {PC: 19, Line: 2053}, {PC: 21, Line: 2056}, {PC: 23, Line: 2058}, {PC: 25, Line: 2063}, {PC: 27, Line: 2073}, {PC: 29, Line: 2077}, {PC: 31, Line: 2081}, {PC: 33, Line: 2088}, {PC: 35, Line: 2105}, {PC: 37, Line: 2107}, {PC: 39, Line: 2115}, {PC: 41, Line: 2119}, {PC: 43, Line: 2122}, {PC: 45, Line: 2124}, {PC: 47, Line: 2128}, {PC: 49, Line: 2132}, {PC: 51, Line: 2139}, {PC: 53, Line: 2145}, {PC: 55, Line: 2152}, {PC: 57, Line: 2156}, {PC: 59, Line: 2164}, {PC: 61, Line: 2173}, {PC: 63, Line: 2177}, {PC: 65, Line: 2181}, {PC: 67, Line: 2185}, {PC: 69, Line: 2189}, {PC: 71, Line: 2193}, {PC: 73, Line: 2197}}, + FirstLine: 2025, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6035,8 +6005,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2013}, {PC: 10, Line: 2014}, {PC: 22, Line: 2015}}, - FirstLine: 2012, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2030}, {PC: 10, Line: 2031}, {PC: 22, Line: 2032}}, + FirstLine: 2029, Super: "", }, &bytecode.ISeq{ @@ -6049,8 +6019,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2019}}, - FirstLine: 2018, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2036}}, + FirstLine: 2035, Super: "", }, &bytecode.ISeq{ @@ -6067,8 +6037,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2024}}, - FirstLine: 2023, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2041}}, + FirstLine: 2040, Super: "", }, &bytecode.ISeq{ @@ -6081,8 +6051,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2028}}, - FirstLine: 2027, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2045}}, + FirstLine: 2044, Super: "", }, &bytecode.ISeq{ @@ -6095,8 +6065,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2032}, {PC: 3, Line: 2033}}, - FirstLine: 2031, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2049}, {PC: 3, Line: 2050}}, + FirstLine: 2048, Super: "", }, &bytecode.ISeq{ @@ -6111,8 +6081,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2037}}, - FirstLine: 2036, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, + FirstLine: 2053, Super: "", }, &bytecode.ISeq{ @@ -6127,8 +6097,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2042}, {PC: 5, Line: 259}, {PC: 10, Line: 2043}}, - FirstLine: 2041, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2059}, {PC: 5, Line: 259}, {PC: 10, Line: 2060}}, + FirstLine: 2058, Super: "", }, &bytecode.ISeq{ @@ -6141,8 +6111,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2047}}, - FirstLine: 2046, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2064}}, + FirstLine: 2063, Super: "", }, &bytecode.ISeq{ @@ -6155,8 +6125,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2057}}, - FirstLine: 2056, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2074}}, + FirstLine: 2073, Super: "", }, &bytecode.ISeq{ @@ -6169,8 +6139,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2061}}, - FirstLine: 2060, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2078}}, + FirstLine: 2077, Super: "", }, &bytecode.ISeq{ @@ -6183,8 +6153,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2065}}, - FirstLine: 2064, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2082}}, + FirstLine: 2081, Super: "", }, &bytecode.ISeq{ @@ -6199,8 +6169,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2072}, {PC: 12, Line: 2073}}, - FirstLine: 2071, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2089}, {PC: 12, Line: 2090}}, + FirstLine: 2088, Super: "", }, &bytecode.ISeq{ @@ -6215,8 +6185,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2092}, {PC: 6, Line: 2093}}, - FirstLine: 2090, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2109}, {PC: 6, Line: 2110}}, + FirstLine: 2107, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6229,8 +6199,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2092}}, - FirstLine: 2092, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2109}}, + FirstLine: 2109, Super: "", }, }, @@ -6251,8 +6221,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2098}, {PC: 5, Line: 2099}}, - FirstLine: 2098, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2115}, {PC: 5, Line: 2116}}, + FirstLine: 2115, Super: "", }, &bytecode.ISeq{ @@ -6265,8 +6235,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2103}}, - FirstLine: 2102, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2120}}, + FirstLine: 2119, Super: "", }, &bytecode.ISeq{ @@ -6279,8 +6249,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2108}}, - FirstLine: 2107, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2125}}, + FirstLine: 2124, Super: "", }, &bytecode.ISeq{ @@ -6293,8 +6263,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2112}}, - FirstLine: 2111, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2129}}, + FirstLine: 2128, Super: "", }, &bytecode.ISeq{ @@ -6310,8 +6280,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2116}, {PC: 10, Line: 2117}}, - FirstLine: 2115, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2133}, {PC: 10, Line: 2134}}, + FirstLine: 2132, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6324,8 +6294,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2117}}, - FirstLine: 2117, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2134}}, + FirstLine: 2134, Super: "", }, }, @@ -6344,8 +6314,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2123}, {PC: 10, Line: 2124}, {PC: 15, Line: 109}}, - FirstLine: 2122, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2140}, {PC: 10, Line: 2141}, {PC: 15, Line: 109}}, + FirstLine: 2139, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6359,8 +6329,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2124}}, - FirstLine: 2124, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2141}}, + FirstLine: 2141, Super: "", }, }, @@ -6379,8 +6349,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2129}, {PC: 10, Line: 2130}, {PC: 15, Line: 109}}, - FirstLine: 2128, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2146}, {PC: 10, Line: 2147}, {PC: 15, Line: 109}}, + FirstLine: 2145, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6394,8 +6364,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2130}}, - FirstLine: 2130, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2147}}, + FirstLine: 2147, Super: "", }, }, @@ -6411,8 +6381,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2136}}, - FirstLine: 2135, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2153}}, + FirstLine: 2152, Super: "", }, &bytecode.ISeq{ @@ -6427,8 +6397,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2140}}, - FirstLine: 2139, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, + FirstLine: 2156, Super: "", }, &bytecode.ISeq{ @@ -6443,8 +6413,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2148}, {PC: 12, Line: 2149}}, - FirstLine: 2147, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}, {PC: 12, Line: 2166}}, + FirstLine: 2164, Super: "", }, &bytecode.ISeq{ @@ -6459,8 +6429,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, - FirstLine: 2156, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2174}}, + FirstLine: 2173, Super: "", }, &bytecode.ISeq{ @@ -6475,8 +6445,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2161}}, - FirstLine: 2160, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2178}}, + FirstLine: 2177, Super: "", }, &bytecode.ISeq{ @@ -6491,8 +6461,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}}, - FirstLine: 2164, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2182}}, + FirstLine: 2181, Super: "", }, &bytecode.ISeq{ @@ -6505,8 +6475,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2169}}, - FirstLine: 2168, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2186}}, + FirstLine: 2185, Super: "", }, &bytecode.ISeq{ @@ -6519,8 +6489,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2173}}, - FirstLine: 2172, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2190}}, + FirstLine: 2189, Super: "", }, &bytecode.ISeq{ @@ -6533,8 +6503,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2177}}, - FirstLine: 2176, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2194}}, + FirstLine: 2193, Super: "", }, &bytecode.ISeq{ @@ -6549,8 +6519,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2181}}, - FirstLine: 2180, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2198}}, + FirstLine: 2197, Super: "", }, }, @@ -6566,8 +6536,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2191}, {PC: 2, Line: 2202}}, - FirstLine: 2189, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2208}, {PC: 2, Line: 2219}}, + FirstLine: 2206, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6579,8 +6549,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2194}}, - FirstLine: 2191, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2211}}, + FirstLine: 2208, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6592,8 +6562,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2195}}, - FirstLine: 2194, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2212}}, + FirstLine: 2211, Super: "", }, }, @@ -6615,8 +6585,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2203}, {PC: 4, Line: 2204}}, - FirstLine: 2202, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2220}, {PC: 4, Line: 2221}}, + FirstLine: 2219, Super: "", }, }, @@ -6638,8 +6608,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2234}, {PC: 5, Line: 2235}, {PC: 10, Line: 2241}, {PC: 12, Line: 2254}, {PC: 14, Line: 2261}, {PC: 16, Line: 2270}, {PC: 18, Line: 2274}, {PC: 21, Line: 2278}}, - FirstLine: 2232, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2251}, {PC: 5, Line: 2252}, {PC: 10, Line: 2258}, {PC: 12, Line: 2271}, {PC: 14, Line: 2278}, {PC: 16, Line: 2287}, {PC: 18, Line: 2291}, {PC: 21, Line: 2295}}, + FirstLine: 2249, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6660,8 +6630,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2241}, {PC: 2, Line: 259}, {PC: 13, Line: 2243}, {PC: 16, Line: 2244}, {PC: 19, Line: 2248}}, - FirstLine: 2241, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2258}, {PC: 2, Line: 259}, {PC: 13, Line: 2260}, {PC: 16, Line: 2261}, {PC: 19, Line: 2265}}, + FirstLine: 2258, Super: "", }, &bytecode.ISeq{ @@ -6679,8 +6649,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2254}, {PC: 6, Line: 2255}}, - FirstLine: 2254, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2271}, {PC: 6, Line: 2272}}, + FirstLine: 2271, Super: "", }, &bytecode.ISeq{ @@ -6695,8 +6665,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2262}, {PC: 4, Line: 2263}, {PC: 7, Line: 2266}}, - FirstLine: 2261, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}, {PC: 4, Line: 2280}, {PC: 7, Line: 2283}}, + FirstLine: 2278, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6710,8 +6680,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2264}}, - FirstLine: 2263, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2281}}, + FirstLine: 2280, Super: "", }, }, @@ -6729,8 +6699,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2270}, {PC: 6, Line: 2271}}, - FirstLine: 2270, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2287}, {PC: 6, Line: 2288}}, + FirstLine: 2287, Super: "", }, &bytecode.ISeq{ @@ -6742,8 +6712,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, - FirstLine: 2278, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2296}}, + FirstLine: 2295, Super: "", }, }, @@ -6759,8 +6729,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2299}, {PC: 2, Line: 2368}}, - FirstLine: 2298, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2316}, {PC: 2, Line: 2385}}, + FirstLine: 2315, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6772,8 +6742,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2302}, {PC: 2, Line: 2309}, {PC: 4, Line: 2316}, {PC: 6, Line: 2325}, {PC: 8, Line: 2338}}, - FirstLine: 2299, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2319}, {PC: 2, Line: 2326}, {PC: 4, Line: 2333}, {PC: 6, Line: 2342}, {PC: 8, Line: 2355}}, + FirstLine: 2316, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6788,8 +6758,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2303}, {PC: 4, Line: 2304}}, - FirstLine: 2302, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2320}, {PC: 4, Line: 2321}}, + FirstLine: 2319, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6803,8 +6773,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2305}}, - FirstLine: 2304, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2322}}, + FirstLine: 2321, Super: "", }, }, @@ -6822,8 +6792,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2310}}, - FirstLine: 2309, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2327}}, + FirstLine: 2326, Super: "", }, &bytecode.ISeq{ @@ -6850,8 +6820,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2317}}, - FirstLine: 2316, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2334}}, + FirstLine: 2333, Super: "", }, &bytecode.ISeq{ @@ -6873,8 +6843,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2326}, {PC: 14, Line: 2327}, {PC: 19, Line: 1}, {PC: 27, Line: 2328}, {PC: 32, Line: 1}, {PC: 44, Line: 2330}, {PC: 45, Line: 1}}, - FirstLine: 2325, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2343}, {PC: 14, Line: 2344}, {PC: 19, Line: 1}, {PC: 27, Line: 2345}, {PC: 32, Line: 1}, {PC: 44, Line: 2347}, {PC: 45, Line: 1}}, + FirstLine: 2342, Super: "", }, &bytecode.ISeq{ @@ -6892,8 +6862,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}, {PC: 3, Line: 2340}, {PC: 7, Line: 2352}, {PC: 10, Line: 2353}, {PC: 13, Line: 2355}, {PC: 17, Line: 2356}, {PC: 22, Line: 2359}}, - FirstLine: 2338, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2356}, {PC: 3, Line: 2357}, {PC: 7, Line: 2369}, {PC: 10, Line: 2370}, {PC: 13, Line: 2372}, {PC: 17, Line: 2373}, {PC: 22, Line: 2376}}, + FirstLine: 2355, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6912,8 +6882,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2341}, {PC: 4, Line: 2342}, {PC: 8, Line: 2343}, {PC: 13, Line: 2344}, {PC: 24, Line: 2345}, {PC: 42, Line: 2347}, {PC: 50, Line: 2349}}, - FirstLine: 2340, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2358}, {PC: 4, Line: 2359}, {PC: 8, Line: 2360}, {PC: 13, Line: 2361}, {PC: 24, Line: 2362}, {PC: 42, Line: 2364}, {PC: 50, Line: 2366}}, + FirstLine: 2357, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6929,8 +6899,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2345}}, - FirstLine: 2345, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2362}}, + FirstLine: 2362, Super: "", }, }, @@ -6948,8 +6918,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2352}}, - FirstLine: 2352, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2369}}, + FirstLine: 2369, Super: "", }, &bytecode.ISeq{ @@ -6964,8 +6934,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2353}}, - FirstLine: 2353, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2370}}, + FirstLine: 2370, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6979,8 +6949,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2353}}, - FirstLine: 2353, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2370}}, + FirstLine: 2370, Super: "", }, }, @@ -6998,8 +6968,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2357}}, - FirstLine: 2356, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2374}}, + FirstLine: 2373, Super: "", }, }, @@ -7021,8 +6991,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2369}, {PC: 4, Line: 2373}, {PC: 6, Line: 2382}}, - FirstLine: 2368, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2386}, {PC: 4, Line: 2390}, {PC: 6, Line: 2399}}, + FirstLine: 2385, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7036,8 +7006,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 2, Line: 259}, {PC: 5, Line: 2374}, {PC: 18, Line: 2375}}, - FirstLine: 2373, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2390}, {PC: 2, Line: 259}, {PC: 5, Line: 2391}, {PC: 18, Line: 2392}}, + FirstLine: 2390, Super: "", }, &bytecode.ISeq{ @@ -7056,8 +7026,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2382}, {PC: 11, Line: 2383}, {PC: 14, Line: 2384}, {PC: 17, Line: 2385}}, - FirstLine: 2382, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2399}, {PC: 11, Line: 2400}, {PC: 14, Line: 2401}, {PC: 17, Line: 2402}}, + FirstLine: 2399, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7071,8 +7041,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2384}}, - FirstLine: 2384, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2401}}, + FirstLine: 2401, Super: "", }, }, @@ -7094,8 +7064,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2409}, {PC: 2, Line: 2422}, {PC: 4, Line: 2462}}, - FirstLine: 2408, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2426}, {PC: 2, Line: 2439}, {PC: 4, Line: 2479}}, + FirstLine: 2425, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7107,8 +7077,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2412}}, - FirstLine: 2409, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2429}}, + FirstLine: 2426, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7134,8 +7104,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2413}}, - FirstLine: 2412, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}}, + FirstLine: 2429, Super: "", }, }, @@ -7171,8 +7141,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2423}, {PC: 22, Line: 2427}}, - FirstLine: 2422, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2440}, {PC: 22, Line: 2444}}, + FirstLine: 2439, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7189,8 +7159,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2428}, {PC: 3, Line: 2429}, {PC: 6, Line: 2444}, {PC: 10, Line: 2445}, {PC: 15, Line: 2455}}, - FirstLine: 2427, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2445}, {PC: 3, Line: 2446}, {PC: 6, Line: 2461}, {PC: 10, Line: 2462}, {PC: 15, Line: 2472}}, + FirstLine: 2444, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7211,8 +7181,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}, {PC: 4, Line: 2431}, {PC: 14, Line: 2432}, {PC: 21, Line: 2434}, {PC: 26, Line: 2435}, {PC: 42, Line: 2436}, {PC: 54, Line: 2438}, {PC: 59, Line: 2439}, {PC: 72, Line: 2441}}, - FirstLine: 2429, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2447}, {PC: 4, Line: 2448}, {PC: 14, Line: 2449}, {PC: 21, Line: 2451}, {PC: 26, Line: 2452}, {PC: 42, Line: 2453}, {PC: 54, Line: 2455}, {PC: 59, Line: 2456}, {PC: 72, Line: 2458}}, + FirstLine: 2446, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7230,8 +7200,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2432}}, - FirstLine: 2432, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2449}}, + FirstLine: 2449, Super: "", }, }, @@ -7255,8 +7225,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2446}, {PC: 5, Line: 2447}, {PC: 9, Line: 2448}, {PC: 27, Line: 2450}, {PC: 35, Line: 2452}, {PC: 37, Line: 1}}, - FirstLine: 2445, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2463}, {PC: 5, Line: 2464}, {PC: 9, Line: 2465}, {PC: 27, Line: 2467}, {PC: 35, Line: 2469}, {PC: 37, Line: 1}}, + FirstLine: 2462, Super: "", }, }, @@ -7278,8 +7248,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2463}, {PC: 4, Line: 2467}, {PC: 6, Line: 2475}}, - FirstLine: 2462, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2480}, {PC: 4, Line: 2484}, {PC: 6, Line: 2492}}, + FirstLine: 2479, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7293,8 +7263,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2467}, {PC: 2, Line: 259}, {PC: 5, Line: 2468}, {PC: 18, Line: 2469}}, - FirstLine: 2467, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2484}, {PC: 2, Line: 259}, {PC: 5, Line: 2485}, {PC: 18, Line: 2486}}, + FirstLine: 2484, Super: "", }, &bytecode.ISeq{ @@ -7313,8 +7283,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2475}, {PC: 11, Line: 2476}, {PC: 14, Line: 2477}, {PC: 17, Line: 2478}}, - FirstLine: 2475, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2492}, {PC: 11, Line: 2493}, {PC: 14, Line: 2494}, {PC: 17, Line: 2495}}, + FirstLine: 2492, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7328,8 +7298,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2477}}, - FirstLine: 2477, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2494}}, + FirstLine: 2494, Super: "", }, }, @@ -7362,8 +7332,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}, {PC: 2, Line: 2532}, {PC: 4, Line: 2535}, {PC: 6, Line: 2538}, {PC: 8, Line: 2541}, {PC: 10, Line: 2544}, {PC: 12, Line: 2547}, {PC: 14, Line: 2551}}, - FirstLine: 2510, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2528}, {PC: 2, Line: 2549}, {PC: 4, Line: 2552}, {PC: 6, Line: 2555}, {PC: 8, Line: 2558}, {PC: 10, Line: 2561}, {PC: 12, Line: 2564}, {PC: 14, Line: 2568}}, + FirstLine: 2527, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7378,8 +7348,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2512}, {PC: 4, Line: 2513}, {PC: 6, Line: 2520}, {PC: 8, Line: 2521}, {PC: 10, Line: 2522}, {PC: 12, Line: 2525}, {PC: 14, Line: 2526}}, - FirstLine: 2511, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2529}, {PC: 4, Line: 2530}, {PC: 6, Line: 2537}, {PC: 8, Line: 2538}, {PC: 10, Line: 2539}, {PC: 12, Line: 2542}, {PC: 14, Line: 2543}}, + FirstLine: 2528, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7397,8 +7367,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2514}, {PC: 3, Line: 2518}}, - FirstLine: 2513, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2531}, {PC: 3, Line: 2535}}, + FirstLine: 2530, Super: "", }, &bytecode.ISeq{ @@ -7413,8 +7383,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2520}}, - FirstLine: 2520, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2537}}, + FirstLine: 2537, Super: "", }, &bytecode.ISeq{ @@ -7428,7 +7398,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2521, + FirstLine: 2538, Super: "", }, &bytecode.ISeq{ @@ -7445,8 +7415,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2523}}, - FirstLine: 2522, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2540}}, + FirstLine: 2539, Super: "", }, &bytecode.ISeq{ @@ -7464,8 +7434,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2527}, {PC: 9, Line: 2528}}, - FirstLine: 2526, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2544}, {PC: 9, Line: 2545}}, + FirstLine: 2543, Super: "", }, }, @@ -7481,8 +7451,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, - FirstLine: 2532, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2550}}, + FirstLine: 2549, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7496,8 +7466,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, - FirstLine: 2533, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2550}}, + FirstLine: 2550, Super: "", }, }, @@ -7513,8 +7483,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2536}}, - FirstLine: 2535, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}}, + FirstLine: 2552, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7528,8 +7498,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2536}}, - FirstLine: 2536, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}}, + FirstLine: 2553, Super: "", }, }, @@ -7545,8 +7515,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2539}}, - FirstLine: 2538, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2556}}, + FirstLine: 2555, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7560,8 +7530,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2539}}, - FirstLine: 2539, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2556}}, + FirstLine: 2556, Super: "", }, }, @@ -7577,8 +7547,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2542}}, - FirstLine: 2541, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2559}}, + FirstLine: 2558, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7592,8 +7562,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2542}}, - FirstLine: 2542, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2559}}, + FirstLine: 2559, Super: "", }, }, @@ -7609,8 +7579,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}}, - FirstLine: 2544, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2562}}, + FirstLine: 2561, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7624,8 +7594,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}}, - FirstLine: 2545, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2562}}, + FirstLine: 2562, Super: "", }, }, @@ -7641,8 +7611,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}}, - FirstLine: 2547, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2565}}, + FirstLine: 2564, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7656,8 +7626,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}}, - FirstLine: 2548, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2565}}, + FirstLine: 2565, Super: "", }, }, @@ -7679,8 +7649,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2568}, {PC: 4, Line: 2570}, {PC: 6, Line: 2591}, {PC: 8, Line: 2622}, {PC: 10, Line: 2628}, {PC: 12, Line: 2637}, {PC: 14, Line: 2652}, {PC: 16, Line: 2659}, {PC: 18, Line: 2663}, {PC: 20, Line: 2670}, {PC: 22, Line: 2672}, {PC: 24, Line: 2676}, {PC: 26, Line: 2680}}, - FirstLine: 2567, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2585}, {PC: 4, Line: 2587}, {PC: 6, Line: 2608}, {PC: 8, Line: 2639}, {PC: 10, Line: 2645}, {PC: 12, Line: 2654}, {PC: 14, Line: 2669}, {PC: 16, Line: 2676}, {PC: 18, Line: 2680}, {PC: 20, Line: 2687}, {PC: 22, Line: 2689}, {PC: 24, Line: 2693}, {PC: 26, Line: 2697}}, + FirstLine: 2584, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7696,8 +7666,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2571}}, - FirstLine: 2570, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2588}}, + FirstLine: 2587, Super: "", }, &bytecode.ISeq{ @@ -7722,8 +7692,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: 2591}, {PC: 7, Line: 259}, {PC: 15, Line: 2592}, {PC: 19, Line: 2593}, {PC: 36, Line: 2594}, {PC: 44, Line: 259}, {PC: 47, Line: 2596}, {PC: 50, Line: 2604}, {PC: 62, Line: 2605}, {PC: 65, Line: 2606}, {PC: 68, Line: 2607}, {PC: 76, Line: 2608}, {PC: 92, Line: 2609}, {PC: 94, Line: 2610}, {PC: 95, Line: 109}, {PC: 98, Line: 2613}, {PC: 101, Line: 2614}, {PC: 105, Line: 2613}, {PC: 108, Line: 2614}}, - FirstLine: 2591, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2608}, {PC: 7, Line: 259}, {PC: 15, Line: 2609}, {PC: 19, Line: 2610}, {PC: 36, Line: 2611}, {PC: 44, Line: 259}, {PC: 47, Line: 2613}, {PC: 50, Line: 2621}, {PC: 62, Line: 2622}, {PC: 65, Line: 2623}, {PC: 68, Line: 2624}, {PC: 76, Line: 2625}, {PC: 92, Line: 2626}, {PC: 94, Line: 2627}, {PC: 95, Line: 109}, {PC: 98, Line: 2630}, {PC: 101, Line: 2631}, {PC: 105, Line: 2630}, {PC: 108, Line: 2631}}, + FirstLine: 2608, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7742,8 +7712,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2597}, {PC: 25, Line: 2598}, {PC: 31, Line: 2599}, {PC: 36, Line: 2600}, {PC: 39, Line: 2601}}, - FirstLine: 2596, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2614}, {PC: 25, Line: 2615}, {PC: 31, Line: 2616}, {PC: 36, Line: 2617}, {PC: 39, Line: 2618}}, + FirstLine: 2613, Super: "", }, &bytecode.ISeq{ @@ -7761,8 +7731,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2606}}, - FirstLine: 2606, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2623}}, + FirstLine: 2623, Super: "", }, }, @@ -7781,8 +7751,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2623}, {PC: 16, Line: 2624}, {PC: 19, Line: 2625}}, - FirstLine: 2622, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}, {PC: 16, Line: 2641}, {PC: 19, Line: 2642}}, + FirstLine: 2639, Super: "", }, &bytecode.ISeq{ @@ -7797,8 +7767,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2629}}, - FirstLine: 2628, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2646}}, + FirstLine: 2645, Super: "", }, &bytecode.ISeq{ @@ -7816,8 +7786,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2637}, {PC: 7, Line: 259}, {PC: 10, Line: 2638}, {PC: 13, Line: 2639}, {PC: 16, Line: 2640}, {PC: 32, Line: 2641}, {PC: 34, Line: 2642}, {PC: 35, Line: 2643}, {PC: 39, Line: 2645}, {PC: 42, Line: 2646}, {PC: 46, Line: 2645}, {PC: 49, Line: 2646}, {PC: 56, Line: 2649}}, - FirstLine: 2637, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2654}, {PC: 7, Line: 259}, {PC: 10, Line: 2655}, {PC: 13, Line: 2656}, {PC: 16, Line: 2657}, {PC: 32, Line: 2658}, {PC: 34, Line: 2659}, {PC: 35, Line: 2660}, {PC: 39, Line: 2662}, {PC: 42, Line: 2663}, {PC: 46, Line: 2662}, {PC: 49, Line: 2663}, {PC: 56, Line: 2666}}, + FirstLine: 2654, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7834,8 +7804,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2639}}, - FirstLine: 2639, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2656}}, + FirstLine: 2656, Super: "", }, }, @@ -7853,8 +7823,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2652}, {PC: 5, Line: 2653}, {PC: 17, Line: 2654}, {PC: 20, Line: 2655}, {PC: 27, Line: 259}}, - FirstLine: 2652, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2669}, {PC: 5, Line: 2670}, {PC: 17, Line: 2671}, {PC: 20, Line: 2672}, {PC: 27, Line: 259}}, + FirstLine: 2669, Super: "", }, &bytecode.ISeq{ @@ -7867,8 +7837,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2660}}, - FirstLine: 2659, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2677}}, + FirstLine: 2676, Super: "", }, &bytecode.ISeq{ @@ -7881,8 +7851,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2664}, {PC: 8, Line: 2665}, {PC: 14, Line: 259}}, - FirstLine: 2663, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2681}, {PC: 8, Line: 2682}, {PC: 14, Line: 259}}, + FirstLine: 2680, Super: "", }, &bytecode.ISeq{ @@ -7900,8 +7870,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2673}}, - FirstLine: 2672, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2690}}, + FirstLine: 2689, Super: "", }, &bytecode.ISeq{ @@ -7916,8 +7886,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2676}, {PC: 5, Line: 2677}}, - FirstLine: 2676, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2693}, {PC: 5, Line: 2694}}, + FirstLine: 2693, Super: "", }, &bytecode.ISeq{ @@ -7932,8 +7902,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2681}, {PC: 8, Line: 2682}, {PC: 19, Line: 2684}}, - FirstLine: 2680, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2698}, {PC: 8, Line: 2699}, {PC: 19, Line: 2701}}, + FirstLine: 2697, Super: "", }, }, @@ -7955,8 +7925,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2693}, {PC: 11, Line: 109}, {PC: 14, Line: 2733}, {PC: 16, Line: 2737}, {PC: 17, Line: 109}}, - FirstLine: 2692, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2710}, {PC: 11, Line: 109}, {PC: 14, Line: 2750}, {PC: 16, Line: 2754}, {PC: 17, Line: 109}}, + FirstLine: 2709, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7968,8 +7938,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2703}, {PC: 2, Line: 2715}, {PC: 4, Line: 2726}}, - FirstLine: 2700, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2720}, {PC: 2, Line: 2732}, {PC: 4, Line: 2743}}, + FirstLine: 2717, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7989,8 +7959,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2704}, {PC: 5, Line: 2705}, {PC: 17, Line: 2707}, {PC: 22, Line: 2708}, {PC: 33, Line: 2710}}, - FirstLine: 2703, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2721}, {PC: 5, Line: 2722}, {PC: 17, Line: 2724}, {PC: 22, Line: 2725}, {PC: 33, Line: 2727}}, + FirstLine: 2720, Super: "", }, &bytecode.ISeq{ @@ -8011,8 +7981,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2716}, {PC: 5, Line: 2717}, {PC: 17, Line: 2719}, {PC: 22, Line: 2720}, {PC: 33, Line: 2722}}, - FirstLine: 2715, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2733}, {PC: 5, Line: 2734}, {PC: 17, Line: 2736}, {PC: 22, Line: 2737}, {PC: 33, Line: 2739}}, + FirstLine: 2732, Super: "", }, &bytecode.ISeq{ @@ -8025,8 +7995,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2727}}, - FirstLine: 2726, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2744}}, + FirstLine: 2743, Super: "", }, }, @@ -8046,8 +8016,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2733}, {PC: 2, Line: 259}, {PC: 5, Line: 2734}, {PC: 9, Line: 259}}, - FirstLine: 2733, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2750}, {PC: 2, Line: 259}, {PC: 5, Line: 2751}, {PC: 9, Line: 259}}, + FirstLine: 2750, Super: "", }, }, @@ -8063,8 +8033,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2751}}, - FirstLine: 2750, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2768}}, + FirstLine: 2767, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8079,7 +8049,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2751, + FirstLine: 2768, Super: "", }, }, diff --git a/internal/vm/set_divide_test.go b/internal/vm/set_divide_test.go new file mode 100644 index 00000000..f248c74f --- /dev/null +++ b/internal/vm/set_divide_test.go @@ -0,0 +1,100 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import "testing" + +// ⛔ Ruby 4.0 replaced the ALGORITHM behind Set#divide with a 2-arity block, not +// just the pattern of yields. rbgo ran Tarjan's strongly-connected components +// over the full n x n relation — what MRI's lib/set.rb did up to 3.x. +// set_divide_arity2 (set.c:923 at v4.0.9) is union-find over each UNORDERED pair +// once, merging i and j only when the block is truthy BOTH ways. +// +// ruby/spec sees only the yields and asserts them both ways five lines apart +// (core/set/divide_spec.rb:35 from 4.0, :43 below it). It cannot see the other +// three divergences this file pins; every row was measured on MRI 4.0.7. +func TestSetDivideWithATwoArityBlockIsUnionFindOverMutualPairs(t *testing.T) { + const pre = "require \"set\"\n" + for _, tc := range []struct{ name, src, want string }{ + // --- the yields, which is all the spec example checks --- + {"each unordered pair once, both orders", pre + `ret = [] +Set[1, 2, 3].divide { |x, y| ret << [x, y] } +p ret`, `[[1, 2], [2, 1], [1, 3], [3, 1], [2, 3], [3, 2]]`}, + {"no self-pair is ever yielded", pre + `ret = [] +Set[1, 2].divide { |x, y| ret << [x, y] } +p ret.sort`, `[[1, 2], [2, 1]]`}, + + // ⛔ The && SHORT-CIRCUITS (set.c:940). A falsy first answer means the + // reversed pair is never yielded. The spec cannot see this: its block + // body is `ret << [x, y]`, which returns the Array and is truthy. + {"a falsy block yields once per pair, not twice", pre + `ret = [] +Set[1, 2, 3].divide { |x, y| ret << [x, y]; false } +p ret`, `[[1, 2], [1, 3], [2, 3]]`}, + + // ⛔ A one-element Set has no pairs at all, so the block is never called. + // rbgo called it once, with the element against itself. + {"a single element yields nothing", pre + `n = 0 +Set[1].divide { |x, y| n += 1; true } +p n`, `0`}, + {"an empty Set yields nothing", pre + `n = 0 +Set[].divide { |x, y| n += 1; true } +p n`, `0`}, + + // ⛔⛔ The RESULT changed too, and no spec covers it. A directed cycle + // 1->2->3->1 with no reverse edge is ONE strongly-connected component and + // has no mutually-related pair at all. SCC answers [[1, 2, 3]]; + // union-find answers three singletons, and 4.0.7 answers the latter. + {"a directed cycle does not merge", pre + `f = ->(x, y) { [[1, 2], [2, 3], [3, 1]].include?([x, y]) } +p Set[1, 2, 3].divide(&f).map { |s| s.to_a.sort }.sort`, `[[1], [2], [3]]`}, + {"one-way truthiness does not merge", pre + `p Set[1, 2].divide { |x, y| x < y }.map { |s| s.to_a.sort }.sort`, + `[[1], [2]]`}, + {"mutual truthiness merges", pre + `p Set[1, 2].divide { |x, y| true }.map { |s| s.to_a.sort }.sort`, + `[[1, 2]]`}, + // The union is transitive even though 1 and 3 are unrelated. + {"the union is transitive", pre + `f = ->(x, y) { [[1, 2], [2, 1], [2, 3], [3, 2]].include?([x, y]) } +p Set[1, 2, 3].divide(&f).map { |s| s.to_a.sort }.sort`, `[[1, 2, 3]]`}, + {"a mutual pair keeps an unrelated element out", pre + `f = ->(x, y) { [[1, 2], [2, 1], [2, 3]].include?([x, y]) } +p Set[1, 2, 3].divide(&f).map { |s| s.to_a.sort }.sort`, `[[1, 2], [3]]`}, + + // The example from the spec and from MRI's own docs, which must not move. + {"the adjacency division", pre + `p Set[1, 3, 4, 6, 9, 10, 11].divide { |x, y| (x - y).abs == 1 }.map { |s| s.to_a.sort }.sort`, + `[[1], [3, 4], [6], [9, 10, 11]]`}, + + // --- controls: the arity-1 path is a different function entirely --- + {"arity 1 groups by block value", pre + `p Set[1, 2, 3, 4].divide { |x| x % 2 }.map { |s| s.to_a.sort }.sort`, + `[[1, 3], [2, 4]]`}, + {"arity 1 yields once per element", pre + `n = 0 +Set[1, 2, 3, 4].divide { |x| n += 1; x % 2 } +p n`, `4`}, + // Arity > 2 and -1 take the arity-1 path: only the first element arrives. + {"arity 3 takes the one-argument path", pre + `seen = [] +Set["one", "two", "three"].divide { |x, y, z| seen << [x, y, z]; x.length } +p seen.sort`, `[["one", nil, nil], ["three", nil, nil], ["two", nil, nil]]`}, + {"arity -1 receives one element", pre + `sizes = [] +Set["one", "two", "three"].divide { |*xs| sizes << xs.size; xs.first.length } +p sizes`, `[1, 1, 1]`}, + + // The enumerator form, and the outer Set's class on BOTH paths — + // set_i_divide builds it with rb_cSet (set.c:1002), as does + // set_divide_arity2 (set.c:946). + {"no block gives an Enumerator", pre + `p Set[1, 2, 3, 4].divide.class`, `Enumerator`}, + {"the enumerator divides", pre + `p Set[1, 2, 3, 4].divide.each { |a, b| (a + b).even? }.map { |s| s.to_a.sort }.sort`, + `[[1, 3], [2, 4]]`}, + {"the outer Set is a plain Set, arity 2", pre + `p Set[1, 2].divide { |x, y| false }.class`, `Set`}, + {"the outer Set is a plain Set, arity 1", pre + `p Set[1, 2].divide { |x| x }.class`, `Set`}, + + // compare_by_identity is not retained by the outer Set + // (core/set/divide_spec.rb:21). + {"the outer Set drops compare_by_identity", pre + `s = Set.new.compare_by_identity +s << "a" << "b" +p s.divide { |x, y| false }.compare_by_identity?`, `false`}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := runSrc(t, tc.src); got != tc.want { + t.Errorf("%s\n got %s\nwant %s", tc.src, got, tc.want) + } + }) + } +}