diff --git a/internal/vm/enumerable_residuals_test.go b/internal/vm/enumerable_residuals_test.go index 19bcd34c..c6302df0 100644 --- a/internal/vm/enumerable_residuals_test.go +++ b/internal/vm/enumerable_residuals_test.go @@ -67,6 +67,109 @@ func TestEnumerableResiduals(t *testing.T) { } } +// enumSized is an #each-only Enumerable that also answers #size, used to prove +// the origin-size enumerators report the receiver size while the same method on +// a size-less Enumerable reports nil. +const enumSized = "class ES\n include Enumerable\n def initialize(*a) @a=a end\n def each; @a.each { |x| yield x } end\n def size; @a.size end\nend\n" + +// TestEnumerableAliasesAndSizes covers the genuine aliases (so their +// UnboundMethods are identical, as in MRI) and the enumerator #size functions: +// origin-size methods report the receiver size when it has one and nil +// otherwise, unknown-size methods always report nil. +func TestEnumerableAliasesAndSizes(t *testing.T) { + cases := []struct{ src, want string }{ + // Genuine aliases: the UnboundMethod is the same object as its target. + {`p Enumerable.instance_method(:collect) == Enumerable.instance_method(:map)`, "true\n"}, + {`p Enumerable.instance_method(:filter) == Enumerable.instance_method(:select)`, "true\n"}, + {`p Enumerable.instance_method(:detect) == Enumerable.instance_method(:find)`, "true\n"}, + {`p Enumerable.instance_method(:find_all) == Enumerable.instance_method(:select)`, "true\n"}, + {`p Enumerable.instance_method(:collect_concat) == Enumerable.instance_method(:flat_map)`, "true\n"}, + {`p Enumerable.instance_method(:inject) == Enumerable.instance_method(:reduce)`, "true\n"}, + {`p Enumerable.instance_method(:entries) == Enumerable.instance_method(:to_a)`, "true\n"}, + {`p Enumerable.instance_method(:member?) == Enumerable.instance_method(:include?)`, "true\n"}, + + // Origin-size enumerators: receiver size when it has one, nil otherwise. + {enumSized + `p ES.new(1, 2, 3).map.size`, "3\n"}, + {enumEach + `p E.new(1, 2, 3).map.size.inspect`, "\"nil\"\n"}, + {enumSized + `p ES.new(1, 2, 3, 4).flat_map.size`, "4\n"}, + {enumEach + `p E.new(1, 2, 3, 4).flat_map.size.inspect`, "\"nil\"\n"}, + {enumSized + `p ES.new(1, 2, 3).select.size`, "3\n"}, + {enumSized + `p ES.new(1, 2).min_by.size`, "2\n"}, + {enumSized + `p ES.new(1, 2).partition.size`, "2\n"}, + {enumSized + `p ES.new(1, 2).each_with_index.size`, "2\n"}, + // Unknown-size enumerators: always nil, even when the receiver has #size. + {enumSized + `p ES.new(1, 2, 3).find.size.inspect`, "\"nil\"\n"}, + {enumSized + `p ES.new(1, 2, 3).find_index.size.inspect`, "\"nil\"\n"}, + {enumSized + `p ES.new(1, 2, 3).take_while.size.inspect`, "\"nil\"\n"}, + {enumSized + `p ES.new(1, 2, 3).drop_while.size.inspect`, "\"nil\"\n"}, + } + for _, c := range cases { + if got := eval(t, c.src); got != c.want { + t.Errorf("src=%q\n got=%q\nwant=%q", c.src, got, c.want) + } + } +} + +// TestEnumerableMinMaxReduceFind covers min/max/minmax comparator behaviour, +// reduce/inject operator forms, find's ifnone, and the arity/argument-forwarding +// completions, all against MRI Ruby 4.0 semantics on a custom Enumerable. +func TestEnumerableMinMaxReduceFind(t *testing.T) { + cases := []struct{ src, want string }{ + // min/max/minmax compare with the block, else <=>. + {enumEach + `p E.new("2", "33", "4").max { |a, b| b <=> a }`, "\"2\"\n"}, + {enumEach + `p E.new(3, 1, 2).min`, "1\n"}, + {enumEach + `p E.new(3, 1, 2).minmax`, "[1, 3]\n"}, + {enumEach + `p E.new(3, 1, 2).min(2)`, "[1, 2]\n"}, + {enumEach + `p E.new(3, 1, 2).max(2)`, "[3, 2]\n"}, + // nil comparison (incomparable elements, or a nil-returning block) raises. + {enumEach + `begin; E.new(1, "a").max; rescue => e; p e.class; end`, "ArgumentError\n"}, + {enumEach + `begin; E.new(1, 2, 3).min { |a, b| nil }; rescue => e; p e.class; end`, "ArgumentError\n"}, + // multi-value yields are gathered and compared as arrays. + {`class YM; include Enumerable; def each; yield 1,2; yield 6,7,8; yield 3,4; end; end +p YM.new.max`, "[6, 7, 8]\n"}, + + // reduce/inject operator: Symbol, String, and #to_str all work; a lone + // argument is init with a block and the operator without one. + {enumEach + `p E.new(1, 2, 3, 4).inject(:+)`, "10\n"}, + {enumEach + `p E.new(1, 2, 3, 4).inject("+")`, "10\n"}, + {enumEach + `p E.new(1, 2, 3, 4).inject(10, :+)`, "20\n"}, + {enumEach + `p E.new(1, 2, 3, 4).inject(10) { |a, b| a + b }`, "20\n"}, + {enumEach + `s = Object.new; def s.to_str; "+"; end; p E.new(1, 2, 3).inject(s)`, "6\n"}, + + // find/detect ifnone: called (once) when nothing matches, else nil. + {enumEach + `p E.new(1, 2, 3).find(-> { :none }) { |x| x > 5 }`, ":none\n"}, + {enumEach + `p E.new(1, 2, 3).find { |x| x > 5 }.inspect`, "\"nil\"\n"}, + {enumEach + `p E.new(1, 2, 3).detect(-> { 42 }) { |x| x == 2 }`, "2\n"}, + + // map/find_index/take_while forward the raw yield so block arity governs. + {`class YM2; include Enumerable; def each; yield 1,2; yield 3,4; end; end +p YM2.new.map { |x| x }`, "[1, 3]\n"}, + {`class YM3; include Enumerable; def each; yield 1,2; yield 3,4; end; end +p YM3.new.map { |x, y| y }`, "[2, 4]\n"}, + + // argument forwarding to #each. + {`class EA; include Enumerable; attr_reader :got; def each(*a); @got = a; yield 1; yield 2; end; end +e = EA.new; e.to_a(:x, :y); p e.got`, "[:x, :y]\n"}, + + // to_h coerces each pair with #to_ary. + {`class Pairish; def to_ary; [:k, :v]; end; end +class EP; include Enumerable; def each; yield Pairish.new; end; end +p EP.new.to_h`, "{k: :v}\n"}, + + // flat_map concatenates a #to_ary result, appends when to_ary is nil. + {`class TA; def to_ary; [:a, :b]; end; end +p [1, TA.new, 2].flat_map { |x| x }`, "[1, :a, :b, 2]\n"}, + + // lazy on a bare Enumerable, driven through #each. + {enumEach + `p E.new(1, 2, 3, 4).lazy.map { |x| x * 2 }.first(2)`, "[2, 4]\n"}, + } + for _, c := range cases { + if got := eval(t, c.src); got != c.want { + t.Errorf("src=%q\n got=%q\nwant=%q", c.src, got, c.want) + } + } +} + // TestEnumerableResidualErrors covers the error branches of the residual methods // with the exact MRI Ruby 4.0.5 exception class and message: tally rejects a // non-Hash argument, a non-Integer accumulated count, and surplus arguments; @@ -87,6 +190,30 @@ func TestEnumerableResidualErrors(t *testing.T) { "ArgumentError: wrong number of arguments (given 2, expected 0..1)\n"}, {enumEach + `begin; E.new(1).find_index(1, 2); rescue => e; puts "#{e.class}: #{e.message}"; end`, "ArgumentError: wrong number of arguments (given 2, expected 0..1)\n"}, + + // reduce/inject: a lone non-symbol/string argument with no block, an + // operator that is neither symbol nor string, no args without a block, and + // too many arguments. + {enumEach + `begin; E.new(1, 2).inject(5); rescue => e; puts "#{e.class}: #{e.message}"; end`, + "TypeError: 5 is not a symbol nor a string\n"}, + {enumEach + `begin; E.new(1, 2).inject(Object.new); rescue => e; p e.class; end`, "TypeError\n"}, + {enumEach + `begin; E.new(1, 2).inject; rescue => e; puts "#{e.class}: #{e.message}"; end`, + "ArgumentError: wrong number of arguments (given 0, expected 1..2)\n"}, + {enumEach + `begin; E.new(1, 2).inject(1, 2, 3); rescue => e; puts "#{e.class}: #{e.message}"; end`, + "ArgumentError: wrong number of arguments (given 3, expected 1..2)\n"}, + + // find's ifnone must respond to #call. + {enumEach + `begin; E.new(1, 2).find(42) { |x| x > 5 }; rescue => e; p e.class; end`, + "NoMethodError\n"}, + + // cycle coerces n with #to_int; an uncoercible n is a TypeError. + {enumEach + `begin; E.new(1).cycle("cat") { }; rescue => e; p e.class; end`, "TypeError\n"}, + + // zip requires each argument to respond to #to_ary or #each. + {enumEach + `begin; E.new(1, 2).zip(Object.new); rescue => e; puts "#{e.class}: #{e.message}"; end`, + "TypeError: wrong argument type Object (must respond to :each)\n"}, + {enumEach + `begin; E.new(1, 2).zip(42); rescue => e; puts "#{e.class}: #{e.message}"; end`, + "TypeError: wrong argument type Integer (must respond to :each)\n"}, } for _, c := range cases { if got := eval(t, c.src); got != c.want { diff --git a/internal/vm/lazy.go b/internal/vm/lazy.go index e05a01ee..f076d2ee 100644 --- a/internal/vm/lazy.go +++ b/internal/vm/lazy.go @@ -54,6 +54,11 @@ func (vm *VM) registerLazy() { vm.cRange.define("lazy", makeLazy) vm.cHash.define("lazy", makeLazy) vm.cEnumerator.define("lazy", makeLazy) + // Every Enumerable (a class that mixes in Enumerable and defines #each) gets + // #lazy too; the source is driven through #each (see lazySource's default). + if en, ok := vm.consts["Enumerable"].(*RClass); ok { + en.define("lazy", makeLazy) + } d := func(name string, fn NativeFn) { vm.cLazy.define(name, fn) } chain := func(kind string) NativeFn { diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index 3fa47cb0..6419c4c9 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -147,53 +147,48 @@ def __enum_int_arg(n) # public API (MRI does not expose them). private :__each_packed, :__pack, :__enum_int_arg - def to_a + # to_a (aka entries): collect the elements. Any arguments are forwarded to + # #each, as MRI does (a custom #each may take and act on them). + def to_a(*args) r = [] - __each_packed { |x| r << x } + each(*args) { |*a| r << __pack(a) } r end + alias entries to_a # to_set: a new Set of the elements (each preprocessed by the block, if given), # as MRI's Enumerable#to_set. Defined here so every Enumerable — Array, Range, # Hash, … — can be turned into a Set. - def to_set(&block) - Set.new(self, &block) + def to_set(klass = Set, *args, &block) + klass.new(self, *args, &block) end # to_h: each element (or each yield of the block) must be a [key, value] pair. - def to_h + # A non-Array pair is coerced with #to_ary (MRI's rb_check_array_type). Any + # arguments are forwarded to #each. + def to_h(*args) h = {} - __each_packed { |x| - pair = block_given? ? yield(x) : x - raise TypeError, "wrong element type #{pair.class} (expected array)" unless pair.is_a?(Array) - raise ArgumentError, "element has wrong array length (expected 2, was #{pair.length})" unless pair.length == 2 - h[pair[0]] = pair[1] + each(*args) { |*a| + pair = block_given? ? yield(*a) : __pack(a) + ary = Array.try_convert(pair) + raise TypeError, "wrong element type #{pair.class} (expected array)" if ary.nil? + raise ArgumentError, "element has wrong array length (expected 2, was #{ary.length})" unless ary.length == 2 + h[ary[0]] = ary[1] } h end def map - return enum_for(:map) unless block_given? + return enum_for(:map) { size if respond_to?(:size) } unless block_given? r = [] - __each_packed { |x| r << yield(x) } + each { |*a| r << yield(*a) } r end - # collect/filter/detect are the classic aliases of map/select/find. - def collect(&blk) - return enum_for(:collect) unless block_given? - map(&blk) - end - - def filter(&blk) - return enum_for(:filter) unless block_given? - select(&blk) - end - - def detect(&blk) - return enum_for(:detect) unless block_given? - find(&blk) - end + # collect/filter/detect are the classic aliases of map/select/find. They are + # genuine aliases (sharing the same method entry) so that, as in MRI, + # Enumerable.instance_method(:collect) == Enumerable.instance_method(:map). + alias collect map def count(*args) raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" if args.length > 1 @@ -212,12 +207,12 @@ def count(*args) # min_by / max_by / sort_by delegate to Array's native implementations via the # pair/element list, so any Enumerable (Hash, Range, Struct, …) gains them. def min_by(*args) - return enum_for(:min_by, *args) unless block_given? + return enum_for(:min_by, *args) { size if respond_to?(:size) } unless block_given? to_a.min_by(*args) { |x| yield(x) } end def max_by(*args) - return enum_for(:max_by, *args) unless block_given? + return enum_for(:max_by, *args) { size if respond_to?(:size) } unless block_given? to_a.max_by(*args) { |x| yield(x) } end @@ -226,83 +221,124 @@ def sort(&block) end def sort_by - return enum_for(:sort_by) unless block_given? + return enum_for(:sort_by) { size if respond_to?(:size) } unless block_given? to_a.sort_by { |x| yield(x) } end def select - return enum_for(:select) unless block_given? + return enum_for(:select) { size if respond_to?(:size) } unless block_given? r = [] __each_packed { |x| r << x if yield(x) } r end + alias filter select def reject - return enum_for(:reject) unless block_given? + return enum_for(:reject) { size if respond_to?(:size) } unless block_given? r = [] __each_packed { |x| r << x unless yield(x) } r end - def find - return enum_for(:find) unless block_given? + # find(ifnone = nil): returns the first element for which the block is truthy. + # When none matches, calls the ifnone proc (if given) and returns its result, + # else nil. ifnone is passed through to the enumerator when no block is given. + def find(ifnone = nil) + return enum_for(:find, ifnone) { nil } unless block_given? + found = false result = nil __each_packed { |x| - if result == nil - result = x if yield(x) + unless found + if yield(x) + result = x + found = true + end end } - result + return result if found + ifnone.nil? ? nil : ifnone.call end + alias detect find def include?(value) found = false __each_packed { |x| found = true if x == value } found end + alias member? include? + # sum folds the elements (each mapped through the block, if given) onto init. + # Once a Float is involved it switches to Kahan-Babuska-Neumaier compensated + # summation, as MRI does, so a long run of floats sums without drift. def sum(init = 0) total = init - __each_packed { |x| total = total + (block_given? ? yield(x) : x) } - total + compensation = 0.0 + float_mode = total.is_a?(Float) + __each_packed { |x| + v = block_given? ? yield(x) : x + if !float_mode && v.is_a?(Float) + total = total.to_f + float_mode = true + end + if float_mode && v.is_a?(Float) + t = total + v + compensation += total.abs >= v.abs ? (total - t) + v : (v - t) + total + total = t + else + total = total + v + end + } + float_mode ? total + compensation : total end - def min(n = nil) - return to_a.sort.first(n) unless n.nil? # min(n): the n smallest, ascending + # min/max/minmax compare with the block when one is given, else with <=>. + # A nil comparison (incomparable elements, or a block returning nil) raises + # ArgumentError, as in MRI. Multi-value #each yields are gathered into an + # Array element (via __each_packed) and compared as arrays. + def min(n = nil, &block) + return to_a.sort(&block).first(n) unless n.nil? # min(n): the n smallest, ascending result = nil first = true __each_packed { |x| if first result = x first = false - elsif x < result - result = x + else + c = block ? block.call(x, result) : (x <=> result) + raise ArgumentError, "comparison of #{x.class} with #{result.class} failed" if c.nil? + result = x if c < 0 end } result end - def max(n = nil) - return to_a.sort.last(n).reverse unless n.nil? # max(n): the n largest, descending + def max(n = nil, &block) + return to_a.sort(&block).last(n).reverse unless n.nil? # max(n): the n largest, descending result = nil first = true __each_packed { |x| if first result = x first = false - elsif x > result - result = x + else + c = block ? block.call(x, result) : (x <=> result) + raise ArgumentError, "comparison of #{x.class} with #{result.class} failed" if c.nil? + result = x if c > 0 end } result end - def minmax - [min, max] + def minmax(&block) + [min(&block), max(&block)] end def reduce(*args) # Forms: reduce { |a, b| }, reduce(init) { }, reduce(:op), reduce(init, :op). + # The operator may be a Symbol or a String (or anything with #to_str); when a + # single argument is given it is the initial value if a block is present and + # otherwise the operator, exactly as MRI decides. + raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1..2)" if args.length > 2 sym = nil has_init = false init = nil @@ -310,11 +346,22 @@ def reduce(*args) init = args[0] sym = args[1] has_init = true - elsif args.length == 1 && args[0].is_a?(Symbol) - sym = args[0] elsif args.length == 1 - init = args[0] - has_init = true + if block_given? + init = args[0] + has_init = true + else + sym = args[0] + end + elsif !block_given? + raise ArgumentError, "wrong number of arguments (given 0, expected 1..2)" + end + unless sym.nil? || sym.is_a?(Symbol) || sym.is_a?(String) + if sym.respond_to?(:to_str) + sym = sym.to_str + else + raise TypeError, "#{sym.inspect} is not a symbol nor a string" + end end acc = init started = has_init @@ -331,9 +378,7 @@ def reduce(*args) acc end - def inject(*args, &blk) - reduce(*args, &blk) - end + alias inject reduce # any?/all?/none? follow MRI's three forms: with a pattern argument each element # is tested with `pattern === x`; with a block the block result is used; with @@ -428,11 +473,11 @@ def compact result end - def each_with_index - return enum_for(:each_with_index) unless block_given? + def each_with_index(*args) + return enum_for(:each_with_index, *args) { size if respond_to?(:size) } unless block_given? i = 0 - __each_packed { |x| - yield(x, i) + each(*args) { |*a| + yield(__pack(a), i) i = i + 1 } self @@ -449,44 +494,42 @@ def reverse_each(&block) end def flat_map - return enum_for(:flat_map) unless block_given? + return enum_for(:flat_map) { size if respond_to?(:size) } unless block_given? r = [] __each_packed { |x| v = yield(x) - if v.is_a?(Array) - v.each { |e| r << e } - else + ary = Array.try_convert(v) + if ary.nil? r << v + else + ary.each { |e| r << e } end } r end # collect_concat is the classic alias of flat_map. - def collect_concat(&blk) - return enum_for(:collect_concat) unless block_given? - flat_map(&blk) - end + alias collect_concat flat_map # each_entry yields each element as MRI's rb_enum_values_pack packs it: a lone # value stays scalar, a multi-value #each yield gathers into an Array, and a # zero-argument yield becomes nil. Unlike map/select (whose block arity governs # a multi-value yield), each_entry always hands the block one packed value. With # no block it returns a sized Enumerator; with a block it returns self. - def each_entry - return enum_for(:each_entry) { size if respond_to?(:size) } unless block_given? - __each_packed { |x| yield(x) } + def each_entry(*args) + return enum_for(:each_entry, *args) { size if respond_to?(:size) } unless block_given? + each(*args) { |*a| yield(__pack(a)) } self end def each_with_object(memo) - return enum_for(:each_with_object, memo) unless block_given? + return enum_for(:each_with_object, memo) { size if respond_to?(:size) } unless block_given? __each_packed { |x| yield(x, memo) } memo end def filter_map - return enum_for(:filter_map) unless block_given? + return enum_for(:filter_map) { size if respond_to?(:size) } unless block_given? r = [] __each_packed { |x| v = yield(x) @@ -496,7 +539,7 @@ def filter_map end def partition - return enum_for(:partition) unless block_given? + return enum_for(:partition) { size if respond_to?(:size) } unless block_given? yes = [] no = [] __each_packed { |x| @@ -510,7 +553,7 @@ def partition end def group_by - return enum_for(:group_by) unless block_given? + return enum_for(:group_by) { size if respond_to?(:size) } unless block_given? h = {} __each_packed { |x| k = yield(x) @@ -529,7 +572,14 @@ def tally(*args) h = {} else a = args[0] - raise TypeError, "no implicit conversion of #{a.nil? ? "nil" : a.class} into Hash" unless a.is_a?(Hash) + unless a.is_a?(Hash) + if a.respond_to?(:to_hash) + a = a.to_hash + raise TypeError, "can't convert #{args[0].class} to Hash (#{args[0].class}#to_hash gives #{a.class})" unless a.is_a?(Hash) + else + raise TypeError, "no implicit conversion of #{a.nil? ? "nil" : a.class} into Hash" + end + end h = a end __each_packed { |x| @@ -549,10 +599,19 @@ def tally(*args) # zip pairs each element with the correspondingly-indexed element of every other # collection (a shorter operand pads with nil). Each other is taken via #to_ary - # or, failing that, #to_a so any Enumerable works. With a block each row is - # yielded and zip returns nil; without one it returns the Array of rows. + # or, failing that, an Enumerator from #to_enum(:each) so any Enumerable works; + # an argument that responds to neither raises TypeError. With a block each row + # is yielded and zip returns nil; without one it returns the Array of rows. def zip(*others) - others = others.map { |o| o.respond_to?(:to_ary) ? o.to_ary : o.to_a } + others = others.map { |o| + if o.respond_to?(:to_ary) + o.to_ary + elsif o.respond_to?(:each) + o.to_enum(:each).to_a + else + raise TypeError, "wrong argument type #{o.class} (must respond to :each)" + end + } blk = block_given? r = blk ? nil : [] i = 0 @@ -574,20 +633,17 @@ def zip(*others) # is an ArgumentError. def find_index(*args) raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" if args.length > 1 - return enum_for(:find_index) if args.empty? && !block_given? + return enum_for(:find_index) { nil } if args.empty? && !block_given? idx = nil i = 0 - __each_packed { |x| - idx = i if idx.nil? && (args.empty? ? yield(x) : x == args[0]) + each { |*a| + idx = i if idx.nil? && (args.empty? ? yield(*a) : __pack(a) == args[0]) i = i + 1 } idx end - def find_all(&blk) - return enum_for(:find_all) unless block_given? - select(&blk) - end + alias find_all select # grep selects the elements that pattern === matches (and maps them through the # block, if given); grep_v keeps the non-matching ones. @@ -604,18 +660,22 @@ def grep_v(pattern) end def take_while - return enum_for(:take_while) unless block_given? + return enum_for(:take_while) { nil } unless block_given? r = [] taking = true - __each_packed { |x| - taking = false if taking && !yield(x) - r << x if taking + each { |*a| + next unless taking + if yield(*a) + r << __pack(a) + else + taking = false + end } r end def drop_while - return enum_for(:drop_while) unless block_given? + return enum_for(:drop_while) { nil } unless block_given? r = [] dropping = true __each_packed { |x| @@ -854,7 +914,7 @@ def slice_after(*args) # minmax_by returns [min, max] compared by the block's mapped value (an empty # collection gives [nil, nil]); with no block it returns an Enumerator. def minmax_by - return enum_for(:minmax_by) unless block_given? + return enum_for(:minmax_by) { size if respond_to?(:size) } unless block_given? [min_by { |x| yield(x) }, max_by { |x| yield(x) }] end @@ -877,12 +937,24 @@ def cycle(n = nil) end end end - a = to_a - return nil if a.empty? + # A non-positive count does nothing and must not touch #each at all. + unless n.nil? + n = __enum_int_arg(n) + return nil if n <= 0 + end + # The first pass drives #each directly (so a block that breaks stops without + # buffering the rest), buffering the packed elements for the later cycles. + buffer = [] + each { |*a| + v = __pack(a) + buffer << v + yield(v) + } + return nil if buffer.empty? if n.nil? - loop { a.each { |x| yield(x) } } + loop { buffer.each { |x| yield(x) } } else - n.times { a.each { |x| yield(x) } } + (n - 1).times { buffer.each { |x| yield(x) } } end nil end diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index b90883fb..6b7a4ae4 100644 --- a/internal/vm/prelude_frozen_gen.go +++ b/internal/vm/prelude_frozen_gen.go @@ -4,6 +4,7 @@ package vm import ( "github.com/go-embedded-ruby/ruby/internal/bytecode" "github.com/go-embedded-ruby/ruby/internal/object" + "math" "math/big" ) @@ -181,13 +182,13 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 44, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 5}, {Op: 9}, {Op: 44, A: 7, B: 6}, {Op: 9}, {Op: 44, A: 8, B: 7}, {Op: 9}, {Op: 44, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 9}, {Op: 9}, {Op: 44, A: 11, B: 10}, {Op: 9}, {Op: 44, A: 12, B: 11}, {Op: 9}, {Op: 44, A: 13, B: 12}, {Op: 9}, {Op: 44, A: 14, B: 13}, {Op: 9}, {Op: 44, A: 15, B: 14}, {Op: 9}, {Op: 44, A: 16, B: 15}, {Op: 9}, {Op: 44, A: 17, B: 16}, {Op: 9}, {Op: 44, A: 18, B: 17}, {Op: 9}, {Op: 44, A: 19, B: 18}, {Op: 9}, {Op: 44, A: 20, B: 19}, {Op: 9}, {Op: 44, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 21}, {Op: 9}, {Op: 44, A: 23, B: 22}, {Op: 9}, {Op: 44, A: 24, B: 23}, {Op: 9}, {Op: 44, A: 25, B: 24}, {Op: 9}, {Op: 44, A: 26, B: 25}, {Op: 9}, {Op: 44, A: 27, B: 26}, {Op: 9}, {Op: 44, A: 28, B: 27}, {Op: 9}, {Op: 44, A: 29, B: 28}, {Op: 9}, {Op: 44, A: 30, B: 29}, {Op: 9}, {Op: 44, A: 31, B: 30}, {Op: 9}, {Op: 44, A: 32, B: 31}, {Op: 9}, {Op: 44, A: 33, B: 32}, {Op: 9}, {Op: 44, A: 34, B: 33}, {Op: 9}, {Op: 44, A: 35, B: 34}, {Op: 9}, {Op: 44, A: 36, B: 35}, {Op: 9}, {Op: 44, A: 37, B: 36}, {Op: 9}, {Op: 44, A: 38, B: 37}, {Op: 9}, {Op: 44, A: 39, B: 38}, {Op: 9}, {Op: 44, A: 40, B: 39}, {Op: 9}, {Op: 44, A: 41, B: 40}, {Op: 9}, {Op: 44, A: 42, B: 41}, {Op: 9}, {Op: 44, A: 43, B: 42}, {Op: 9}, {Op: 44, A: 44, B: 43}, {Op: 9}, {Op: 44, A: 45, B: 44}, {Op: 9}, {Op: 44, A: 46, B: 45}, {Op: 9}, {Op: 44, A: 47, B: 46}, {Op: 9}, {Op: 44, A: 48, B: 47}, {Op: 9}, {Op: 44, A: 49, B: 48}, {Op: 9}, {Op: 44, A: 50, B: 49}, {Op: 9}, {Op: 44, A: 51, B: 50}, {Op: 9}, {Op: 44, A: 52, B: 51}, {Op: 9}, {Op: 44, A: 53, B: 52}, {Op: 9}, {Op: 44, A: 54, B: 53}, {Op: 9}, {Op: 44, A: 55, B: 54}, {Op: 9}, {Op: 44, A: 56, B: 55}, {Op: 9}, {Op: 44, A: 57, B: 56}, {Op: 9}, {Op: 44, A: 58, B: 57}, {Op: 9}, {Op: 44, A: 59, B: 58}, {Op: 9}, {Op: 44, A: 60, B: 59}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 44}, {Op: 9}, {Op: 44, A: 1, B: 1}, {Op: 9}, {Op: 44, A: 2, B: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 3, B: 3}, {Op: 9}, {Op: 44, A: 4, B: 3}, {Op: 9}, {Op: 78, A: 5, B: 4}, {Op: 9}, {Op: 44, A: 6, B: 4}, {Op: 9}, {Op: 44, A: 7, B: 5}, {Op: 9}, {Op: 44, A: 8, B: 6}, {Op: 9}, {Op: 78, A: 9, B: 8}, {Op: 9}, {Op: 44, A: 10, B: 7}, {Op: 9}, {Op: 44, A: 11, B: 8}, {Op: 9}, {Op: 44, A: 12, B: 9}, {Op: 9}, {Op: 44, A: 13, B: 10}, {Op: 9}, {Op: 44, A: 14, B: 11}, {Op: 9}, {Op: 44, A: 15, B: 12}, {Op: 9}, {Op: 78, A: 16, B: 15}, {Op: 9}, {Op: 44, A: 17, B: 13}, {Op: 9}, {Op: 44, A: 18, B: 14}, {Op: 9}, {Op: 78, A: 19, B: 18}, {Op: 9}, {Op: 44, A: 20, B: 15}, {Op: 9}, {Op: 78, A: 21, B: 20}, {Op: 9}, {Op: 44, A: 22, B: 16}, {Op: 9}, {Op: 44, A: 23, B: 17}, {Op: 9}, {Op: 44, A: 24, B: 18}, {Op: 9}, {Op: 44, A: 25, B: 19}, {Op: 9}, {Op: 44, A: 26, B: 20}, {Op: 9}, {Op: 78, A: 27, B: 26}, {Op: 9}, {Op: 44, A: 28, B: 21}, {Op: 9}, {Op: 44, A: 29, B: 22}, {Op: 9}, {Op: 44, A: 30, B: 23}, {Op: 9}, {Op: 44, A: 31, B: 24}, {Op: 9}, {Op: 44, A: 32, B: 25}, {Op: 9}, {Op: 44, A: 33, B: 26}, {Op: 9}, {Op: 44, A: 34, B: 27}, {Op: 9}, {Op: 44, A: 35, B: 28}, {Op: 9}, {Op: 44, A: 36, B: 29}, {Op: 9}, {Op: 78, A: 37, B: 36}, {Op: 9}, {Op: 44, A: 38, B: 30}, {Op: 9}, {Op: 44, A: 39, B: 31}, {Op: 9}, {Op: 44, A: 40, B: 32}, {Op: 9}, {Op: 44, A: 41, B: 33}, {Op: 9}, {Op: 44, A: 42, B: 34}, {Op: 9}, {Op: 44, A: 43, B: 35}, {Op: 9}, {Op: 44, A: 44, B: 36}, {Op: 9}, {Op: 44, A: 45, B: 37}, {Op: 9}, {Op: 78, A: 46, B: 15}, {Op: 9}, {Op: 44, A: 47, B: 38}, {Op: 9}, {Op: 44, A: 48, B: 39}, {Op: 9}, {Op: 44, A: 49, B: 40}, {Op: 9}, {Op: 44, A: 50, B: 41}, {Op: 9}, {Op: 44, A: 51, B: 42}, {Op: 9}, {Op: 44, A: 52, B: 43}, {Op: 9}, {Op: 44, A: 53, B: 44}, {Op: 9}, {Op: 44, A: 54, B: 45}, {Op: 9}, {Op: 44, A: 55, B: 46}, {Op: 9}, {Op: 44, A: 56, B: 47}, {Op: 9}, {Op: 44, A: 57, B: 48}, {Op: 9}, {Op: 44, A: 58, B: 49}, {Op: 9}, {Op: 44, A: 59, B: 50}, {Op: 9}, {Op: 44, A: 60, B: 51}, {Op: 9}, {Op: 44, A: 61, B: 52}, {Op: 9}, {Op: 44, A: 62, B: 53}, {Op: 53}}, Consts: []object.Value{ object.Symbol("__each_packed"), object.Symbol("__pack"), object.Symbol("__enum_int_arg"), }, - Names: []string{"__each_packed", "__pack", "__enum_int_arg", "private", "to_a", "to_set", "to_h", "map", "collect", "filter", "detect", "count", "min_by", "max_by", "sort", "sort_by", "select", "reject", "find", "include?", "sum", "min", "max", "minmax", "reduce", "inject", "any?", "all?", "none?", "one?", "uniq", "compact", "each_with_index", "reverse_each", "flat_map", "collect_concat", "each_entry", "each_with_object", "filter_map", "partition", "group_by", "tally", "zip", "find_index", "find_all", "grep", "grep_v", "take_while", "drop_while", "each_slice", "each_cons", "first", "take", "drop", "chunk_while", "slice_when", "chunk", "slice_before", "slice_after", "minmax_by", "cycle"}, + Names: []string{"__each_packed", "__pack", "__enum_int_arg", "private", "to_a", "entries", "to_set", "to_h", "map", "collect", "count", "min_by", "max_by", "sort", "sort_by", "select", "filter", "reject", "find", "detect", "include?", "member?", "sum", "min", "max", "minmax", "reduce", "inject", "any?", "all?", "none?", "one?", "uniq", "compact", "each_with_index", "reverse_each", "flat_map", "collect_concat", "each_entry", "each_with_object", "filter_map", "partition", "group_by", "tally", "zip", "find_index", "find_all", "grep", "grep_v", "take_while", "drop_while", "each_slice", "each_cons", "first", "take", "drop", "chunk_while", "slice_when", "chunk", "slice_before", "slice_after", "minmax_by", "cycle"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, @@ -266,26 +267,27 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "to_a", - Insns: []bytecode.Instr{{Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, - Names: []string{"__each_packed"}, + Insns: []bytecode.Instr{{Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Names: []string{"each"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"r"}, + NumLocals: 2, + Locals: []string{"args", "r"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}}, - Names: []string{"<<"}, - Params: []string{"x"}, - NumRequired: 1, - SplatIndex: -1, + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 53}}, + Names: []string{"__pack", "<<"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, @@ -293,30 +295,32 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "to_set", - Insns: []bytecode.Instr{{Op: 33}, {Op: 5}, {Op: 11}, {Op: 66, A: 1, B: 1, Flags: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 33}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 6}, {Op: 5}, {Op: 6, A: 1}, {Op: 61}, {Op: 11, A: 1}, {Op: 60}, {Op: 61}, {Op: 11, A: 2}, {Op: 67, A: 1, Flags: 1}, {Op: 53}}, Names: []string{"Set", "new"}, + Params: []string{"klass", "args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 1, KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"block"}, + BlockSlot: 2, + NumLocals: 3, + Locals: []string{"klass", "args", "block"}, Super: "", }, &bytecode.ISeq{ Name: "to_h", - Insns: []bytecode.Instr{{Op: 7}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, - Names: []string{"__each_packed"}, + Insns: []bytecode.Instr{{Op: 7}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Names: []string{"each"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"h"}, + NumLocals: 2, + Locals: []string{"args", "h"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 28}, {Op: 5}, {Op: 33, A: 2}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 29}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 25}, {Op: 28, A: 51}, {Op: 5}, {Op: 33, A: 7}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 3}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 3}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 3}, {Op: 13}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 52}, {Op: 2}, {Op: 9}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 11, A: 1}, {Op: 1, A: 8}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 30, A: 9, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 8}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 11}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 11, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 36}, {Op: 5}, {Op: 33, A: 4}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 37}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 1, A: 3}, {Op: 22}, {Op: 25}, {Op: 28, A: 59}, {Op: 5}, {Op: 33, A: 9}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 30, A: 5}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 8, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 6}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 26, A: 60}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 1, A: 7}, {Op: 30, A: 10, B: 1, Flags: 1}, {Op: 11, A: 2}, {Op: 1, A: 8}, {Op: 30, A: 10, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 30, A: 11, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 53}}, Consts: []object.Value{ object.NewString(""), object.NewString("wrong element type "), @@ -328,14 +332,14 @@ func embeddedPrelude() *bytecode.ISeq { object.IntValue(0), object.IntValue(1), }, - Names: []string{"Array", "is_a?", "TypeError", "to_s", "class", "raise", "length", "ArgumentError", "[]", "[]="}, - Params: []string{"x"}, - NumRequired: 1, - SplatIndex: -1, + Names: []string{"__pack", "Array", "try_convert", "nil?", "TypeError", "to_s", "class", "raise", "length", "ArgumentError", "[]", "[]="}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 3, - Locals: []string{"x", "pair", ""}, + NumLocals: 4, + Locals: []string{"a", "pair", "ary", ""}, Super: "", }, }, @@ -343,11 +347,11 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "map", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("map"), }, - Names: []string{"enum_for", "__each_packed"}, + Names: []string{"enum_for", "each"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, @@ -355,67 +359,36 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, B: 1}, {Op: 11}, {Op: 48, A: 1}, {Op: 30, B: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11, B: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 30, B: 1}, {Op: 53}}, Names: []string{"<<"}, - Params: []string{"x"}, - NumRequired: 1, - SplatIndex: -1, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, Super: "", }, - &bytecode.ISeq{ - Name: "collect", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 53}}, - Consts: []object.Value{ - object.Symbol("collect"), - }, - Names: []string{"enum_for", "map"}, - NumRequired: 0, - SplatIndex: -1, - KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"blk"}, - Super: "", - }, - &bytecode.ISeq{ - Name: "filter", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 53}}, - Consts: []object.Value{ - object.Symbol("filter"), - }, - Names: []string{"enum_for", "select"}, - NumRequired: 0, - SplatIndex: -1, - KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"blk"}, - Super: "", - }, - &bytecode.ISeq{ - Name: "detect", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 53}}, - Consts: []object.Value{ - object.Symbol("detect"), - }, - Names: []string{"enum_for", "find"}, - NumRequired: 0, - SplatIndex: -1, - KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"blk"}, - Super: "", - }, &bytecode.ISeq{ Name: "count", Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 1, A: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 28, A: 37}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 26, A: 44}, {Op: 52}, {Op: 28, A: 42}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 26, A: 44}, {Op: 5}, {Op: 30, A: 6, C: 3}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, @@ -486,7 +459,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "min_by", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 1, Flags: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 1}, {Op: 53}}, Consts: []object.Value{ object.Symbol("min_by"), }, @@ -499,6 +472,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"args"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}}, @@ -516,7 +503,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "max_by", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 1, Flags: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 2, C: 2, Flags: 1}, {Op: 53}}, Consts: []object.Value{ object.Symbol("max_by"), }, @@ -529,6 +516,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"args"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}}, @@ -558,7 +559,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "sort_by", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, C: 2, Flags: 1}, {Op: 53}}, Consts: []object.Value{ object.Symbol("sort_by"), }, @@ -569,6 +570,20 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}}, @@ -586,7 +601,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "select", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("select"), }, @@ -598,6 +613,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, @@ -616,7 +645,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "reject", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("reject"), }, @@ -628,6 +657,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 25}, {Op: 28, A: 8}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 9}, {Op: 2}, {Op: 53}}, @@ -646,21 +689,32 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "find", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 4}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 30}, {Op: 11, A: 2}, {Op: 53}, {Op: 26, A: 31}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 37}, {Op: 2}, {Op: 26, A: 39}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 53}}, Consts: []object.Value{ object.Symbol("find"), }, - Names: []string{"enum_for", "__each_packed"}, + Names: []string{"enum_for", "__each_packed", "nil?", "call"}, + Params: []string{"ifnone"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"result"}, + NumLocals: 3, + Locals: []string{"ifnone", "found", "result"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, B: 1}, {Op: 2}, {Op: 22}, {Op: 28, A: 12}, {Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 10}, {Op: 11}, {Op: 12, B: 1}, {Op: 26, A: 11}, {Op: 2}, {Op: 26, A: 13}, {Op: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 2}, {Op: 53}}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 14}, {Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 12}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 13}, {Op: 2}, {Op: 26, A: 15}, {Op: 2}, {Op: 53}}, Params: []string{"x"}, NumRequired: 1, SplatIndex: -1, @@ -702,29 +756,31 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "sum", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 2, C: 1}, {Op: 9}, {Op: 11, A: 3}, {Op: 28, A: 25}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 13}, {Op: 26, A: 26}, {Op: 11, A: 1}, {Op: 53}}, Consts: []object.Value{ object.IntValue(0), + frozenFloat(0x0), }, - Names: []string{"__each_packed"}, + Names: []string{"Float", "is_a?", "__each_packed"}, Params: []string{"init"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 2, - Locals: []string{"init", "total"}, + NumLocals: 4, + Locals: []string{"init", "total", "compensation", "float_mode"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 52}, {Op: 28, A: 6}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 7}, {Op: 11}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 28, A: 5}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 6}, {Op: 11}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 24}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 12, A: 1, B: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 25}, {Op: 2}, {Op: 9}, {Op: 11, A: 3, B: 1}, {Op: 10}, {Op: 28, A: 33}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 63}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 21}, {Op: 28, A: 52}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1}, {Op: 13}, {Op: 26, A: 57}, {Op: 11, A: 1}, {Op: 11, A: 2}, {Op: 14}, {Op: 11, A: 1, B: 1}, {Op: 13}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 67}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}}, + Names: []string{"Float", "is_a?", "to_f", "abs"}, Params: []string{"x"}, NumRequired: 1, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"x"}, + NumLocals: 3, + Locals: []string{"x", "v", "t"}, Super: "", }, }, @@ -732,26 +788,34 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "min", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 16}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}, {Op: 26, A: 17}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}}, Names: []string{"nil?", "to_a", "sort", "first", "__each_packed"}, Params: []string{"n"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 3, - Locals: []string{"n", "result", "first"}, + BlockSlot: 1, + NumLocals: 4, + Locals: []string{"n", "block", "result", "first"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ - Name: "", - Insns: []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 1, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 16}, {Op: 11}, {Op: 11, A: 1, B: 1}, {Op: 18}, {Op: 28, A: 15}, {Op: 11}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}}, + Name: "", + Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 18}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.NewString(""), + object.NewString("comparison of "), + object.NewString(" with "), + object.NewString(" failed"), + object.IntValue(0), + }, + Names: []string{"call", "<=>", "nil?", "ArgumentError", "to_s", "class", "raise"}, Params: []string{"x"}, NumRequired: 1, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"x"}, + NumLocals: 2, + Locals: []string{"x", "c"}, Super: "", }, }, @@ -759,26 +823,34 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "max", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 17}, {Op: 5}, {Op: 30, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 53}, {Op: 26, A: 18}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 25}, {Op: 28, A: 18}, {Op: 5}, {Op: 30, A: 1}, {Op: 11, A: 1}, {Op: 66, A: 2, Flags: 1}, {Op: 11}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 53}, {Op: 26, A: 19}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 2}, {Op: 9}, {Op: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 30, A: 5, C: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 53}}, Names: []string{"nil?", "to_a", "sort", "last", "reverse", "__each_packed"}, Params: []string{"n"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 3, - Locals: []string{"n", "result", "first"}, + BlockSlot: 1, + NumLocals: 4, + Locals: []string{"n", "block", "result", "first"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ - Name: "", - Insns: []bytecode.Instr{{Op: 11, A: 2, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 1, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 16}, {Op: 11}, {Op: 11, A: 1, B: 1}, {Op: 19}, {Op: 28, A: 15}, {Op: 11}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 16}, {Op: 2}, {Op: 53}}, + Name: "", + Insns: []bytecode.Instr{{Op: 11, A: 3, B: 1}, {Op: 28, A: 8}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 3, B: 1}, {Op: 26, A: 55}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 15}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, B: 2, Flags: 1}, {Op: 26, A: 18}, {Op: 11}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 45}, {Op: 5}, {Op: 33, A: 3}, {Op: 1}, {Op: 1, A: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 11}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 2}, {Op: 30, A: 4}, {Op: 13}, {Op: 11, A: 2, B: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 30, A: 4}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 4}, {Op: 13}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 46}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 1, A: 4}, {Op: 19}, {Op: 28, A: 54}, {Op: 11}, {Op: 12, A: 2, B: 1}, {Op: 26, A: 55}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.NewString(""), + object.NewString("comparison of "), + object.NewString(" with "), + object.NewString(" failed"), + object.IntValue(0), + }, + Names: []string{"call", "<=>", "nil?", "ArgumentError", "to_s", "class", "raise"}, Params: []string{"x"}, NumRequired: 1, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"x"}, + NumLocals: 2, + Locals: []string{"x", "c"}, Super: "", }, }, @@ -786,24 +858,33 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "minmax", - Insns: []bytecode.Instr{{Op: 5}, {Op: 30}, {Op: 5}, {Op: 30, A: 1}, {Op: 6, A: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 66}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 6, A: 2}, {Op: 53}}, Names: []string{"min", "max"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, - BlockSlot: -1, - NumLocals: 0, + BlockSlot: 0, + NumLocals: 1, + Locals: []string{"block"}, Super: "", }, &bytecode.ISeq{ Name: "reduce", - Insns: []bytecode.Instr{{Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 27}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 2}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 59}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 2}, {Op: 22}, {Op: 10}, {Op: 28, A: 39}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 33, A: 2}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 28, A: 45}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 59}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 2}, {Op: 22}, {Op: 28, A: 58}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 59}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 5}, {Op: 30, A: 4, C: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 4}, {Op: 12, A: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 22}, {Op: 28, A: 49}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 78}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 5}, {Op: 22}, {Op: 28, A: 69}, {Op: 52}, {Op: 28, A: 64}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 68}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 4, B: 1, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 78}, {Op: 52}, {Op: 25}, {Op: 28, A: 77}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 6}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 78}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 5, Flags: 1}, {Op: 10}, {Op: 27, A: 87}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 93}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, Flags: 1}, {Op: 28, A: 103}, {Op: 11, A: 1}, {Op: 30, A: 10, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 117}, {Op: 5}, {Op: 33, A: 11}, {Op: 1, A: 8}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 119}, {Op: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 12, A: 4}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 5}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 4}, {Op: 53}}, Consts: []object.Value{ object.IntValue(2), + object.NewString(""), + object.NewString("wrong number of arguments (given "), + object.NewString(", expected 1..2)"), object.IntValue(0), object.IntValue(1), + object.NewString("wrong number of arguments (given 0, expected 1..2)"), + object.Symbol("to_str"), + object.NewString(""), + object.NewString(""), + object.NewString(" is not a symbol nor a string"), }, - Names: []string{"length", "[]", "Symbol", "is_a?", "__each_packed"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "[]", "nil?", "Symbol", "is_a?", "String", "respond_to?", "to_str", "TypeError", "inspect", "__each_packed"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -828,19 +909,6 @@ func embeddedPrelude() *bytecode.ISeq { }, Super: "", }, - &bytecode.ISeq{ - Name: "inject", - Insns: []bytecode.Instr{{Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 11, A: 1}, {Op: 67}, {Op: 53}}, - Names: []string{"reduce"}, - Params: []string{"args"}, - NumRequired: 0, - SplatIndex: 0, - KwRestSlot: -1, - BlockSlot: 1, - NumLocals: 2, - Locals: []string{"args", "blk"}, - Super: "", - }, &bytecode.ISeq{ Name: "any?", Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 8}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}}, @@ -1092,32 +1160,48 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "each_with_index", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 1, A: 1}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 5}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 1, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}}, Consts: []object.Value{ object.Symbol("each_with_index"), object.IntValue(0), }, - Names: []string{"enum_for", "__each_packed"}, + Names: []string{"enum_for", "each"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 1, - Locals: []string{"i"}, + NumLocals: 2, + Locals: []string{"args", "i"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11}, {Op: 11, B: 1}, {Op: 48, A: 2}, {Op: 9}, {Op: 11, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, B: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, Consts: []object.Value{ - object.IntValue(1), + object.Symbol("size"), }, - Params: []string{"x"}, - NumRequired: 1, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, + NumLocals: 0, + Super: "", + }, + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 11, A: 1, B: 1}, {Op: 48, A: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 1}, {Op: 13}, {Op: 12, A: 1, B: 1}, {Op: 53}}, + Consts: []object.Value{ + object.IntValue(1), + }, + Names: []string{"__pack"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, + KwRestSlot: -1, + BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, @@ -1156,7 +1240,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "flat_map", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("flat_map"), }, @@ -1168,17 +1252,31 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 33}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 28, A: 11}, {Op: 11, A: 1}, {Op: 30, A: 2, C: 1, Flags: 1}, {Op: 26, A: 14}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 53}}, - Names: []string{"Array", "is_a?", "each", "<<"}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 33}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 16}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 3, B: 1}, {Op: 26, A: 18}, {Op: 11, A: 2}, {Op: 30, A: 4, C: 1, Flags: 1}, {Op: 53}}, + Names: []string{"Array", "try_convert", "nil?", "<<", "each"}, Params: []string{"x"}, NumRequired: 1, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 2, - Locals: []string{"x", "v"}, + NumLocals: 3, + Locals: []string{"x", "v", "ary"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -1199,33 +1297,20 @@ func embeddedPrelude() *bytecode.ISeq { }, Super: "", }, - &bytecode.ISeq{ - Name: "collect_concat", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 53}}, - Consts: []object.Value{ - object.Symbol("collect_concat"), - }, - Names: []string{"enum_for", "flat_map"}, - NumRequired: 0, - SplatIndex: -1, - KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"blk"}, - Super: "", - }, &bytecode.ISeq{ Name: "each_entry", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 6}, {Op: 1}, {Op: 6, A: 1}, {Op: 61}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 62, A: 1, C: 2}, {Op: 9}, {Op: 5}, {Op: 53}}, Consts: []object.Value{ object.Symbol("each_entry"), }, - Names: []string{"enum_for", "__each_packed"}, + Names: []string{"enum_for", "each"}, + Params: []string{"args"}, NumRequired: 0, - SplatIndex: -1, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, - NumLocals: 0, + NumLocals: 1, + Locals: []string{"args"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -1243,14 +1328,15 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}}, - Params: []string{"x"}, - NumRequired: 1, - SplatIndex: -1, + Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 48, A: 1}, {Op: 53}}, + Names: []string{"__pack"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, @@ -1258,7 +1344,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "each_with_object", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 9}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 10}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("each_with_object"), }, @@ -1271,6 +1357,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"memo"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 11, B: 1}, {Op: 48, A: 2}, {Op: 53}}, @@ -1288,7 +1388,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "filter_map", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("filter_map"), }, @@ -1300,6 +1400,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 28, A: 10}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1}, {Op: 26, A: 11}, {Op: 2}, {Op: 53}}, @@ -1318,7 +1432,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "partition", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 11, A: 1}, {Op: 6, A: 2}, {Op: 53}}, Consts: []object.Value{ object.Symbol("partition"), }, @@ -1330,6 +1444,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 2, Locals: []string{"yes", "no"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 28, A: 7}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 10}, {Op: 11, A: 1, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 53}}, @@ -1348,7 +1476,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "group_by", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 7}, {Op: 12}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("group_by"), }, @@ -1360,6 +1488,20 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"h"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 11, B: 1}, {Op: 11, A: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 10}, {Op: 27, A: 13}, {Op: 9}, {Op: 6}, {Op: 12, A: 2}, {Op: 30, A: 1, B: 2, Flags: 1}, {Op: 9}, {Op: 11, A: 2}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 53}}, @@ -1378,19 +1520,25 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "tally", - Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 28}, {Op: 7}, {Op: 12, A: 1}, {Op: 26, A: 62}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 58}, {Op: 5}, {Op: 33, A: 8}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 9, Flags: 1}, {Op: 28, A: 49}, {Op: 1, A: 7}, {Op: 26, A: 51}, {Op: 11, A: 2}, {Op: 30, A: 10, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 59}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 11, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 28}, {Op: 7}, {Op: 12, A: 1}, {Op: 26, A: 110}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 106}, {Op: 11, A: 2}, {Op: 1, A: 5}, {Op: 30, A: 8, B: 1, Flags: 1}, {Op: 28, A: 86}, {Op: 11, A: 2}, {Op: 30, A: 9, Flags: 1}, {Op: 12, A: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 33, A: 6}, {Op: 30, A: 7, B: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 84}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 6}, {Op: 1, A: 7}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 8}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, Flags: 1}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 9}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 10}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 85}, {Op: 2}, {Op: 26, A: 105}, {Op: 5}, {Op: 33, A: 10}, {Op: 1, A: 11}, {Op: 1, A: 12}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 2}, {Op: 30, A: 12, Flags: 1}, {Op: 28, A: 97}, {Op: 1, A: 13}, {Op: 26, A: 99}, {Op: 11, A: 2}, {Op: 30, A: 11, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 14}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 107}, {Op: 2}, {Op: 9}, {Op: 11, A: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 13, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, Consts: []object.Value{ object.IntValue(1), object.NewString(""), object.NewString("wrong number of arguments (given "), object.NewString(", expected 0..1)"), object.IntValue(0), + object.Symbol("to_hash"), + object.NewString(""), + object.NewString("can't convert "), + object.NewString(" to Hash ("), + object.NewString("#to_hash gives "), + object.NewString(")"), object.NewString(""), object.NewString("no implicit conversion of "), object.NewString("nil"), object.NewString(" into Hash"), }, - Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "[]", "Hash", "is_a?", "TypeError", "nil?", "class", "__each_packed"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "[]", "Hash", "is_a?", "respond_to?", "to_hash", "TypeError", "class", "nil?", "__each_packed"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -1442,11 +1590,15 @@ func embeddedPrelude() *bytecode.ISeq { Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 26, A: 9}, {Op: 11}, {Op: 30, A: 2, Flags: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 7}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 26, A: 30}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, B: 1, Flags: 1}, {Op: 28, A: 16}, {Op: 11}, {Op: 1, A: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 30, A: 3, Flags: 1}, {Op: 26, A: 30}, {Op: 5}, {Op: 33, A: 4}, {Op: 1, A: 2}, {Op: 1, A: 3}, {Op: 30, A: 5}, {Op: 13}, {Op: 11}, {Op: 30, A: 6, Flags: 1}, {Op: 30, A: 5}, {Op: 13}, {Op: 1, A: 4}, {Op: 30, A: 5}, {Op: 13}, {Op: 30, A: 7, B: 2}, {Op: 53}}, Consts: []object.Value{ object.Symbol("to_ary"), + object.Symbol("each"), + object.NewString(""), + object.NewString("wrong argument type "), + object.NewString(" (must respond to :each)"), }, - Names: []string{"respond_to?", "to_ary", "to_a"}, + Names: []string{"respond_to?", "to_ary", "to_enum", "to_a", "TypeError", "to_s", "class", "raise"}, Params: []string{"o"}, NumRequired: 1, SplatIndex: -1, @@ -1492,7 +1644,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "find_index", - Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 29}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11}, {Op: 30, Flags: 1}, {Op: 1}, {Op: 19}, {Op: 28, A: 20}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 30, A: 2}, {Op: 13}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 3}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 10}, {Op: 28, A: 29}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 35}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 5, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 5}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 6, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, Consts: []object.Value{ object.IntValue(1), object.NewString(""), @@ -1501,7 +1653,7 @@ func embeddedPrelude() *bytecode.ISeq { object.Symbol("find_index"), object.IntValue(0), }, - Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "__each_packed"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "each"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -1510,41 +1662,36 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 3, Locals: []string{"args", "idx", "i"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 2}, {Op: 53}}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 16}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 11}, {Op: 11}, {Op: 48, A: 1}, {Op: 26, A: 16}, {Op: 11}, {Op: 11, B: 1}, {Op: 1}, {Op: 30, A: 2, B: 1, Flags: 1}, {Op: 22}, {Op: 28, A: 20}, {Op: 11, A: 2, B: 1}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 30, Flags: 1}, {Op: 10}, {Op: 28, A: 21}, {Op: 9}, {Op: 11, B: 1}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 14}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 26, A: 21}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 11, B: 1}, {Op: 1}, {Op: 30, A: 3, B: 1, Flags: 1}, {Op: 22}, {Op: 28, A: 25}, {Op: 11, A: 2, B: 1}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 11, A: 2, B: 1}, {Op: 1, A: 1}, {Op: 13}, {Op: 12, A: 2, B: 1}, {Op: 53}}, Consts: []object.Value{ object.IntValue(0), object.IntValue(1), }, - Names: []string{"nil?", "empty?", "[]"}, - Params: []string{"x"}, - NumRequired: 1, - SplatIndex: -1, + Names: []string{"nil?", "empty?", "__pack", "[]"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, Super: "", }, - &bytecode.ISeq{ - Name: "find_all", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 11}, {Op: 66, A: 1}, {Op: 53}}, - Consts: []object.Value{ - object.Symbol("find_all"), - }, - Names: []string{"enum_for", "select"}, - NumRequired: 0, - SplatIndex: -1, - KwRestSlot: -1, - BlockSlot: 0, - NumLocals: 1, - Locals: []string{"blk"}, - Super: "", - }, &bytecode.ISeq{ Name: "grep", Insns: []bytecode.Instr{{Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, C: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 53}}, @@ -1603,11 +1750,11 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "take_while", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("take_while"), }, - Names: []string{"enum_for", "__each_packed"}, + Names: []string{"enum_for", "each"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, @@ -1617,15 +1764,25 @@ func embeddedPrelude() *bytecode.ISeq { Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 11}, {Op: 48, A: 1}, {Op: 25}, {Op: 28, A: 11}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 28, A: 19}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 20}, {Op: 2}, {Op: 53}}, - Names: []string{"<<"}, - Params: []string{"x"}, - NumRequired: 1, + Insns: []bytecode.Instr{{Op: 2}, {Op: 53}}, + NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, + NumLocals: 0, + Super: "", + }, + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 6}, {Op: 2}, {Op: 53}, {Op: 26, A: 7}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 11}, {Op: 60}, {Op: 61}, {Op: 49}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 30, A: 1, B: 1}, {Op: 26, A: 22}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 53}}, + Names: []string{"__pack", "<<"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, + KwRestSlot: -1, + BlockSlot: -1, NumLocals: 1, - Locals: []string{"x"}, + Locals: []string{"a"}, Super: "", }, }, @@ -1633,7 +1790,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "drop_while", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 9}, {Op: 11}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12}, {Op: 9}, {Op: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 9}, {Op: 11}, {Op: 53}}, Consts: []object.Value{ object.Symbol("drop_while"), }, @@ -1645,6 +1802,16 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 2, Locals: []string{"r", "dropping"}, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 2}, {Op: 53}}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 10}, {Op: 28, A: 7}, {Op: 9}, {Op: 11}, {Op: 48, A: 1}, {Op: 25}, {Op: 28, A: 11}, {Op: 4}, {Op: 12, A: 1, B: 1}, {Op: 26, A: 12}, {Op: 2}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 25}, {Op: 28, A: 20}, {Op: 11, B: 1}, {Op: 11}, {Op: 30, B: 1}, {Op: 26, A: 21}, {Op: 2}, {Op: 53}}, @@ -2120,7 +2287,7 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "minmax_by", - Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 1}, {Op: 5}, {Op: 30, A: 2, C: 2}, {Op: 6, A: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 52}, {Op: 25}, {Op: 28, A: 8}, {Op: 5}, {Op: 1}, {Op: 30, B: 1, C: 1}, {Op: 53}, {Op: 26, A: 9}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1, C: 2}, {Op: 5}, {Op: 30, A: 2, C: 3}, {Op: 6, A: 2}, {Op: 53}}, Consts: []object.Value{ object.Symbol("minmax_by"), }, @@ -2131,6 +2298,20 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Children: []*bytecode.ISeq{ + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 1}, {Op: 30, B: 1}, {Op: 28, A: 7}, {Op: 5}, {Op: 30, A: 1}, {Op: 26, A: 8}, {Op: 2}, {Op: 53}}, + Consts: []object.Value{ + object.Symbol("size"), + }, + Names: []string{"respond_to?", "size"}, + NumRequired: 0, + SplatIndex: -1, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 0, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11}, {Op: 48, A: 1}, {Op: 53}}, @@ -2160,18 +2341,20 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "cycle", - Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 2, Flags: 1}, {Op: 28, A: 26}, {Op: 2}, {Op: 53}, {Op: 26, A: 27}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 3, Flags: 1}, {Op: 28, A: 34}, {Op: 5}, {Op: 30, A: 4, C: 2}, {Op: 26, A: 36}, {Op: 11}, {Op: 30, A: 5, C: 3, Flags: 1}, {Op: 9}, {Op: 2}, {Op: 53}}, + Insns: []bytecode.Instr{{Op: 54}, {Op: 27, A: 5}, {Op: 2}, {Op: 12}, {Op: 9}, {Op: 52}, {Op: 25}, {Op: 28, A: 14}, {Op: 5}, {Op: 1}, {Op: 11}, {Op: 30, B: 2, C: 1}, {Op: 53}, {Op: 26, A: 15}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 25}, {Op: 28, A: 34}, {Op: 5}, {Op: 11}, {Op: 30, A: 2, B: 1}, {Op: 12}, {Op: 9}, {Op: 11}, {Op: 1, A: 1}, {Op: 20}, {Op: 28, A: 32}, {Op: 2}, {Op: 53}, {Op: 26, A: 33}, {Op: 2}, {Op: 26, A: 35}, {Op: 2}, {Op: 9}, {Op: 6}, {Op: 12, A: 1}, {Op: 9}, {Op: 5}, {Op: 30, A: 3, C: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 4, Flags: 1}, {Op: 28, A: 48}, {Op: 2}, {Op: 53}, {Op: 26, A: 49}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 1, Flags: 1}, {Op: 28, A: 56}, {Op: 5}, {Op: 30, A: 5, C: 3}, {Op: 26, A: 60}, {Op: 11}, {Op: 1, A: 2}, {Op: 14}, {Op: 30, A: 6, C: 4, Flags: 1}, {Op: 9}, {Op: 2}, {Op: 53}}, Consts: []object.Value{ object.Symbol("cycle"), + object.IntValue(0), + object.IntValue(1), }, - Names: []string{"enum_for", "to_a", "empty?", "nil?", "loop", "times"}, + Names: []string{"enum_for", "nil?", "__enum_int_arg", "each", "empty?", "loop", "times"}, Params: []string{"n"}, NumRequired: 0, SplatIndex: -1, KwRestSlot: -1, BlockSlot: -1, NumLocals: 2, - Locals: []string{"n", "a"}, + Locals: []string{"n", "buffer"}, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -2189,6 +2372,19 @@ func embeddedPrelude() *bytecode.ISeq { Locals: []string{"sz"}, Super: "", }, + &bytecode.ISeq{ + Name: "", + Insns: []bytecode.Instr{{Op: 5}, {Op: 11}, {Op: 30, B: 1}, {Op: 12, A: 1}, {Op: 9}, {Op: 11, A: 1, B: 1}, {Op: 11, A: 1}, {Op: 30, A: 1, B: 1}, {Op: 9}, {Op: 11, A: 1}, {Op: 48, A: 1}, {Op: 53}}, + Names: []string{"__pack", "<<"}, + Params: []string{"a"}, + NumRequired: 0, + SplatIndex: 0, + KwRestSlot: -1, + BlockSlot: -1, + NumLocals: 2, + Locals: []string{"a", "v"}, + Super: "", + }, &bytecode.ISeq{ Name: "", Insns: []bytecode.Instr{{Op: 11, A: 1, B: 1}, {Op: 30, C: 1, Flags: 1}, {Op: 53}}, @@ -6445,3 +6641,7 @@ func frozenBig(s string) *big.Int { i, _ := new(big.Int).SetString(s, 10) return i } + +func frozenFloat(bits uint64) object.Float { + return object.Float(math.Float64frombits(bits)) +}