From ad4d6053bf22ee217551cf7fde0ad8f42eb7fd7e Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 8 Nov 2026 10:20:09 +0100 Subject: [PATCH] A Set subclass reports its own class (closes #903) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit class Sub < Set; end Sub[1, 2].class # MRI: Sub rbgo: Set ## ⛔ The cause this issue named was not the cause #903 blamed Set.new and Set.[] for ignoring their receiver. They did, and fixing that alone would have changed NOTHING observable: type Set struct { h *object.Hash iterating int } case *Set: return vm.cSet There was no class field, so classOf could not answer anything else. The class was UNREPRESENTABLE, not discarded — a constructor honouring its receiver would have handed a class to a struct with nowhere to put it. The issue's diagnosis is corrected in a comment there. ## The change One allocation point (set.go:65), so: a `cls *RClass` field (nil means Set, so every existing allocation is untouched), classOf reading it, the receiver honoured in both smethods, and dup carrying it. ## ⛔⛔ MRI's asymmetry comes out FOR FREE, which is why it is tested The SUBSETS classify/divide build take the receiver's class (set.c:890, :953) while the OUTER Set those two return is always rb_cSet (set.c:946, :1002). The prelude already wrote `self.class.new` for the subsets (prelude.rb:1258, :1276, :1442, :1519) and a bare `Set.new` for divide's outer set, and `|` is `dup`. So one field plus one read produced MRI's whole shape with no prelude change. Behaviour that is correct by accident of another change is behaviour nobody is holding in place, so it is asserted. ## ⛔ And the change UNMASKED a divergence of its own making def to_set # prelude.rb:1563, before self end While every Set reported Set, returning self answered Set whatever the receiver was — matching MRI BY ACCIDENT. Giving a subclass its own class turned that accident into a divergence (`Sub[1,2].to_set` -> Sub, MRI says Set). That is a regression this change caused, so it is fixed here rather than deferred, with MRI's own form: def to_set(klass = Set, *args, &block) return self if instance_of?(Set) && klass == Set && block.nil? && args.empty? klass.new(self, *args, &block) end It also closes an arity gap the one-line version had: `to_set(Sub)` raised ArgumentError (given 1, expected 0). ## Measured cmd/oracle against /opt/homebrew/opt/ruby@4.0/bin/ruby (ruby 4.0.7, +PRISM): 16 rows on subclass propagation, "2 engines AGREED, byte for byte"; 8 rows on to_set, stdout identical. ⛔ The two engines printed the SAME NUMBER OF BYTES (88 vs 88) on the first run of the subclass probe while differing in content — Sub and Set are both three letters. A comparison by length would have called it parity. ## Negative control, and what it says about the rows Disabling classOf's read of cls fails 8 of the 12 test rows. The 4 that do not are named in the test with the reason: two are controls, and two ("the outer Set of divide stays a plain Set", "a block makes to_set build a new Set") answer Set in BOTH states. Those two cannot discriminate against the pre-fix engine — they guard the OPPOSITE direction, a later change that over-propagated the class. Said in the file, because a reader running the same experiment would otherwise read them as redundant and delete the only guard on the asymmetry. ## Not fixed here, to be filed `[1, 2].to_set(Sub)` — Enumerable#to_set with arguments — emits "warning: passing arguments to Enumerable#to_set is deprecated" on MRI and nothing here. rbgo never emitted it, before or after, so it is pre-existing and unrelated; a plain `Set[1,2].to_set(Sub)` does not warn. go test ./... : 14 packages ok, 0 failures. Closes #903 Co-Authored-By: Claude Opus 5 --- internal/vm/object_model.go | 7 + internal/vm/prelude.rb | 21 +- internal/vm/prelude_frozen_gen.go | 817 +++++++++++++++--------------- internal/vm/set.go | 35 +- internal/vm/set_subclass_test.go | 123 +++++ 5 files changed, 592 insertions(+), 411 deletions(-) create mode 100644 internal/vm/set_subclass_test.go diff --git a/internal/vm/object_model.go b/internal/vm/object_model.go index b484a7f4..10dcee3c 100644 --- a/internal/vm/object_model.go +++ b/internal/vm/object_model.go @@ -1255,6 +1255,13 @@ func (vm *VM) classOf(v object.Value) *RClass { // Logger::Formatter, whose #call renders one line through the library. return vm.cLoggerFormatter case *Set: + // A Set subclass instance carries its own class; nil is Set itself. + // Disabling this line fails 8 of the 12 rows of + // TestASetSubclassReportsItsOwnClass — see that test for which 4 do not, + // and why. + if x.cls != nil { + return x.cls + } return vm.cSet case *PrettyPrint: return vm.cPrettyPrint diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index f120e593..852abe75 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -1560,8 +1560,25 @@ def join(sep = nil) end # to_set returns self (a Set is already a Set). - def to_set - self + # Set#to_set returns SELF only for a plain Set asked with no arguments; a + # subclass, an explicit klass, extra arguments or a block all build a new one + # (MRI's set.rb: `return self if instance_of?(Set) && klass == Set && + # block.nil? && args.empty?`). + # + # ⛔ This was `def to_set; self; end`, which was INVISIBLE while every Set + # reported Set: returning self then answered Set whatever the receiver was, so + # it matched MRI by accident. Giving a subclass its own class (#903) made that + # accident a divergence — `Sub[1,2].to_set` answers Sub where MRI answers Set — so + # the guard is part of that change, not a separate cleanup. Measured on 4.0.7: + # + # Set[1,2].to_set.equal?(s) true Sub[1,2].to_set.class Set + # Set[1,2].to_set(Sub).class Sub Sub[1,2].to_set.equal?(sub) false + # + # It also closes an arity gap the no-argument form had: `to_set(Sub)` raised + # ArgumentError (given 1, expected 0). + def to_set(klass = Set, *args, &block) + return self if instance_of?(Set) && klass == Set && block.nil? && args.empty? + klass.new(self, *args, &block) end end diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index 1adcd657..4ce71247 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: 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}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 998}, {PC: 6, Line: 1013}, {PC: 8, Line: 1024}, {PC: 10, Line: 1037}, {PC: 12, Line: 1041}, {PC: 14, Line: 1050}, {PC: 16, Line: 1107}, {PC: 18, Line: 1178}, {PC: 20, Line: 1193}, {PC: 22, Line: 1599}, {PC: 24, Line: 1819}, {PC: 26, Line: 1898}, {PC: 28, Line: 1929}, {PC: 30, Line: 1949}, {PC: 32, Line: 1989}, {PC: 34, Line: 2002}, {PC: 36, Line: 2042}, {PC: 38, Line: 2223}, {PC: 40, Line: 2265}, {PC: 42, Line: 2266}, {PC: 46, Line: 2331}, {PC: 48, Line: 2332}, {PC: 52, Line: 2441}, {PC: 54, Line: 2442}, {PC: 58, Line: 2543}, {PC: 60, Line: 2544}, {PC: 64, Line: 2601}, {PC: 66, Line: 2726}, {PC: 68, Line: 2784}}, 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: 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}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}, {PC: 4, Line: 1200}, {PC: 6, Line: 1209}, {PC: 10, Line: 1213}, {PC: 12, Line: 1221}, {PC: 16, Line: 1225}, {PC: 18, Line: 1231}, {PC: 20, Line: 1237}, {PC: 22, Line: 1241}, {PC: 24, Line: 1247}, {PC: 26, Line: 1252}, {PC: 28, Line: 1253}, {PC: 30, Line: 1257}, {PC: 32, Line: 1262}, {PC: 34, Line: 1266}, {PC: 36, Line: 1271}, {PC: 38, Line: 1275}, {PC: 40, Line: 1282}, {PC: 42, Line: 1288}, {PC: 44, Line: 1296}, {PC: 46, Line: 1310}, {PC: 48, Line: 1318}, {PC: 50, Line: 1323}, {PC: 52, Line: 1326}, {PC: 54, Line: 1331}, {PC: 56, Line: 1334}, {PC: 58, Line: 1339}, {PC: 60, Line: 1342}, {PC: 62, Line: 1347}, {PC: 64, Line: 1351}, {PC: 66, Line: 1362}, {PC: 68, Line: 1371}, {PC: 70, Line: 1375}, {PC: 72, Line: 1381}, {PC: 74, Line: 1389}, {PC: 76, Line: 1395}, {PC: 78, Line: 1401}, {PC: 80, Line: 1409}, {PC: 82, Line: 1415}, {PC: 84, Line: 1417}, {PC: 86, Line: 1426}, {PC: 88, Line: 1433}, {PC: 90, Line: 1437}, {PC: 92, Line: 1456}, {PC: 94, Line: 1479}, {PC: 96, Line: 1521}, {PC: 100, Line: 1527}, {PC: 102, Line: 1531}, {PC: 104, Line: 1542}, {PC: 106, Line: 1555}, {PC: 110, Line: 1558}, {PC: 112, Line: 1579}}, FirstLine: 1193, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -4535,15 +4535,18 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "to_set", - Insns: []bytecode.Instr{{Op: 5}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 2}, {Op: 10}, {Op: 28, A: 14}, {Op: 9}, {Op: 11}, {Op: 33}, {Op: 22}, {Op: 10}, {Op: 28, A: 19}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 2, Flags: 1}, {Op: 10}, {Op: 28, A: 24}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 28}, {Op: 5}, {Op: 53}, {Op: 26, A: 29}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 4, Flags: 3}, {Op: 53}}, + Names: []string{"Set", "instance_of?", "nil?", "empty?", "new"}, + Params: []string{"klass", "args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 1, PostCount: 0, KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1563, + BlockSlot: 2, + NumLocals: 3, + Locals: []string{"klass", "args", "block"}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1579}, {PC: 5, Line: 1580}, {PC: 25, Line: 109}, {PC: 30, Line: 1581}, {PC: 32, Line: 109}}, + FirstLine: 1579, Super: "", }, }, @@ -4559,8 +4562,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1603}, {PC: 2, Line: 1727}, {PC: 4, Line: 1784}, {PC: 6, Line: 1788}, {PC: 8, Line: 1794}, {PC: 10, Line: 1798}}, + FirstLine: 1599, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4578,8 +4581,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1604}, {PC: 4, Line: 1606}, {PC: 7, Line: 1607}, {PC: 16, Line: 1611}, {PC: 18, Line: 1616}, {PC: 20, Line: 1626}, {PC: 24, Line: 1628}, {PC: 26, Line: 1636}, {PC: 28, Line: 1640}, {PC: 30, Line: 1646}, {PC: 32, Line: 1653}, {PC: 34, Line: 1657}, {PC: 36, Line: 1666}, {PC: 38, Line: 1674}, {PC: 40, Line: 1694}, {PC: 42, Line: 1700}, {PC: 44, Line: 1704}, {PC: 46, Line: 1708}, {PC: 49, Line: 1712}}, + FirstLine: 1603, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4593,8 +4596,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1595}, {PC: 8, Line: 1596}}, - FirstLine: 1594, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1612}, {PC: 8, Line: 1613}}, + FirstLine: 1611, Super: "", }, &bytecode.ISeq{ @@ -4609,8 +4612,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1600}, {PC: 4, Line: 1601}, {PC: 9, Line: 259}, {PC: 11, Line: 1605}}, - FirstLine: 1599, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1617}, {PC: 4, Line: 1618}, {PC: 9, Line: 259}, {PC: 11, Line: 1622}}, + FirstLine: 1616, Super: "", }, &bytecode.ISeq{ @@ -4632,8 +4635,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1613}, {PC: 17, Line: 1615}, {PC: 25, Line: 1616}}, - FirstLine: 1611, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1630}, {PC: 17, Line: 1632}, {PC: 25, Line: 1633}}, + FirstLine: 1628, Super: "", }, &bytecode.ISeq{ @@ -4646,8 +4649,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{ @@ -4665,8 +4668,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}, {PC: 1, Line: 109}, {PC: 6, Line: 1624}}, - FirstLine: 1623, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1641}, {PC: 1, Line: 109}, {PC: 6, Line: 1641}}, + FirstLine: 1640, Super: "", }, &bytecode.ISeq{ @@ -4679,8 +4682,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1630}}, - FirstLine: 1629, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1647}}, + FirstLine: 1646, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4694,8 +4697,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1631}}, - FirstLine: 1630, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1648}}, + FirstLine: 1647, Super: "", }, }, @@ -4711,8 +4714,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1637}}, - FirstLine: 1636, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1654}}, + FirstLine: 1653, Super: "", }, &bytecode.ISeq{ @@ -4729,8 +4732,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}, {PC: 4, Line: 109}, {PC: 9, Line: 1659}, {PC: 13, Line: 1660}, {PC: 31, Line: 109}}, + FirstLine: 1657, Super: "", }, &bytecode.ISeq{ @@ -4749,8 +4752,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1667}, {PC: 5, Line: 1668}, {PC: 23, Line: 1669}, {PC: 33, Line: 1670}, {PC: 45, Line: 109}}, + FirstLine: 1666, Super: "", }, &bytecode.ISeq{ @@ -4769,8 +4772,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1676}, {PC: 9, Line: 259}, {PC: 14, Line: 1677}, {PC: 18, Line: 1678}, {PC: 22, Line: 1679}, {PC: 35, Line: 1680}, {PC: 38, Line: 1681}, {PC: 42, Line: 1682}, {PC: 47, Line: 1683}, {PC: 52, Line: 1685}, {PC: 60, Line: 1686}, {PC: 68, Line: 1687}, {PC: 74, Line: 1688}, {PC: 84, Line: 1689}, {PC: 92, Line: 1691}}, + FirstLine: 1674, Super: "", }, &bytecode.ISeq{ @@ -4788,8 +4791,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1679}, {PC: 14, Line: 109}}, - FirstLine: 1677, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1696}, {PC: 14, Line: 109}}, + FirstLine: 1694, Super: "", }, &bytecode.ISeq{ @@ -4804,8 +4807,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1684}}, - FirstLine: 1683, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1701}}, + FirstLine: 1700, Super: "", }, &bytecode.ISeq{ @@ -4818,8 +4821,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1688}}, - FirstLine: 1687, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1705}}, + FirstLine: 1704, Super: "", }, &bytecode.ISeq{ @@ -4838,8 +4841,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}, {PC: 10, Line: 1714}, {PC: 24, Line: 1716}, {PC: 32, Line: 1718}, {PC: 34, Line: 1720}}, + FirstLine: 1712, Super: "", }, }, @@ -4867,8 +4870,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1728}, {PC: 24, Line: 1741}, {PC: 34, Line: 1743}, {PC: 36, Line: 1747}, {PC: 38, Line: 1751}, {PC: 42, Line: 1753}, {PC: 44, Line: 1761}, {PC: 46, Line: 1770}, {PC: 48, Line: 1774}, {PC: 50, Line: 1775}, {PC: 52, Line: 1777}}, + FirstLine: 1727, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4881,8 +4884,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1712}}, - FirstLine: 1712, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1729}}, + FirstLine: 1729, Super: "", }, &bytecode.ISeq{ @@ -4896,8 +4899,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1713}}, - FirstLine: 1713, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1730}}, + FirstLine: 1730, Super: "", }, &bytecode.ISeq{ @@ -4911,8 +4914,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1714}}, - FirstLine: 1714, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1731}}, + FirstLine: 1731, Super: "", }, &bytecode.ISeq{ @@ -4926,8 +4929,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1715}}, - FirstLine: 1715, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1732}}, + FirstLine: 1732, Super: "", }, &bytecode.ISeq{ @@ -4941,8 +4944,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1716}}, - FirstLine: 1716, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1733}}, + FirstLine: 1733, Super: "", }, &bytecode.ISeq{ @@ -4956,8 +4959,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1717}}, - FirstLine: 1717, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1734}}, + FirstLine: 1734, Super: "", }, &bytecode.ISeq{ @@ -4972,8 +4975,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1718}}, - FirstLine: 1718, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1735}}, + FirstLine: 1735, Super: "", }, &bytecode.ISeq{ @@ -4988,8 +4991,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1727}}, - FirstLine: 1726, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1744}}, + FirstLine: 1743, Super: "", }, &bytecode.ISeq{ @@ -5005,8 +5008,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1731}}, - FirstLine: 1730, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1748}}, + FirstLine: 1747, Super: "", }, &bytecode.ISeq{ @@ -5024,8 +5027,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 4, Line: 1738}, {PC: 13, Line: 1739}}, - FirstLine: 1736, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1754}, {PC: 4, Line: 1755}, {PC: 13, Line: 1756}}, + FirstLine: 1753, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5040,7 +5043,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1739, + FirstLine: 1756, Super: "", }, }, @@ -5065,8 +5068,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1762}, {PC: 11, Line: 1763}, {PC: 17, Line: 1764}, {PC: 32, Line: 1765}, {PC: 41, Line: 1766}}, + FirstLine: 1761, Super: "", }, &bytecode.ISeq{ @@ -5081,8 +5084,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1754}, {PC: 5, Line: 1755}}, - FirstLine: 1753, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1771}, {PC: 5, Line: 1772}}, + FirstLine: 1770, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5096,8 +5099,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}}, - FirstLine: 1755, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1772}}, + FirstLine: 1772, Super: "", }, }, @@ -5116,8 +5119,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1761}}, - FirstLine: 1760, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, + FirstLine: 1777, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5134,8 +5137,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1761}}, - FirstLine: 1761, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1778}}, + FirstLine: 1778, Super: "", }, }, @@ -5154,8 +5157,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1768}}, - FirstLine: 1767, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1785}}, + FirstLine: 1784, Super: "", }, &bytecode.ISeq{ @@ -5167,8 +5170,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1772}}, - FirstLine: 1771, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1789}}, + FirstLine: 1788, Super: "", }, &bytecode.ISeq{ @@ -5180,8 +5183,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1777}}, - FirstLine: 1777, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1794}}, + FirstLine: 1794, Super: "", }, &bytecode.ISeq{ @@ -5194,8 +5197,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1782}}, - FirstLine: 1781, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1799}}, + FirstLine: 1798, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5206,8 +5209,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1783}}, - FirstLine: 1782, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1800}}, + FirstLine: 1799, Super: "", }, }, @@ -5226,8 +5229,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}, {PC: 2, Line: 1827}, {PC: 4, Line: 1831}, {PC: 6, Line: 1835}, {PC: 8, Line: 1839}, {PC: 10, Line: 1845}, {PC: 12, Line: 1849}, {PC: 14, Line: 1853}, {PC: 16, Line: 1857}, {PC: 18, Line: 1862}, {PC: 20, Line: 1874}, {PC: 22, Line: 1877}, {PC: 24, Line: 1879}, {PC: 26, Line: 1883}, {PC: 28, Line: 1886}}, + FirstLine: 1819, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5241,8 +5244,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1820}, {PC: 2, Line: 259}, {PC: 5, Line: 1821}, {PC: 8, Line: 1822}, {PC: 10, Line: 1823}}, + FirstLine: 1820, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5256,8 +5259,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1806}}, - FirstLine: 1806, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}}, + FirstLine: 1823, Super: "", }, }, @@ -5275,8 +5278,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1811}}, - FirstLine: 1810, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1828}}, + FirstLine: 1827, Super: "", }, &bytecode.ISeq{ @@ -5291,8 +5294,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1815}}, - FirstLine: 1814, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1832}}, + FirstLine: 1831, Super: "", }, &bytecode.ISeq{ @@ -5305,8 +5308,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1819}}, - FirstLine: 1818, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1836}}, + FirstLine: 1835, Super: "", }, &bytecode.ISeq{ @@ -5322,8 +5325,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1823}, {PC: 10, Line: 1824}, {PC: 13, Line: 109}}, - FirstLine: 1822, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 10, Line: 1841}, {PC: 13, Line: 109}}, + FirstLine: 1839, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5336,8 +5339,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1824}}, - FirstLine: 1824, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1841}}, + FirstLine: 1841, Super: "", }, }, @@ -5353,8 +5356,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1829}}, - FirstLine: 1828, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1846}}, + FirstLine: 1845, Super: "", }, &bytecode.ISeq{ @@ -5369,8 +5372,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1833}}, - FirstLine: 1832, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1850}}, + FirstLine: 1849, Super: "", }, &bytecode.ISeq{ @@ -5385,8 +5388,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1837}}, - FirstLine: 1836, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1854}}, + FirstLine: 1853, Super: "", }, &bytecode.ISeq{ @@ -5404,8 +5407,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 5, Line: 1841}, {PC: 9, Line: 1842}}, - FirstLine: 1840, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1857}, {PC: 5, Line: 1858}, {PC: 9, Line: 1859}}, + FirstLine: 1857, Super: "", }, &bytecode.ISeq{ @@ -5428,8 +5431,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}, {PC: 4, Line: 1864}, {PC: 8, Line: 1865}, {PC: 26, Line: 1866}, {PC: 44, Line: 1868}, {PC: 48, Line: 1870}}, + FirstLine: 1862, Super: "", }, &bytecode.ISeq{ @@ -5444,8 +5447,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1858}, {PC: 9, Line: 259}}, - FirstLine: 1857, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1875}, {PC: 9, Line: 259}}, + FirstLine: 1874, Super: "", }, &bytecode.ISeq{ @@ -5460,8 +5463,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1862}, {PC: 5, Line: 1863}}, - FirstLine: 1862, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1879}, {PC: 5, Line: 1880}}, + FirstLine: 1879, Super: "", }, &bytecode.ISeq{ @@ -5474,8 +5477,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}}, - FirstLine: 1866, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}}, + FirstLine: 1883, Super: "", }, }, @@ -5491,8 +5494,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 2, Line: 1892}, {PC: 4, Line: 1895}, {PC: 6, Line: 1901}}, - FirstLine: 1881, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1901}, {PC: 2, Line: 1909}, {PC: 4, Line: 1912}, {PC: 6, Line: 1918}}, + FirstLine: 1898, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5506,8 +5509,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1884}, {PC: 5, Line: 1885}, {PC: 9, Line: 1886}, {PC: 13, Line: 1890}}, - FirstLine: 1884, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1901}, {PC: 5, Line: 1902}, {PC: 9, Line: 1903}, {PC: 13, Line: 1907}}, + FirstLine: 1901, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5521,8 +5524,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1887}, {PC: 1, Line: 109}, {PC: 6, Line: 1888}}, - FirstLine: 1886, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1904}, {PC: 1, Line: 109}, {PC: 6, Line: 1905}}, + FirstLine: 1903, Super: "", }, }, @@ -5540,8 +5543,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}}, - FirstLine: 1895, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}}, + FirstLine: 1912, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5555,8 +5558,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1896}}, - FirstLine: 1896, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}}, + FirstLine: 1913, Super: "", }, }, @@ -5577,8 +5580,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1902}, {PC: 4, Line: 1903}, {PC: 9, Line: 1905}}, - FirstLine: 1901, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1919}, {PC: 4, Line: 1920}, {PC: 9, Line: 1922}}, + FirstLine: 1918, Super: "", }, }, @@ -5594,8 +5597,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}, {PC: 2, Line: 1921}, {PC: 4, Line: 1923}}, - FirstLine: 1912, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1930}, {PC: 2, Line: 1938}, {PC: 4, Line: 1940}}, + FirstLine: 1929, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5609,8 +5612,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1913}, {PC: 5, Line: 1914}, {PC: 9, Line: 1915}, {PC: 13, Line: 1919}}, - FirstLine: 1913, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1930}, {PC: 5, Line: 1931}, {PC: 9, Line: 1932}, {PC: 13, Line: 1936}}, + FirstLine: 1930, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5624,8 +5627,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1916}, {PC: 1, Line: 109}, {PC: 6, Line: 1917}}, - FirstLine: 1915, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 1, Line: 109}, {PC: 6, Line: 1934}}, + FirstLine: 1932, Super: "", }, }, @@ -5643,8 +5646,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1924}}, - FirstLine: 1923, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1941}}, + FirstLine: 1940, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5658,8 +5661,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1924}}, - FirstLine: 1924, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1941}}, + FirstLine: 1941, Super: "", }, }, @@ -5678,8 +5681,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1950}, {PC: 2, Line: 1956}, {PC: 4, Line: 1965}, {PC: 6, Line: 1969}, {PC: 8, Line: 1973}, {PC: 10, Line: 1978}, {PC: 12, Line: 1982}}, + FirstLine: 1949, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5693,8 +5696,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1934}}, - FirstLine: 1933, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1951}}, + FirstLine: 1950, Super: "", }, &bytecode.ISeq{ @@ -5709,8 +5712,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1940}, {PC: 4, Line: 1941}, {PC: 8, Line: 1942}, {PC: 19, Line: 1944}}, - FirstLine: 1939, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}, {PC: 4, Line: 1958}, {PC: 8, Line: 1959}, {PC: 19, Line: 1961}}, + FirstLine: 1956, Super: "", }, &bytecode.ISeq{ @@ -5725,8 +5728,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1948}, {PC: 5, Line: 1949}}, - FirstLine: 1948, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1965}, {PC: 5, Line: 1966}}, + FirstLine: 1965, Super: "", }, &bytecode.ISeq{ @@ -5741,8 +5744,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1952}, {PC: 5, Line: 1953}}, - FirstLine: 1952, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1969}, {PC: 5, Line: 1970}}, + FirstLine: 1969, Super: "", }, &bytecode.ISeq{ @@ -5757,8 +5760,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1957}, {PC: 1, Line: 109}, {PC: 9, Line: 1958}}, - FirstLine: 1956, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1974}, {PC: 1, Line: 109}, {PC: 9, Line: 1975}}, + FirstLine: 1973, Super: "", }, &bytecode.ISeq{ @@ -5775,8 +5778,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1962}, {PC: 3, Line: 109}}, - FirstLine: 1961, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1979}, {PC: 3, Line: 109}}, + FirstLine: 1978, Super: "", }, &bytecode.ISeq{ @@ -5795,8 +5798,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1966}, {PC: 3, Line: 109}}, - FirstLine: 1965, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1983}, {PC: 3, Line: 109}}, + FirstLine: 1982, Super: "", }, }, @@ -5812,8 +5815,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1973}, {PC: 2, Line: 1977}}, - FirstLine: 1972, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1990}, {PC: 2, Line: 1994}}, + FirstLine: 1989, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5825,8 +5828,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1974}}, - FirstLine: 1973, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1991}}, + FirstLine: 1990, Super: "", }, &bytecode.ISeq{ @@ -5841,8 +5844,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1978}}, - FirstLine: 1977, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1995}}, + FirstLine: 1994, Super: "", }, }, @@ -5885,8 +5888,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2003}, {PC: 5, Line: 2004}, {PC: 8, Line: 2022}, {PC: 34, Line: 2029}, {PC: 38, Line: 2035}}, + FirstLine: 2002, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5898,8 +5901,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1988}, {PC: 2, Line: 1992}}, - FirstLine: 1987, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2005}, {PC: 2, Line: 2009}}, + FirstLine: 2004, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5911,8 +5914,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1989}}, - FirstLine: 1988, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2006}}, + FirstLine: 2005, Super: "", }, &bytecode.ISeq{ @@ -5927,8 +5930,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1993}}, - FirstLine: 1992, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2010}}, + FirstLine: 2009, Super: "", }, }, @@ -5949,8 +5952,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2013}, {PC: 9, Line: 2014}}, - FirstLine: 2012, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2030}, {PC: 9, Line: 2031}}, + FirstLine: 2029, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5964,8 +5967,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2015}}, - FirstLine: 2014, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2032}}, + FirstLine: 2031, Super: "", }, }, @@ -5987,8 +5990,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2043}, {PC: 4, Line: 2044}, {PC: 7, Line: 2046}, {PC: 9, Line: 2052}, {PC: 11, Line: 2055}, {PC: 13, Line: 2057}, {PC: 15, Line: 2061}, {PC: 17, Line: 2065}, {PC: 19, Line: 2070}, {PC: 21, Line: 2073}, {PC: 23, Line: 2075}, {PC: 25, Line: 2080}, {PC: 27, Line: 2090}, {PC: 29, Line: 2094}, {PC: 31, Line: 2098}, {PC: 33, Line: 2105}, {PC: 35, Line: 2122}, {PC: 37, Line: 2124}, {PC: 39, Line: 2132}, {PC: 41, Line: 2136}, {PC: 43, Line: 2139}, {PC: 45, Line: 2141}, {PC: 47, Line: 2145}, {PC: 49, Line: 2149}, {PC: 51, Line: 2156}, {PC: 53, Line: 2162}, {PC: 55, Line: 2169}, {PC: 57, Line: 2173}, {PC: 59, Line: 2181}, {PC: 61, Line: 2190}, {PC: 63, Line: 2194}, {PC: 65, Line: 2198}, {PC: 67, Line: 2202}, {PC: 69, Line: 2206}, {PC: 71, Line: 2210}, {PC: 73, Line: 2214}}, + FirstLine: 2042, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6005,8 +6008,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2030}, {PC: 10, Line: 2031}, {PC: 22, Line: 2032}}, - FirstLine: 2029, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2047}, {PC: 10, Line: 2048}, {PC: 22, Line: 2049}}, + FirstLine: 2046, Super: "", }, &bytecode.ISeq{ @@ -6019,8 +6022,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2036}}, - FirstLine: 2035, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2053}}, + FirstLine: 2052, Super: "", }, &bytecode.ISeq{ @@ -6037,8 +6040,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2041}}, - FirstLine: 2040, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2058}}, + FirstLine: 2057, Super: "", }, &bytecode.ISeq{ @@ -6051,8 +6054,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2045}}, - FirstLine: 2044, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2062}}, + FirstLine: 2061, Super: "", }, &bytecode.ISeq{ @@ -6065,8 +6068,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2049}, {PC: 3, Line: 2050}}, - FirstLine: 2048, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2066}, {PC: 3, Line: 2067}}, + FirstLine: 2065, Super: "", }, &bytecode.ISeq{ @@ -6081,8 +6084,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, - FirstLine: 2053, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2071}}, + FirstLine: 2070, Super: "", }, &bytecode.ISeq{ @@ -6097,8 +6100,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2059}, {PC: 5, Line: 259}, {PC: 10, Line: 2060}}, - FirstLine: 2058, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2076}, {PC: 5, Line: 259}, {PC: 10, Line: 2077}}, + FirstLine: 2075, Super: "", }, &bytecode.ISeq{ @@ -6111,8 +6114,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2064}}, - FirstLine: 2063, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2081}}, + FirstLine: 2080, Super: "", }, &bytecode.ISeq{ @@ -6125,8 +6128,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2074}}, - FirstLine: 2073, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2091}}, + FirstLine: 2090, Super: "", }, &bytecode.ISeq{ @@ -6139,8 +6142,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2078}}, - FirstLine: 2077, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2095}}, + FirstLine: 2094, Super: "", }, &bytecode.ISeq{ @@ -6153,8 +6156,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2082}}, - FirstLine: 2081, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2099}}, + FirstLine: 2098, Super: "", }, &bytecode.ISeq{ @@ -6169,8 +6172,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2089}, {PC: 12, Line: 2090}}, - FirstLine: 2088, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2106}, {PC: 12, Line: 2107}}, + FirstLine: 2105, Super: "", }, &bytecode.ISeq{ @@ -6185,8 +6188,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2109}, {PC: 6, Line: 2110}}, - FirstLine: 2107, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 2126}, {PC: 6, Line: 2127}}, + FirstLine: 2124, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6199,8 +6202,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2109}}, - FirstLine: 2109, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2126}}, + FirstLine: 2126, Super: "", }, }, @@ -6221,8 +6224,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2115}, {PC: 5, Line: 2116}}, - FirstLine: 2115, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2132}, {PC: 5, Line: 2133}}, + FirstLine: 2132, Super: "", }, &bytecode.ISeq{ @@ -6235,8 +6238,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2120}}, - FirstLine: 2119, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2137}}, + FirstLine: 2136, Super: "", }, &bytecode.ISeq{ @@ -6249,8 +6252,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2125}}, - FirstLine: 2124, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2142}}, + FirstLine: 2141, Super: "", }, &bytecode.ISeq{ @@ -6263,8 +6266,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2129}}, - FirstLine: 2128, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2146}}, + FirstLine: 2145, Super: "", }, &bytecode.ISeq{ @@ -6280,8 +6283,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2133}, {PC: 10, Line: 2134}}, - FirstLine: 2132, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2150}, {PC: 10, Line: 2151}}, + FirstLine: 2149, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6294,8 +6297,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2134}}, - FirstLine: 2134, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2151}}, + FirstLine: 2151, Super: "", }, }, @@ -6314,8 +6317,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2140}, {PC: 10, Line: 2141}, {PC: 15, Line: 109}}, - FirstLine: 2139, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}, {PC: 10, Line: 2158}, {PC: 15, Line: 109}}, + FirstLine: 2156, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6329,8 +6332,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2141}}, - FirstLine: 2141, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2158}}, + FirstLine: 2158, Super: "", }, }, @@ -6349,8 +6352,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2146}, {PC: 10, Line: 2147}, {PC: 15, Line: 109}}, - FirstLine: 2145, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2163}, {PC: 10, Line: 2164}, {PC: 15, Line: 109}}, + FirstLine: 2162, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6364,8 +6367,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2147}}, - FirstLine: 2147, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2164}}, + FirstLine: 2164, Super: "", }, }, @@ -6381,8 +6384,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2153}}, - FirstLine: 2152, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2170}}, + FirstLine: 2169, Super: "", }, &bytecode.ISeq{ @@ -6397,8 +6400,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2157}}, - FirstLine: 2156, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2174}}, + FirstLine: 2173, Super: "", }, &bytecode.ISeq{ @@ -6413,8 +6416,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2165}, {PC: 12, Line: 2166}}, - FirstLine: 2164, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2182}, {PC: 12, Line: 2183}}, + FirstLine: 2181, Super: "", }, &bytecode.ISeq{ @@ -6429,8 +6432,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2174}}, - FirstLine: 2173, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2191}}, + FirstLine: 2190, Super: "", }, &bytecode.ISeq{ @@ -6445,8 +6448,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2178}}, - FirstLine: 2177, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2195}}, + FirstLine: 2194, Super: "", }, &bytecode.ISeq{ @@ -6461,8 +6464,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2182}}, - FirstLine: 2181, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2199}}, + FirstLine: 2198, Super: "", }, &bytecode.ISeq{ @@ -6475,8 +6478,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2186}}, - FirstLine: 2185, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2203}}, + FirstLine: 2202, Super: "", }, &bytecode.ISeq{ @@ -6489,8 +6492,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2190}}, - FirstLine: 2189, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2207}}, + FirstLine: 2206, Super: "", }, &bytecode.ISeq{ @@ -6503,8 +6506,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2194}}, - FirstLine: 2193, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2211}}, + FirstLine: 2210, Super: "", }, &bytecode.ISeq{ @@ -6519,8 +6522,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2198}}, - FirstLine: 2197, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2215}}, + FirstLine: 2214, Super: "", }, }, @@ -6536,8 +6539,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2208}, {PC: 2, Line: 2219}}, - FirstLine: 2206, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2225}, {PC: 2, Line: 2236}}, + FirstLine: 2223, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6549,8 +6552,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2211}}, - FirstLine: 2208, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2228}}, + FirstLine: 2225, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6562,8 +6565,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2212}}, - FirstLine: 2211, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2229}}, + FirstLine: 2228, Super: "", }, }, @@ -6585,8 +6588,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2220}, {PC: 4, Line: 2221}}, - FirstLine: 2219, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2237}, {PC: 4, Line: 2238}}, + FirstLine: 2236, Super: "", }, }, @@ -6608,8 +6611,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2268}, {PC: 5, Line: 2269}, {PC: 10, Line: 2275}, {PC: 12, Line: 2288}, {PC: 14, Line: 2295}, {PC: 16, Line: 2304}, {PC: 18, Line: 2308}, {PC: 21, Line: 2312}}, + FirstLine: 2266, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6630,8 +6633,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2275}, {PC: 2, Line: 259}, {PC: 13, Line: 2277}, {PC: 16, Line: 2278}, {PC: 19, Line: 2282}}, + FirstLine: 2275, Super: "", }, &bytecode.ISeq{ @@ -6649,8 +6652,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2271}, {PC: 6, Line: 2272}}, - FirstLine: 2271, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2288}, {PC: 6, Line: 2289}}, + FirstLine: 2288, Super: "", }, &bytecode.ISeq{ @@ -6665,8 +6668,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}, {PC: 4, Line: 2280}, {PC: 7, Line: 2283}}, - FirstLine: 2278, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2296}, {PC: 4, Line: 2297}, {PC: 7, Line: 2300}}, + FirstLine: 2295, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6680,8 +6683,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2281}}, - FirstLine: 2280, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2298}}, + FirstLine: 2297, Super: "", }, }, @@ -6699,8 +6702,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2287}, {PC: 6, Line: 2288}}, - FirstLine: 2287, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2304}, {PC: 6, Line: 2305}}, + FirstLine: 2304, Super: "", }, &bytecode.ISeq{ @@ -6712,8 +6715,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2296}}, - FirstLine: 2295, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2313}}, + FirstLine: 2312, Super: "", }, }, @@ -6729,8 +6732,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2316}, {PC: 2, Line: 2385}}, - FirstLine: 2315, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2333}, {PC: 2, Line: 2402}}, + FirstLine: 2332, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6742,8 +6745,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2336}, {PC: 2, Line: 2343}, {PC: 4, Line: 2350}, {PC: 6, Line: 2359}, {PC: 8, Line: 2372}}, + FirstLine: 2333, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6758,8 +6761,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2320}, {PC: 4, Line: 2321}}, - FirstLine: 2319, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2337}, {PC: 4, Line: 2338}}, + FirstLine: 2336, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6773,8 +6776,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2322}}, - FirstLine: 2321, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}}, + FirstLine: 2338, Super: "", }, }, @@ -6792,8 +6795,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2327}}, - FirstLine: 2326, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2344}}, + FirstLine: 2343, Super: "", }, &bytecode.ISeq{ @@ -6820,8 +6823,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2334}}, - FirstLine: 2333, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2351}}, + FirstLine: 2350, Super: "", }, &bytecode.ISeq{ @@ -6843,8 +6846,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 14, Line: 2361}, {PC: 19, Line: 1}, {PC: 27, Line: 2362}, {PC: 32, Line: 1}, {PC: 44, Line: 2364}, {PC: 45, Line: 1}}, + FirstLine: 2359, Super: "", }, &bytecode.ISeq{ @@ -6862,8 +6865,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 3, Line: 2374}, {PC: 7, Line: 2386}, {PC: 10, Line: 2387}, {PC: 13, Line: 2389}, {PC: 17, Line: 2390}, {PC: 22, Line: 2393}}, + FirstLine: 2372, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6882,8 +6885,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2375}, {PC: 4, Line: 2376}, {PC: 8, Line: 2377}, {PC: 13, Line: 2378}, {PC: 24, Line: 2379}, {PC: 42, Line: 2381}, {PC: 50, Line: 2383}}, + FirstLine: 2374, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6899,8 +6902,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2362}}, - FirstLine: 2362, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2379}}, + FirstLine: 2379, Super: "", }, }, @@ -6918,8 +6921,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2369}}, - FirstLine: 2369, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2386}}, + FirstLine: 2386, Super: "", }, &bytecode.ISeq{ @@ -6934,8 +6937,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2370}}, - FirstLine: 2370, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2387}}, + FirstLine: 2387, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6949,8 +6952,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2370}}, - FirstLine: 2370, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2387}}, + FirstLine: 2387, Super: "", }, }, @@ -6968,8 +6971,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2374}}, - FirstLine: 2373, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2391}}, + FirstLine: 2390, Super: "", }, }, @@ -6991,8 +6994,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2386}, {PC: 4, Line: 2390}, {PC: 6, Line: 2399}}, - FirstLine: 2385, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2403}, {PC: 4, Line: 2407}, {PC: 6, Line: 2416}}, + FirstLine: 2402, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7006,8 +7009,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2390}, {PC: 2, Line: 259}, {PC: 5, Line: 2391}, {PC: 18, Line: 2392}}, - FirstLine: 2390, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2407}, {PC: 2, Line: 259}, {PC: 5, Line: 2408}, {PC: 18, Line: 2409}}, + FirstLine: 2407, Super: "", }, &bytecode.ISeq{ @@ -7026,8 +7029,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2399}, {PC: 11, Line: 2400}, {PC: 14, Line: 2401}, {PC: 17, Line: 2402}}, - FirstLine: 2399, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2416}, {PC: 11, Line: 2417}, {PC: 14, Line: 2418}, {PC: 17, Line: 2419}}, + FirstLine: 2416, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7041,8 +7044,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2401}}, - FirstLine: 2401, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2418}}, + FirstLine: 2418, Super: "", }, }, @@ -7064,8 +7067,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2426}, {PC: 2, Line: 2439}, {PC: 4, Line: 2479}}, - FirstLine: 2425, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2443}, {PC: 2, Line: 2456}, {PC: 4, Line: 2496}}, + FirstLine: 2442, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7077,8 +7080,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2429}}, - FirstLine: 2426, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2446}}, + FirstLine: 2443, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7104,8 +7107,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}}, - FirstLine: 2429, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2447}}, + FirstLine: 2446, Super: "", }, }, @@ -7141,8 +7144,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2440}, {PC: 22, Line: 2444}}, - FirstLine: 2439, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2457}, {PC: 22, Line: 2461}}, + FirstLine: 2456, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7159,8 +7162,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2462}, {PC: 3, Line: 2463}, {PC: 6, Line: 2478}, {PC: 10, Line: 2479}, {PC: 15, Line: 2489}}, + FirstLine: 2461, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7181,8 +7184,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2464}, {PC: 4, Line: 2465}, {PC: 14, Line: 2466}, {PC: 21, Line: 2468}, {PC: 26, Line: 2469}, {PC: 42, Line: 2470}, {PC: 54, Line: 2472}, {PC: 59, Line: 2473}, {PC: 72, Line: 2475}}, + FirstLine: 2463, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7200,8 +7203,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2449}}, - FirstLine: 2449, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2466}}, + FirstLine: 2466, Super: "", }, }, @@ -7225,8 +7228,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2480}, {PC: 5, Line: 2481}, {PC: 9, Line: 2482}, {PC: 27, Line: 2484}, {PC: 35, Line: 2486}, {PC: 37, Line: 1}}, + FirstLine: 2479, Super: "", }, }, @@ -7248,8 +7251,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2480}, {PC: 4, Line: 2484}, {PC: 6, Line: 2492}}, - FirstLine: 2479, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2497}, {PC: 4, Line: 2501}, {PC: 6, Line: 2509}}, + FirstLine: 2496, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7263,8 +7266,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2484}, {PC: 2, Line: 259}, {PC: 5, Line: 2485}, {PC: 18, Line: 2486}}, - FirstLine: 2484, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2501}, {PC: 2, Line: 259}, {PC: 5, Line: 2502}, {PC: 18, Line: 2503}}, + FirstLine: 2501, Super: "", }, &bytecode.ISeq{ @@ -7283,8 +7286,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2492}, {PC: 11, Line: 2493}, {PC: 14, Line: 2494}, {PC: 17, Line: 2495}}, - FirstLine: 2492, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2509}, {PC: 11, Line: 2510}, {PC: 14, Line: 2511}, {PC: 17, Line: 2512}}, + FirstLine: 2509, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7298,8 +7301,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2494}}, - FirstLine: 2494, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2511}}, + FirstLine: 2511, Super: "", }, }, @@ -7332,8 +7335,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2545}, {PC: 2, Line: 2566}, {PC: 4, Line: 2569}, {PC: 6, Line: 2572}, {PC: 8, Line: 2575}, {PC: 10, Line: 2578}, {PC: 12, Line: 2581}, {PC: 14, Line: 2585}}, + FirstLine: 2544, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7348,8 +7351,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2546}, {PC: 4, Line: 2547}, {PC: 6, Line: 2554}, {PC: 8, Line: 2555}, {PC: 10, Line: 2556}, {PC: 12, Line: 2559}, {PC: 14, Line: 2560}}, + FirstLine: 2545, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7367,8 +7370,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2531}, {PC: 3, Line: 2535}}, - FirstLine: 2530, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2548}, {PC: 3, Line: 2552}}, + FirstLine: 2547, Super: "", }, &bytecode.ISeq{ @@ -7383,8 +7386,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2537}}, - FirstLine: 2537, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2554}}, + FirstLine: 2554, Super: "", }, &bytecode.ISeq{ @@ -7398,7 +7401,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2538, + FirstLine: 2555, Super: "", }, &bytecode.ISeq{ @@ -7415,8 +7418,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2540}}, - FirstLine: 2539, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2557}}, + FirstLine: 2556, Super: "", }, &bytecode.ISeq{ @@ -7434,8 +7437,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2544}, {PC: 9, Line: 2545}}, - FirstLine: 2543, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2561}, {PC: 9, Line: 2562}}, + FirstLine: 2560, Super: "", }, }, @@ -7451,8 +7454,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2550}}, - FirstLine: 2549, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2567}}, + FirstLine: 2566, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7466,8 +7469,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2550}}, - FirstLine: 2550, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2567}}, + FirstLine: 2567, Super: "", }, }, @@ -7483,8 +7486,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}}, - FirstLine: 2552, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2570}}, + FirstLine: 2569, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7498,8 +7501,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}}, - FirstLine: 2553, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2570}}, + FirstLine: 2570, Super: "", }, }, @@ -7515,8 +7518,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2556}}, - FirstLine: 2555, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2573}}, + FirstLine: 2572, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7530,8 +7533,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2556}}, - FirstLine: 2556, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2573}}, + FirstLine: 2573, Super: "", }, }, @@ -7547,8 +7550,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2559}}, - FirstLine: 2558, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2576}}, + FirstLine: 2575, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7562,8 +7565,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2559}}, - FirstLine: 2559, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2576}}, + FirstLine: 2576, Super: "", }, }, @@ -7579,8 +7582,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2562}}, - FirstLine: 2561, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2579}}, + FirstLine: 2578, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7594,8 +7597,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2562}}, - FirstLine: 2562, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2579}}, + FirstLine: 2579, Super: "", }, }, @@ -7611,8 +7614,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2565}}, - FirstLine: 2564, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2582}}, + FirstLine: 2581, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7626,8 +7629,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2565}}, - FirstLine: 2565, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2582}}, + FirstLine: 2582, Super: "", }, }, @@ -7649,8 +7652,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2602}, {PC: 4, Line: 2604}, {PC: 6, Line: 2625}, {PC: 8, Line: 2656}, {PC: 10, Line: 2662}, {PC: 12, Line: 2671}, {PC: 14, Line: 2686}, {PC: 16, Line: 2693}, {PC: 18, Line: 2697}, {PC: 20, Line: 2704}, {PC: 22, Line: 2706}, {PC: 24, Line: 2710}, {PC: 26, Line: 2714}}, + FirstLine: 2601, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7666,8 +7669,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2588}}, - FirstLine: 2587, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2605}}, + FirstLine: 2604, Super: "", }, &bytecode.ISeq{ @@ -7692,8 +7695,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: 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2625}, {PC: 7, Line: 259}, {PC: 15, Line: 2626}, {PC: 19, Line: 2627}, {PC: 36, Line: 2628}, {PC: 44, Line: 259}, {PC: 47, Line: 2630}, {PC: 50, Line: 2638}, {PC: 62, Line: 2639}, {PC: 65, Line: 2640}, {PC: 68, Line: 2641}, {PC: 76, Line: 2642}, {PC: 92, Line: 2643}, {PC: 94, Line: 2644}, {PC: 95, Line: 109}, {PC: 98, Line: 2647}, {PC: 101, Line: 2648}, {PC: 105, Line: 2647}, {PC: 108, Line: 2648}}, + FirstLine: 2625, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7712,8 +7715,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2631}, {PC: 25, Line: 2632}, {PC: 31, Line: 2633}, {PC: 36, Line: 2634}, {PC: 39, Line: 2635}}, + FirstLine: 2630, Super: "", }, &bytecode.ISeq{ @@ -7731,8 +7734,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2623}}, - FirstLine: 2623, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}}, + FirstLine: 2640, Super: "", }, }, @@ -7751,8 +7754,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2640}, {PC: 16, Line: 2641}, {PC: 19, Line: 2642}}, - FirstLine: 2639, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2657}, {PC: 16, Line: 2658}, {PC: 19, Line: 2659}}, + FirstLine: 2656, Super: "", }, &bytecode.ISeq{ @@ -7767,8 +7770,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2646}}, - FirstLine: 2645, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2663}}, + FirstLine: 2662, Super: "", }, &bytecode.ISeq{ @@ -7786,8 +7789,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2671}, {PC: 7, Line: 259}, {PC: 10, Line: 2672}, {PC: 13, Line: 2673}, {PC: 16, Line: 2674}, {PC: 32, Line: 2675}, {PC: 34, Line: 2676}, {PC: 35, Line: 2677}, {PC: 39, Line: 2679}, {PC: 42, Line: 2680}, {PC: 46, Line: 2679}, {PC: 49, Line: 2680}, {PC: 56, Line: 2683}}, + FirstLine: 2671, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7804,8 +7807,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2656}}, - FirstLine: 2656, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2673}}, + FirstLine: 2673, Super: "", }, }, @@ -7823,8 +7826,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2686}, {PC: 5, Line: 2687}, {PC: 17, Line: 2688}, {PC: 20, Line: 2689}, {PC: 27, Line: 259}}, + FirstLine: 2686, Super: "", }, &bytecode.ISeq{ @@ -7837,8 +7840,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2677}}, - FirstLine: 2676, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2694}}, + FirstLine: 2693, Super: "", }, &bytecode.ISeq{ @@ -7851,8 +7854,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2681}, {PC: 8, Line: 2682}, {PC: 14, Line: 259}}, - FirstLine: 2680, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2698}, {PC: 8, Line: 2699}, {PC: 14, Line: 259}}, + FirstLine: 2697, Super: "", }, &bytecode.ISeq{ @@ -7870,8 +7873,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2690}}, - FirstLine: 2689, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2707}}, + FirstLine: 2706, Super: "", }, &bytecode.ISeq{ @@ -7886,8 +7889,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2693}, {PC: 5, Line: 2694}}, - FirstLine: 2693, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2710}, {PC: 5, Line: 2711}}, + FirstLine: 2710, Super: "", }, &bytecode.ISeq{ @@ -7902,8 +7905,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2698}, {PC: 8, Line: 2699}, {PC: 19, Line: 2701}}, - FirstLine: 2697, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2715}, {PC: 8, Line: 2716}, {PC: 19, Line: 2718}}, + FirstLine: 2714, Super: "", }, }, @@ -7925,8 +7928,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2727}, {PC: 11, Line: 109}, {PC: 14, Line: 2767}, {PC: 16, Line: 2771}, {PC: 17, Line: 109}}, + FirstLine: 2726, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7938,8 +7941,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2720}, {PC: 2, Line: 2732}, {PC: 4, Line: 2743}}, - FirstLine: 2717, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2737}, {PC: 2, Line: 2749}, {PC: 4, Line: 2760}}, + FirstLine: 2734, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7959,8 +7962,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2738}, {PC: 5, Line: 2739}, {PC: 17, Line: 2741}, {PC: 22, Line: 2742}, {PC: 33, Line: 2744}}, + FirstLine: 2737, Super: "", }, &bytecode.ISeq{ @@ -7981,8 +7984,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - 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, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2750}, {PC: 5, Line: 2751}, {PC: 17, Line: 2753}, {PC: 22, Line: 2754}, {PC: 33, Line: 2756}}, + FirstLine: 2749, Super: "", }, &bytecode.ISeq{ @@ -7995,8 +7998,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2744}}, - FirstLine: 2743, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2761}}, + FirstLine: 2760, Super: "", }, }, @@ -8016,8 +8019,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2750}, {PC: 2, Line: 259}, {PC: 5, Line: 2751}, {PC: 9, Line: 259}}, - FirstLine: 2750, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2767}, {PC: 2, Line: 259}, {PC: 5, Line: 2768}, {PC: 9, Line: 259}}, + FirstLine: 2767, Super: "", }, }, @@ -8033,8 +8036,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2768}}, - FirstLine: 2767, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2785}}, + FirstLine: 2784, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8049,7 +8052,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2768, + FirstLine: 2785, Super: "", }, }, diff --git a/internal/vm/set.go b/internal/vm/set.go index a3047dbf..9ecfbb18 100644 --- a/internal/vm/set.go +++ b/internal/vm/set.go @@ -25,6 +25,16 @@ import ( type Set struct { h *object.Hash // member -> true, keyed by the member's #hash/#eql? iterating int // >0 while an #each is in progress (structural-mod guard) + // cls is the class this Set reports, so an instance of a Set SUBCLASS can + // answer its own class. nil means Set itself, which keeps every existing + // allocation correct without touching it. + // + // ⛔ WITHOUT THIS FIELD THE CLASS IS UNREPRESENTABLE, not merely discarded. + // #903 blamed Set.new and Set.[] for ignoring their receiver; they do, and + // that was not the cause — classOf had nowhere to read a class from and + // answered vm.cSet for every *Set, so honouring the receiver in those two + // constructors would have changed nothing observable. + cls *RClass } // checkIter raises the RuntimeError MRI raises when a Set is structurally @@ -64,6 +74,17 @@ func (s *Set) repr() string { // also the constructor other bindings (e.g. redis) use to surface a Ruby Set. func newSet() *Set { return &Set{h: object.NewHash()} } +// setSubclassOf is the class a Set allocated on behalf of recv must report: +// nil when recv is Set itself (or is not a class at all), so every existing +// allocation keeps answering Set without carrying a pointer for it. +func setSubclassOf(vm *VM, recv object.Value) *RClass { + cls, ok := recv.(*RClass) + if !ok || cls == vm.cSet { + return nil + } + return cls +} + // each calls fn for every member (a Ruby value) in insertion order, in a single // pass over the backing Hash's key slice. func (s *Set) each(fn func(object.Value)) { @@ -141,16 +162,22 @@ func (vm *VM) registerSet() { // Set.new(enumerable=nil, &block): allocate an empty Set, then run the // (prelude, private) #initialize which seeds it via the each_entry/each // protocol and applies the block, exactly like MRI's Class#new. + // ⛔ Both constructors read their RECEIVER, because they are inherited: a + // subclass calling Set.new or Sub[…] arrives here with the subclass as the + // receiver, and MRI allocates with rb_obj_class(self). setClassOf keeps the + // nil-means-Set convention so `Set.new` itself allocates exactly as before. vm.cSet.smethods["new"] = &Method{name: "new", owner: vm.cSet, - native: func(vm *VM, _ object.Value, args []object.Value, blk *Proc) object.Value { + native: func(vm *VM, recv object.Value, args []object.Value, blk *Proc) object.Value { s := newSet() + s.cls = setSubclassOf(vm, recv) vm.send(s, "initialize", args, blk) return s }} // Set[a, b, …] builds a Set from its arguments (MRI's Set.[]). vm.cSet.smethods["[]"] = &Method{name: "[]", owner: vm.cSet, - native: func(_ *VM, _ object.Value, args []object.Value, _ *Proc) object.Value { + native: func(vm *VM, recv object.Value, args []object.Value, _ *Proc) object.Value { s := newSet() + s.cls = setSubclassOf(vm, recv) for _, a := range args { s.add(a) } @@ -222,8 +249,12 @@ func (vm *VM) registerSet() { // dup / clone: a shallow copy with the same members, insertion order and // compare_by_identity flag (ReplaceWith carries the flag across). + // dup/clone keep the receiver's class, as MRI's rb_obj_dup does — and that + // is also what carries it through `|`, which the prelude writes as + // `n = dup; …` (prelude.rb:1247). dupFn := func(_ *VM, v object.Value, _ []object.Value, _ *Proc) object.Value { n := newSet() + n.cls = self(v).cls n.h.ReplaceWith(self(v).h) return n } diff --git a/internal/vm/set_subclass_test.go b/internal/vm/set_subclass_test.go new file mode 100644 index 00000000..0c5a97f4 --- /dev/null +++ b/internal/vm/set_subclass_test.go @@ -0,0 +1,123 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import "testing" + +const setSubPre = `require "set" +class Sub < Set; end +` + +// A Set subclass instance reports its own class, and MRI propagates it +// ASYMMETRICALLY: the SUBSETS that classify/divide build take the receiver's +// class (`rb_obj_class(set)`, set.c:890; `set_s_alloc(set_class)`, set.c:953) +// while the OUTER Set those two return is always `rb_cSet` (set.c:946, :1002). +// +// Every expectation was measured on `ruby 4.0.7 (2026-09-15 revision +// 229531a6cf) +PRISM [arm64-darwin25]` through +// scripts/conformance/rubyspec/cmd/oracle. +// +// ⛔ #903 blamed Set.new and Set.[] for ignoring their receiver. They did, and +// that was NOT the cause: `type Set struct` had no class field, so `classOf` +// answered vm.cSet for every *Set and honouring the receiver would have changed +// nothing observable. The class was unrepresentable, not discarded. +// +// ⛔⛔ AND THE ASYMMETRY BELOW COMES OUT FOR FREE, which is exactly why it is +// asserted here. The prelude already writes `self.class.new` for the subsets +// (prelude.rb:1258, :1276, :1442, :1519) and a bare `Set.new` for divide's +// outer Set, and `|` is `dup`. So one `cls` field plus `classOf` reading it +// produced MRI's whole shape with no prelude change — behaviour that is correct +// by accident of another change is behaviour nobody is holding in place. +// +// ⛔ WHICH ROWS GUARD WHICH DIRECTION, measured by disabling `classOf`'s read of +// `cls`: 8 of the 12 rows below fail. The 4 that do NOT are worth naming, +// because a reader could otherwise take them for evidence they are not: +// +// "it is still a Set" is_a? holds either way +// "a plain Set is unaffected" a control: it SHOULD be unaffected +// "the outer Set of divide stays a plain Set" +// "a block makes to_set build a new Set" Set in both states +// +// The last two answer `Set` with the fix and without it, so they cannot +// discriminate against the pre-fix engine. They are not redundant: they guard +// the OPPOSITE direction — a later change that propagated the class to divide's +// outer Set, or made to_set return self for a block, would fail them. A row +// that cannot fail from one direction may be the only row that fails from the +// other, and saying so is cheaper than re-deriving it. +func TestASetSubclassReportsItsOwnClass(t *testing.T) { + for _, tc := range []struct{ name, src, want string }{ + {"the bracket constructor keeps the subclass", + setSubPre + `p Sub[1, 2].class`, `Sub`}, + + {"new keeps the subclass, with and without an enumerable", + setSubPre + `p Sub.new([1, 2]).class +p Sub.new.class`, "Sub\nSub"}, + + {"an anonymous subclass works too", + setSubPre + `k = Class.new(Set) +p k[1].class == k`, `true`}, + + {"it is still a Set", + setSubPre + `p Sub[1, 2].is_a?(Set)`, `true`}, + + // ⛔ Set itself must be untouched: nil cls means Set, so every existing + // allocation answers exactly as before. + {"a plain Set is unaffected", + setSubPre + `p Set[1, 2].class +p Set.new([1]).class +p Set[1].dup.class`, "Set\nSet\nSet"}, + + // ⛔ THE ASYMMETRY. Subsets take the receiver's class... + {"classify builds subsets of the receiver's class, in a plain Hash", + setSubPre + `h = Sub[1, 2].classify { |x| x } +p h.values.map(&:class) +p h.class`, "[Sub, Sub]\nHash"}, + + {"divide builds subsets of the receiver's class", + setSubPre + `p Sub[1, 2].divide { |x| x }.map(&:class) +p Sub[1, 2].divide { |x, y| false }.map(&:class)`, "[Sub, Sub]\n[Sub, Sub]"}, + + // ...and the OUTER Set of divide is a plain Set on BOTH arities. + {"the outer Set of divide stays a plain Set", + setSubPre + `p Sub[1, 2].divide { |x| x }.class +p Sub[1, 2].divide { |x, y| false }.class`, "Set\nSet"}, + + // dup carries the class, which is what makes `|` carry it: the prelude + // writes `n = dup` (prelude.rb:1247). + {"dup, clone and the set operators keep the subclass", + setSubPre + `p Sub[1, 2].dup.class +p Sub[1, 2].clone.class +p (Sub[1, 2] | Sub[3]).class +p (Sub[1, 2] & Sub[2]).class +p (Sub[1, 2] - Sub[2]).class`, "Sub\nSub\nSub\nSub\nSub"}, + + // ⛔ to_set is the one that does NOT keep it, and the one this change + // had to fix: `def to_set; self; end` answered Set for every receiver + // while every Set reported Set — correct BY ACCIDENT. Giving a subclass + // its own class turned that accident into a divergence. + {"to_set returns a plain Set for a subclass, and self for a plain Set", + setSubPre + `s = Set[1, 2] +p s.to_set.equal?(s) +sub = Sub[1, 2] +p sub.to_set.class +p sub.to_set.equal?(sub)`, "true\nSet\nfalse"}, + + // The arity gap the one-line to_set also had: this raised + // ArgumentError (given 1, expected 0). + {"to_set takes an explicit class", + setSubPre + `p Set[1, 2].to_set(Sub).class +p Set[1, 2].to_set(Sub).equal?(Set[1, 2]) +p Sub[1, 2].to_set(Sub).class`, "Sub\nfalse\nSub"}, + + {"a block makes to_set build a new Set", + setSubPre + `p Set[1, 2].to_set { |x| x }.class`, `Set`}, + } { + t.Run(tc.name, func(t *testing.T) { + if got := runSrc(t, tc.src); got != tc.want { + t.Errorf("%s\n got %q\nwant %q", tc.src, got, tc.want) + } + }) + } +}