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) + } + }) + } +}