From a88525582d01b6a8bee1afec83501a1e17b43fdf Mon Sep 17 00:00:00 2001 From: tannevaled Date: Sun, 27 Sep 2026 00:12:53 +0200 Subject: [PATCH] internal/vm: one gate and one composition for rb_warn, so the diagnostics fire, carry their position, and a redefined constant warns twice (#641, #699) $VERBOSE had two representations of one value and the gate read the one nobody writes. Four call sites tested vm.globals["$VERBOSE"] straight out of the map, which is unset until a program assigns it; every Ruby-level read went through verboseSlot and answered false, MRI's default. So `$VERBOSE.nil?` agreed on both engines and no Ruby-level probe could see the gate, while assigning $VERBOSE the value it already read turned the warnings on. warnEnabled (!NIL_P) and warningEnabled (RTEST) are now the only two places that decide, reading the slot through verboseSlot rather than seeding it, so a fresh VM and one handed an explicit false cannot disagree again. rbWarn is now the only place a warning is composed: error.c's warning_string -> warn_vsprintf -> err_vcatf, i.e. the current frame's "path:lineno: " then "warning: ". Nine callers passed their own "warning: " and two passed none, so two of them printed no "warning: " at all. rbCompileWarn is error.c's rb_compile_warn: the same gate and sink with an explicit position, which is what the second line of a constant redefinition needs. A redefined constant now emits both of MRI's lines, the second pointing at the original definition through the constLocs record const_source_location already keeps. Struct.new's named form keeps struct.c's own wording ("redefining constant Struct::Foo"), which a test had pinned as "already initialized". Thirteen "given block not used" warnings MRI emits were missing entirely (Array/Hash/Enumerable count, any?, all?, none?, one?, find_index), and Regexp.new's ignorecase warning was rb_warn where object.c rb_bool_expected uses rb_warning. The circular-require and autoload-did-not-define warnings wrote past Warning.warn to $stderr. Three constants the prelude re-assigned (Slim::Engine, Haml::Engine, OptParse) were already bound natively to the same objects, so with the gate fixed every rbgo run printed three warnings MRI never emits. The redundant assignments are gone and the frozen prelude regenerated. ruby/spec language+core (2206 spec files, corpus 87b1631): 23215 -> 23228. Co-Authored-By: Claude Opus 5 --- internal/vm/autoload.go | 12 +- internal/vm/builtins.go | 119 +- internal/vm/env.go | 2 +- internal/vm/env_wave16_test.go | 10 +- internal/vm/getoptlong_test.go | 7 +- internal/vm/globals.go | 31 +- internal/vm/io.go | 6 +- internal/vm/io_class.go | 21 +- internal/vm/io_modeenc_internal_test.go | 39 +- internal/vm/modulefunc.go | 2 +- internal/vm/phase5f_test.go | 6 +- internal/vm/prelude.rb | 36 +- internal/vm/prelude_frozen_gen.go | 1767 ++++++++++---------- internal/vm/refinement_import.go | 2 +- internal/vm/regexp.go | 10 +- internal/vm/require.go | 12 +- internal/vm/struct.go | 20 +- internal/vm/struct_conformance_test.go | 13 +- internal/vm/verbose_gate_wave45_test.go | 300 ++++ internal/vm/vm.go | 45 +- internal/vm/wave24_lang_test.go | 26 +- internal/vm/wave28_file_fd_open_test.go | 2 +- internal/vm/wave28_modreg_internal_test.go | 4 +- internal/vm/wave31_consts_internal_test.go | 7 +- 24 files changed, 1500 insertions(+), 999 deletions(-) create mode 100644 internal/vm/verbose_gate_wave45_test.go diff --git a/internal/vm/autoload.go b/internal/vm/autoload.go index cbd3b74c..c8592dbf 100644 --- a/internal/vm/autoload.go +++ b/internal/vm/autoload.go @@ -257,18 +257,22 @@ func (vm *VM) tryAutoload(cls *RClass, name string) bool { // It goes through rb_warning, not rb_warn, so only $VERBOSE == true shows it — // the same gate warnCircularRequire applies — and it is emitted at most once // per registration because the caller has already retired the entry. +// +// rbWarning, not a curStderr() write: rb_warning ends in rb_write_warning_str +// like every other internal warning, so an overridden Warning.warn intercepts +// this one too, and it carries the file:lineno prefix warning_string composes. The +// gate was ALSO reading vm.globals["$VERBOSE"] out of the map, which is unset +// until a program assigns it, so a Bool type assertion there could never be true +// on a run that only passed -w. func (vm *VM) warnAutoloadDidNotDefine(cls *RClass, name, path string) { if _, defined := cls.consts[name]; defined { return } - if v, ok := vm.globals["$VERBOSE"].(object.Bool); !ok || !bool(v) { - return - } qualified := name if cls != vm.cObject { qualified = vm.moduleToSStr(cls) + "::" + name } - vm.curStderr().writeStr("warning: Expected " + path + " to define " + qualified + " but it didn't\n") + vm.rbWarning("Expected " + path + " to define " + qualified + " but it didn't") } // featureLoaded reports whether path names a file that has already been loaded, diff --git a/internal/vm/builtins.go b/internal/vm/builtins.go index 93336714..171773d0 100644 --- a/internal/vm/builtins.go +++ b/internal/vm/builtins.go @@ -1,6 +1,7 @@ package vm import ( + "fmt" "math" "math/big" "sort" @@ -1706,13 +1707,12 @@ func (vm *VM) bootstrap() { name := vm.coerceConstName(args[0]) // Overwriting an already-initialised constant (a real value, not a pending // autoload — those live in cls.autoloads, so cls.consts misses them and no - // warning fires) warns "already initialized constant X". MRI uses rb_warn - // here, which fires whenever $VERBOSE is non-nil (false or true), suppressed - // only when $VERBOSE is nil. Reference: ruby/ruby v3_4_0 variable.c - // rb_const_set → const_set_raise / rb_warn on the already-set case. - if _, existed := cls.consts[name]; existed && !object.IsNil(vm.globals["$VERBOSE"]) { - vm.warnRedefineConst(cls, name) - } + // warning fires) is variable.c's const_tbl_update redefinition arm, the same + // one a syntactic `X = 2` reaches, so it goes through the same helper: both + // lines, the file:lineno prefix, and rb_warn's gate. This used to open-code a + // third behaviour of its own — a raw vm.globals read for the gate (never + // seeded, so always silent) and Kernel#warn for the sink. + vm.warnAlreadyInitialized(cls, name) // Route through assignConstIn so an anonymous class/module bound here gains // the qualified name of its constant (Ruby's "permanent name on first // constant binding" rule) — the same path a `Foo::Bar = ...` literal takes. @@ -3103,7 +3103,7 @@ func (vm *VM) bootstrap() { // rb_ary_initialize uses rb_warning here, not rb_warn, so this one is // only heard under -w / $VERBOSE = true. if blk != nil { - vm.rbWarning1("given block not used") + vm.rbWarning("given block not used") } return self } @@ -3132,7 +3132,7 @@ func (vm *VM) bootstrap() { // Build the array incrementally so that if the block calls break, the array // is left holding the elements produced before the break, as MRI does. if blk != nil && len(args) == 2 { - vm.rbWarn1("block supersedes default value argument") + vm.rbWarn("block supersedes default value argument") } arr.Elems = make([]object.Value, 0, n) for i := int64(0); i < n; i++ { @@ -3258,7 +3258,7 @@ func (vm *VM) bootstrap() { // if (block_given && argc == 2) rb_warn("block supersedes default value argument"); // so the warning fires whether or not the index is in range. if blk != nil && len(args) == 2 { - vm.rbWarn1("block supersedes default value argument") + vm.rbWarn("block supersedes default value argument") } v, orig, ok := vm.arrayFetchAt(a, args[0]) if ok { @@ -4425,7 +4425,7 @@ func (vm *VM) bootstrap() { // array.c v3_4_0 rb_ary_index: with a value argument the block is dead, // and MRI says so — `if (rb_block_given_p()) rb_warn("given block not used");` if len(args) > 0 && blk != nil { - vm.rbWarn1("given block not used") + vm.rbWarn("given block not used") } for i := 0; i < len(a.Elems); i++ { var match bool @@ -4453,7 +4453,7 @@ func (vm *VM) bootstrap() { } // rb_ary_rindex warns for the dead block exactly as rb_ary_index does. if len(args) > 0 && blk != nil { - vm.rbWarn1("given block not used") + vm.rbWarn("given block not used") } for i := len(a.Elems) - 1; i >= 0; i-- { // A block may shrink the array; realign to the new end and re-check size @@ -5036,7 +5036,7 @@ func (vm *VM) bootstrap() { // hash.c v3_4_0 rb_hash_fetch_m warns on the clash before the lookup: // if (block_given && argc == 2) rb_warn("block supersedes default value argument"); if blk != nil && len(args) == 2 { - vm.rbWarn1("block supersedes default value argument") + vm.rbWarn("block supersedes default value argument") } if v, ok := self.(*object.Hash).Get(args[0]); ok { return v @@ -12215,34 +12215,85 @@ func (vm *VM) qualifiedConstName(scope *RClass, name string) string { return vm.moduleToSStr(scope) + "::" + name } -// rbWarn1 is error.c's rb_warn at tag v3_4_0 (error.c:466): the message gets the -// CALLING frame's "path:lineno: warning: " in front (rb_warn builds it through -// rb_warning_string, which starts at the current frame), it is silenced only -// under -W0 where $VERBOSE is nil (`if (!NIL_P(ruby_verbose))`), and it is then -// handed to rb_write_warning_str. `ruby -e 'p [1].index(1){}'` prints -// "-e:1: warning: given block not used". +// rbWarn is error.c's rb_warn at tag v3_4_0 (error.c:466). Three things happen +// here and NOWHERE else, because a rule restated at its call sites drifts — and +// this one had drifted three ways at once: +// +// 1. the gate is warnEnabled (`!NIL_P(ruby_verbose)`), so the default +// $VERBOSE == false speaks and only -W0's nil silences it; +// 2. the message is composed by warningString, which is error.c's +// warning_string → warn_vsprintf → err_vcatf: the CURRENT Ruby frame's +// "path:lineno: ", then the literal "warning: ", then the text, then "\n". +// Callers pass the text ALONE — no "warning: " of their own; +// 3. the sink is writeWarningStr, error.c's rb_write_warning_str, which is +// `rb_funcallv(Warning, :warn, str)` — so an overridden Warning.warn +// intercepts it and a $stderr that merely answers #write collects it. // -// It emits through writeWarningStr — Warning.warn — and NOT to curStderr(), which -// was the defect: rb_warn reaches $stderr only via the default Warning.warn's -// `$stderr.write(message)`, so an overridden Warning.warn intercepts it and a -// $stderr that merely answers #write collects it. See writeWarningStr in io.go -// for the C chain and for why a StringIO double could witness neither. -func (vm *VM) rbWarn1(msg string) { - if object.IsNil(vm.gvar("$VERBOSE")) { +// `ruby -e 'p [1].index(1){}'` prints "-e:1: warning: given block not used". +func (vm *VM) rbWarn(msg string) { + if !vm.warnEnabled() { + return + } + vm.writeWarningStr(vm.warningString(msg)) +} + +// rbWarnf is rbWarn with a format string. It exists only so a caller building a +// message out of values does not reach for fmt itself; the gate, the prefix and +// the sink are still rbWarn's. +func (vm *VM) rbWarnf(format string, a ...any) { + vm.rbWarn(fmt.Sprintf(format, a...)) +} + +// rbWarning is error.c's rb_warning (error.c:497), the quieter sibling of +// rb_warn: same composition and same sink, but the stricter RTEST gate, so it +// prints only when $VERBOSE is TRUE (ruby -w). This is why the specs that assert +// one of these pass `verbose: true` to `complain`. +func (vm *VM) rbWarning(msg string) { + if !vm.warningEnabled() { return } - vm.writeWarningStr(vm.warnUplevelPrefix(0) + msg + "\n") + vm.writeWarningStr(vm.warningString(msg)) } -// rbWarning1 is error.c's rb_warning (error.c:497), the quieter sibling of -// rb_warn: it prints only when $VERBOSE is TRUE (ruby -w), which is why the specs -// that assert one of these pass `verbose: true` to `complain`. Same sink as -// rbWarn1 — rb_warning also ends in rb_write_warning_str. -func (vm *VM) rbWarning1(msg string) { - if v := vm.gvar("$VERBOSE"); v != object.True { +// rbWarningf is rbWarning with a format string, standing to rbWarning as rbWarnf +// stands to rbWarn. +func (vm *VM) rbWarningf(format string, a ...any) { + vm.rbWarning(fmt.Sprintf(format, a...)) +} + +// rbCompileWarn is error.c's rb_compile_warn (error.c:397): rb_warn's gate and +// rb_warn's sink, but an EXPLICIT source position instead of the current frame's. +// MRI uses it for a diagnostic that points where the interpreter is not standing +// any more — the "previous definition of X was here" line beside a constant +// redefinition, whose position is the entry's own ce->file / ce->line. +func (vm *VM) rbCompileWarn(file string, line int, msg string) { + if !vm.warnEnabled() { return } - vm.writeWarningStr(vm.warnUplevelPrefix(0) + msg + "\n") + vm.writeWarningStr(warningStringAt(file, line, msg)) +} + +// warningString is error.c's warning_string (error.c:450): warn_vsprintf over the +// position rb_source_location_cstr reports for the current frame. +func (vm *VM) warningString(msg string) string { + return vm.warnUplevelPrefix(0) + msg + "\n" +} + +// warningStringAt is warn_vsprintf (error.c:381) with a caller-supplied position, +// formatted by err_vcatf (error.c:125): the file, then ":line" only when the line +// is non-zero, then ": ", then "warning: ". A file of "" drops the whole location +// — err_vcatf tests `if (file)` — leaving the bare "warning: " prefix, which is +// also what a constant defined by this VM's own bootstrap has (MRI: a ce->file of +// nil, so no second line at all — see warnAlreadyInitialized). +func warningStringAt(file string, line int, msg string) string { + if file == "" { + return "warning: " + msg + "\n" + } + loc := file + if line != 0 { + loc += ":" + strconv.Itoa(line) + } + return loc + ": warning: " + msg + "\n" } // symbolNames interns the frozen String that Symbol#name answers. MRI's symbol diff --git a/internal/vm/env.go b/internal/vm/env.go index c4dece94..b9cf86bd 100644 --- a/internal/vm/env.go +++ b/internal/vm/env.go @@ -70,7 +70,7 @@ func (vm *VM) registerENV() { def("fetch", func(vm *VM, _ object.Value, args []object.Value, blk *Proc) object.Value { key := vm.envStr(args[0]) if blk != nil && len(args) > 1 { - vm.rbWarn("warning: block supersedes default value argument") + vm.rbWarn("block supersedes default value argument") } if v, ok := envLookup(key); ok { return envStrV(v) diff --git a/internal/vm/env_wave16_test.go b/internal/vm/env_wave16_test.go index 09739885..7fb5f505 100644 --- a/internal/vm/env_wave16_test.go +++ b/internal/vm/env_wave16_test.go @@ -116,8 +116,14 @@ func TestENVWave16(t *testing.T) { {`ENV.clear; ENV["A"]="1"; p ENV.fetch("A")`, `"1"`}, {`ENV.clear; p ENV.fetch("X","d")`, `"d"`}, // block + default: the block supersedes the default (and MRI warns). - {`ENV.clear; ENV["A"]="1"; p ENV.fetch("A","d"){|k| "blk"}`, `"1"`}, - {`ENV.clear; p ENV.fetch("X","d"){|k| "blk:#{k}"}`, `"blk:X"`}, + // hash.c env_fetch warns through rb_warn when a default AND a block are given, + // so the default $VERBOSE (false) prints it, prefixed with the caller's + // position. Measured on MRI 4.0.5. These two rows asserted silence, which was + // only true while rbgo's rb_warn gate read an unset slot. + {`ENV.clear; ENV["A"]="1"; p ENV.fetch("A","d"){|k| "blk"}`, + "(rbgo):1: warning: block supersedes default value argument\n" + `"1"`}, + {`ENV.clear; p ENV.fetch("X","d"){|k| "blk:#{k}"}`, + "(rbgo):1: warning: block supersedes default value argument\n" + `"blk:X"`}, {`ENV.clear; p ENV.fetch("X"){|k| "blk:#{k}"}`, `"blk:X"`}, {`ENV.clear; begin; ENV.fetch("X"); rescue KeyError => e; p [e.message, e.key, e.receiver.equal?(ENV)]; end`, `["key not found: \"X\"", "X", true]`}, diff --git a/internal/vm/getoptlong_test.go b/internal/vm/getoptlong_test.go index 63720a06..09b9d802 100644 --- a/internal/vm/getoptlong_test.go +++ b/internal/vm/getoptlong_test.go @@ -169,12 +169,15 @@ g = GetoptLong.new(["-a",GetoptLong::NO_ARGUMENT]) ARGV.replace(["-a","z"]) r=[]; g.each{|o,a| r<<[o,a]}; p r; p ARGV`, "[[\"-a\", \"\"]]\n[\"z\"]\n"}, - // A non-Array ARGV (reassigned) is treated as empty: nothing to scan. + // A non-Array ARGV (reassigned) is treated as empty: nothing to scan. The + // reassignment warns: ARGV is already initialised, and MRI warns there too + // (`ruby -e 'ARGV = "x"'` prints "-e:1: warning: already initialized constant + // ARGV"), with no "previous definition" line because ARGV is defined natively. {golReq + ` ARGV = "notarray" g = GetoptLong.new(["-a",GetoptLong::NO_ARGUMENT]) p g.get`, - "[nil, nil]\n"}, + "(rbgo):2: warning: already initialized constant ARGV\n[nil, nil]\n"}, } for _, c := range cases { if got := eval(t, c.src); got != c.want { diff --git a/internal/vm/globals.go b/internal/vm/globals.go index 69875a13..edd3ec3d 100644 --- a/internal/vm/globals.go +++ b/internal/vm/globals.go @@ -202,12 +202,41 @@ func (vm *VM) verboseSlot(name string) object.Value { return object.Bool(false) } +// $VERBOSE has THREE states in MRI, not two, and the two warning families split +// on exactly that (error.c v3_4_0): +// +// nil (-W0) every rb_warn and rb_warning is silent +// false (the default) rb_warn speaks, rb_warning stays quiet +// true (-w / -W2) both speak +// +// verbose_setter (ruby.c v3_4_0) coerces anything truthy to Qtrue, so these are +// the only three values a slot can hold, and `$VERBOSE = 1` reads back as true. +// +// warnEnabled and warningEnabled are the ONLY two places that decide. Every gate +// in this VM asks one of them, because the defect they replace was a second +// representation of one value: four call sites read vm.globals["$VERBOSE"] +// straight out of the map, which is unset until a program assigns it, while every +// Ruby-level read went through verboseSlot and answered false. The gate read the +// representation nobody writes, so `$VERBOSE.nil?` agreed on both engines and no +// Ruby-level probe could see it. Reading the slot through verboseSlot here +// removes the second representation rather than seeding it, so a future `delete` +// or a fresh VM cannot re-open the same hole. +func (vm *VM) warnEnabled() bool { + return !object.IsNil(vm.verboseSlot("$VERBOSE")) +} + +// warningEnabled is rb_warning's stricter gate, `RTEST(ruby_verbose)`: only a +// TRUE $VERBOSE. It is what ruby/spec's `complain(verbose: true)` arranges. +func (vm *VM) warningEnabled() bool { + return truthyValue(vm.verboseSlot("$VERBOSE")) +} + // warnDeprecatedGvar emits a special-variable deprecation warning through // Warning.warn, but only while Warning[:deprecated] is enabled — error.c v3_4_0 // deprecation_warning_enabled() requires both a non-nil $VERBOSE and the // category, and the category is off by default, so an ordinary run is silent. func (vm *VM) warnDeprecatedGvar(msg string) { - if object.IsNil(vm.verboseSlot("$VERBOSE")) { + if !vm.warnEnabled() { return } w := vm.consts["Warning"] diff --git a/internal/vm/io.go b/internal/vm/io.go index ede1c99d..8354c379 100644 --- a/internal/vm/io.go +++ b/internal/vm/io.go @@ -511,7 +511,7 @@ func (vm *VM) registerIO() { // `if (!NIL_P(ruby_verbose) && argc > 0)`, so a $VERBOSE of nil (the -W0 // level) makes Kernel#warn a no-op — nothing is written, nothing is // validated and Warning.warn is not called. $VERBOSE false still warns. - if object.IsNil(vm.verboseSlot("$VERBOSE")) || len(pos) == 0 { + if !vm.warnEnabled() || len(pos) == 0 { return object.NilV } lev := int64(0) @@ -608,7 +608,7 @@ func (vm *VM) registerIO() { // rb_io_s_new warns when handed a block it will not call: File.new always // returns the open stream, and only File.open yields it. if blk != nil { - vm.rbWarn("warning: File::new() does not take block; use File::open() instead") + vm.rbWarn("File::new() does not take block; use File::open() instead") } return vm.openFileArgs(fileRecvClass(self, cFile), args) }} @@ -1413,7 +1413,7 @@ func (vm *VM) writeArityIsOne(sink object.Value) bool { // whatever that #to_s returns. Measured — the first version of this function used // #to_s and printed the overridden value. func (vm *VM) warnOutdatedWrite(sink object.Value) { - if sink == vm.stderrValue() || vm.gvar("$VERBOSE") != object.True { + if sink == vm.stderrValue() || !vm.warningEnabled() { return } if !vm.send(vm.consts["Warning"], "[]", []object.Value{object.SymVal("deprecated")}, nil).Truthy() { diff --git a/internal/vm/io_class.go b/internal/vm/io_class.go index 018c0b1a..af083cf9 100644 --- a/internal/vm/io_class.go +++ b/internal/vm/io_class.go @@ -5,7 +5,6 @@ package vm import ( - "fmt" "os" "strings" @@ -1071,7 +1070,7 @@ func (vm *VM) extractEncodingOption(opts *object.Hash, ms *ioModeSpec) bool { if !hasExt { which = "internal" } - vm.rbWarn("Ignoring encoding parameter '%s': %s_encoding is used", vm.displayStr(encV), which) + vm.rbWarnf("Ignoring encoding parameter '%s': %s_encoding is used", vm.displayStr(encV), which) hasEnc = false } extName := "" @@ -1125,24 +1124,6 @@ func isDashString(v object.Value) bool { return ok && s.Str() == "-" } -// rbWarn emits an MRI rb_warn-style warning line, but only when $VERBOSE is -// non-nil (false or true) — the gate rb_warn applies. Used for the encoding -// options that IO.new silently overrides. -// -// It goes through writeWarningStr (error.c rb_write_warning_str → Warning.warn), -// like every other rb_warn here. It used to write to curStderr() instead, and the -// comment that justified it — "still honouring a $stderr reassigned to a StringIO -// (mspec's `complain` matcher)" — names the reason the defect survived: a StringIO -// IS an *IOObj in rbgo, so it satisfied the type assertion curStderr() makes and -// the harness's own double could never show the warning being dropped for a -// $stderr that merely answers #write. -func (vm *VM) rbWarn(format string, a ...any) { - if object.IsNil(vm.globals["$VERBOSE"]) { - return - } - vm.writeWarningStr(fmt.Sprintf(format, a...) + "\n") -} - // ioOptEncoding returns the canonical encoding name selected by the :encoding / // :external_encoding option, or "" when none is given. func (vm *VM) ioOptEncoding(opts *object.Hash) string { diff --git a/internal/vm/io_modeenc_internal_test.go b/internal/vm/io_modeenc_internal_test.go index 2482c6aa..8917bbaa 100644 --- a/internal/vm/io_modeenc_internal_test.go +++ b/internal/vm/io_modeenc_internal_test.go @@ -133,8 +133,12 @@ func TestIOBinmodeTextmodeAutoclose(t *testing.T) { // TestIOEncodingOptions covers extractEncodingOption / isDashString / rbWarn: the // :external_encoding / :internal_encoding / :encoding options, the nil and "-" // internal-encoding forms, the int==ext collapse, and the "Ignoring encoding -// parameter" override (whose external/internal wording is exercised both with -// $VERBOSE set, so the warning fires, and unset, so rbWarn early-returns). +// parameter" override. io.c ruby_4_0:6852 warns through rb_warn, so the DEFAULT +// $VERBOSE (false) prints it with the caller's position — measured on MRI 4.0.5: +// `ruby -e 'IO.new(1, "w", external_encoding: "ibm866", encoding: "utf-8")'` +// prints "-e:1: warning: Ignoring encoding parameter …". The unset row below used +// to assert silence and the $VERBOSE = true rows a bare "Ignoring …"; both were +// rbgo's divergence. func TestIOEncodingOptions(t *testing.T) { cases := []struct{ body, want string }{ {`io = IO.new(wo, "w", external_encoding: "utf-8", internal_encoding: "ibm866"); p [io.external_encoding.to_s, io.internal_encoding.to_s]`, "[\"UTF-8\", \"IBM866\"]\n"}, @@ -146,10 +150,10 @@ func TestIOEncodingOptions(t *testing.T) { {`io = IO.new(wo, "w", external_encoding: "utf-8", internal_encoding: "utf-8"); p io.internal_encoding.to_s`, "\"\"\n"}, {`io = IO.new(wo, "w", encoding: "utf-8:utf-8"); p io.internal_encoding.to_s`, "\"\"\n"}, // :encoding is ignored when :external_encoding is present (external wording). - {`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "\"IBM866\"\n"}, - {`$VERBOSE = true; io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"}, + {`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"}, + {`$VERBOSE = true; io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p io.external_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n\"IBM866\"\n"}, // :encoding is ignored when :internal_encoding is present (internal wording). - {`$VERBOSE = true; io = IO.new(wo, "w", internal_encoding: "ibm866", encoding: "utf-8"); p io.internal_encoding.to_s`, "Ignoring encoding parameter 'utf-8': internal_encoding is used\n\"IBM866\"\n"}, + {`$VERBOSE = true; io = IO.new(wo, "w", internal_encoding: "ibm866", encoding: "utf-8"); p io.internal_encoding.to_s`, "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': internal_encoding is used\n\"IBM866\"\n"}, } for _, c := range cases { if got := eval(t, ioFdProg(c.body)); got != c.want { @@ -221,16 +225,21 @@ func TestIOOpenBlock(t *testing.T) { } } -// TestIORbWarnSilentByDefault confirms rbWarn's $VERBOSE gate: with no warning -// level set the ignored-encoding override is silent, yet still resolves the -// external encoding to the winning option. $VERBOSE itself READS false, not nil -// — ruby.c v3_4_0 ruby_prog_init binds it to ruby_verbose, which the interpreter -// starts at Qfalse and only -W0 moves to nil (`ruby -e "p $VERBOSE"` prints -// false on 4.0.5). rbgo's rb_warn gate still keys on the raw, unset slot, which -// is why nothing is printed here. -func TestIORbWarnSilentByDefault(t *testing.T) { +// TestIORbWarnSpeaksAtTheDefaultLevel is the same probe this file used to run +// under the name TestIORbWarnSilentByDefault, inverted, because the behaviour it +// asserted was rbgo's defect and its own comment said so: "rbgo's rb_warn gate +// still keys on the raw, unset slot, which is why nothing is printed here". +// +// $VERBOSE READS false, not nil — ruby.c ruby_prog_init binds it to ruby_verbose, +// which starts at Qfalse and only -W0 moves to nil — and error.c rb_warn fires on +// anything non-nil. So MRI prints the override warning with no -w at all, and the +// interesting property is that $VERBOSE still reads false while it does: the value +// a program can SEE has one representation now, and the gate reads that one. +func TestIORbWarnSpeaksAtTheDefaultLevel(t *testing.T) { got := eval(t, ioFdProg(`io = IO.new(wo, "w", external_encoding: "ibm866", encoding: "utf-8"); p [$VERBOSE, io.external_encoding.to_s]`)) - if want := fmt.Sprintf("[false, %q]\n", "IBM866"); got != want { - t.Errorf("silent warn: got %q want %q", got, want) + want := "(rbgo):7: warning: Ignoring encoding parameter 'utf-8': external_encoding is used\n" + + fmt.Sprintf("[false, %q]\n", "IBM866") + if got != want { + t.Errorf("default-level warn: got %q want %q", got, want) } } diff --git a/internal/vm/modulefunc.go b/internal/vm/modulefunc.go index 2087b8a0..f146e68d 100644 --- a/internal/vm/modulefunc.go +++ b/internal/vm/modulefunc.go @@ -191,7 +191,7 @@ func (vm *VM) registerModuleExtras() { vm.raiseFrozen(mod) } skip := func(name, why string) { - vm.rbWarn("warning: Skipping set of ruby2_keywords flag for %s (%s)", name, why) + vm.rbWarnf("Skipping set of ruby2_keywords flag for %s (%s)", name, why) } for _, a := range args { name := vm.coerceNameArg(a) diff --git a/internal/vm/phase5f_test.go b/internal/vm/phase5f_test.go index bc52e593..9ef093ce 100644 --- a/internal/vm/phase5f_test.go +++ b/internal/vm/phase5f_test.go @@ -10,7 +10,11 @@ func TestConstantAssignment(t *testing.T) { {"int", "X = 5\np X", "5\n"}, {"float", "PI = 3.14\np PI", "3.14\n"}, {"expr", "X = 5\nY = X + 1\np Y", "6\n"}, - {"reassign", "X = 1\nX = 2\np X", "2\n"}, + // The reassignment warns, as it does in MRI (variable.c const_tbl_update). + // One line, not two: eval() compiles a path-less ISeq, so no location is + // recorded for X and MRI's ce->file guard suppresses "previous definition". + {"reassign", "X = 1\nX = 2\np X", + "(rbgo):2: warning: already initialized constant X\n2\n"}, {"string", "NAME = \"ruby\"\np NAME", "\"ruby\"\n"}, } for _, tc := range tests { diff --git a/internal/vm/prelude.rb b/internal/vm/prelude.rb index dc5ec238..af0c4bbc 100644 --- a/internal/vm/prelude.rb +++ b/internal/vm/prelude.rb @@ -201,6 +201,11 @@ def count(*args) raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0..1)" if args.length > 1 n = 0 if !args.empty? + # enum.c v3_4_0 enum_count: an item argument makes the block dead, and MRI + # says so through rb_warn. `warn ..., uplevel: 1` IS rb_warn here -- same + # gate (Kernel#warn is `!NIL_P(ruby_verbose)`), same sink (Warning.warn) and + # the caller's "path:lineno: warning: " rather than this prelude's. + warn "given block not used", uplevel: 1 if block_given? item = args[0] each { |*a| n = n + 1 if __pack(a) == item } elsif block_given? @@ -350,6 +355,11 @@ def reduce(*args) has_init = false init = nil if args.length == 2 + # enum.c v3_4_0 enum_inject, the two-argument arm: the block is dead and MRI + # warns -- but through rb_warning, not rb_warn, so ONLY a true $VERBOSE + # prints it. The explicit `$VERBOSE` test is what turns Kernel#warn's + # non-nil gate into rb_warning's RTEST one. + warn "given block not used", uplevel: 1 if block_given? && $VERBOSE init = args[0] sym = args[1] has_init = true @@ -393,6 +403,9 @@ def reduce(*args) # records whether a pattern was actually passed. def any?(pattern = (no_pat = true; nil)) blk = block_given? + # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block + # dead. rb_warn, so the default $VERBOSE == false still prints it. + warn "given block not used", uplevel: 1 if blk && !no_pat catch(:__enum_any) do each { |*a| truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a)) @@ -404,6 +417,9 @@ def any?(pattern = (no_pat = true; nil)) def all?(pattern = (no_pat = true; nil)) blk = block_given? + # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block + # dead. rb_warn, so the default $VERBOSE == false still prints it. + warn "given block not used", uplevel: 1 if blk && !no_pat catch(:__enum_all) do each { |*a| truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a)) @@ -415,6 +431,9 @@ def all?(pattern = (no_pat = true; nil)) def none?(pattern = (no_pat = true; nil)) blk = block_given? + # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc): a pattern argument makes the block + # dead. rb_warn, so the default $VERBOSE == false still prints it. + warn "given block not used", uplevel: 1 if blk && !no_pat catch(:__enum_none) do each { |*a| truth = no_pat ? (blk ? yield(*a) : __pack(a)) : (pattern === __pack(a)) @@ -430,6 +449,8 @@ def none?(pattern = (no_pat = true; nil)) # matches against the packed value. def one?(pattern = (no_pat = true; nil)) blk = block_given? + # enum.c v3_4_0 WARN_UNUSED_BLOCK(argc), as in any?/all?/none? above. + warn "given block not used", uplevel: 1 if blk && !no_pat n = 0 catch(:__enum_one) do each { |*a| @@ -641,6 +662,8 @@ def zip(*others) 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) { nil } if args.empty? && !block_given? + # enum.c v3_4_0 enum_find_index: a value argument makes the block dead. + warn "given block not used", uplevel: 1 if !args.empty? && block_given? idx = nil i = 0 each { |*a| @@ -2258,7 +2281,12 @@ def render(_scope = Object.new, locals = {}) end end - Engine = Template + # Slim::Engine is NOT assigned here: slim.go's registerSlim already binds it to + # this same Template class, and re-assigning a constant that is already + # initialised is exactly what MRI's const_tbl_update warns about. It stayed + # invisible while rb_warn was gated on an unset $VERBOSE slot; with the gate + # fixed it printed "already initialized constant Slim::Engine" on EVERY run, + # a warning MRI never emits. end # --------------------------------------------------------------------------- @@ -2344,7 +2372,8 @@ def render(_scope = Object.new, locals = {}) end end - Engine = Template + # Haml::Engine: as with Slim above, haml.go's registerHaml already binds it to + # this Template class, so assigning it here only warned. end # --------------------------------------------------------------------------- @@ -2414,7 +2443,8 @@ def self.reason; "needless argument"; end :conv, :desc, :block) end -OptParse = OptionParser +# OptParse: optparse.go's registerOptionParser already binds both OptParse and +# OptionParser::OptParse to this class, so assigning it here only warned. # --------------------------------------------------------------------------- # Tempfile (tempfile): a from-scratch pure-Ruby temporary file built over File diff --git a/internal/vm/prelude_frozen_gen.go b/internal/vm/prelude_frozen_gen.go index 871ae45a..5ddd5c02 100644 --- a/internal/vm/prelude_frozen_gen.go +++ b/internal/vm/prelude_frozen_gen.go @@ -11,15 +11,15 @@ import ( func embeddedPrelude() *bytecode.ISeq { return &bytecode.ISeq{ Name: "
", - Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 42, A: 3, B: 3}, {Op: 9}, {Op: 42, A: 4, B: 4}, {Op: 9}, {Op: 42, A: 5, B: 5}, {Op: 9}, {Op: 42, A: 6, B: 6}, {Op: 9}, {Op: 42, A: 7, B: 7}, {Op: 9}, {Op: 42, A: 8, B: 8}, {Op: 9}, {Op: 42, A: 9, B: 9}, {Op: 9}, {Op: 42, A: 10, B: 10}, {Op: 9}, {Op: 43, A: 11, B: 11}, {Op: 9}, {Op: 42, A: 12, B: 12}, {Op: 9}, {Op: 43, A: 13, B: 13}, {Op: 9}, {Op: 43, A: 14, B: 14}, {Op: 9}, {Op: 42, A: 15, B: 15}, {Op: 9}, {Op: 42, A: 16, B: 16}, {Op: 9}, {Op: 44, A: 17, B: 17}, {Op: 9}, {Op: 42, A: 18, B: 18}, {Op: 9}, {Op: 43, A: 19, B: 19}, {Op: 9}, {Op: 42, A: 20, B: 20}, {Op: 9}, {Op: 43, A: 21, B: 21}, {Op: 9}, {Op: 43, A: 22, B: 22}, {Op: 9}, {Op: 42, A: 23, B: 23}, {Op: 9}, {Op: 33, A: 23}, {Op: 41, A: 24}, {Op: 9}, {Op: 42, A: 25, B: 24}, {Op: 9}, {Op: 43, A: 26, B: 25}, {Op: 9}, {Op: 43, A: 27, B: 26}, {Op: 53}}, - Names: []string{"Comparable", "Enumerable", "Numeric", "Integer", "Float", "String", "Symbol", "Array", "Range", "Hash", "Set", "Gem", "OpenStruct", "Forwardable", "SingleForwardable", "Delegator", "SimpleDelegator", "DelegateClass", "Pathname", "Singleton", "ERB", "Slim", "Haml", "OptionParser", "OptParse", "Tempfile", "Warning", "Kernel"}, + Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 42, A: 3, B: 3}, {Op: 9}, {Op: 42, A: 4, B: 4}, {Op: 9}, {Op: 42, A: 5, B: 5}, {Op: 9}, {Op: 42, A: 6, B: 6}, {Op: 9}, {Op: 42, A: 7, B: 7}, {Op: 9}, {Op: 42, A: 8, B: 8}, {Op: 9}, {Op: 42, A: 9, B: 9}, {Op: 9}, {Op: 42, A: 10, B: 10}, {Op: 9}, {Op: 43, A: 11, B: 11}, {Op: 9}, {Op: 42, A: 12, B: 12}, {Op: 9}, {Op: 43, A: 13, B: 13}, {Op: 9}, {Op: 43, A: 14, B: 14}, {Op: 9}, {Op: 42, A: 15, B: 15}, {Op: 9}, {Op: 42, A: 16, B: 16}, {Op: 9}, {Op: 44, A: 17, B: 17}, {Op: 9}, {Op: 42, A: 18, B: 18}, {Op: 9}, {Op: 43, A: 19, B: 19}, {Op: 9}, {Op: 42, A: 20, B: 20}, {Op: 9}, {Op: 43, A: 21, B: 21}, {Op: 9}, {Op: 43, A: 22, B: 22}, {Op: 9}, {Op: 42, A: 23, B: 23}, {Op: 9}, {Op: 42, A: 24, B: 24}, {Op: 9}, {Op: 43, A: 25, B: 25}, {Op: 9}, {Op: 43, A: 26, B: 26}, {Op: 53}}, + Names: []string{"Comparable", "Enumerable", "Numeric", "Integer", "Float", "String", "Symbol", "Array", "Range", "Hash", "Set", "Gem", "OpenStruct", "Forwardable", "SingleForwardable", "Delegator", "SimpleDelegator", "DelegateClass", "Pathname", "Singleton", "ERB", "Slim", "Haml", "OptionParser", "Tempfile", "Warning", "Kernel"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 10}, {PC: 2, Line: 116}, {PC: 4, Line: 975}, {PC: 6, Line: 990}, {PC: 8, Line: 1001}, {PC: 10, Line: 1014}, {PC: 12, Line: 1018}, {PC: 14, Line: 1027}, {PC: 16, Line: 1036}, {PC: 18, Line: 1069}, {PC: 20, Line: 1084}, {PC: 22, Line: 1456}, {PC: 24, Line: 1676}, {PC: 26, Line: 1755}, {PC: 28, Line: 1786}, {PC: 30, Line: 1806}, {PC: 32, Line: 1846}, {PC: 34, Line: 1859}, {PC: 36, Line: 1899}, {PC: 38, Line: 2070}, {PC: 40, Line: 2106}, {PC: 42, Line: 2170}, {PC: 44, Line: 2273}, {PC: 46, Line: 2372}, {PC: 48, Line: 2417}, {PC: 51, Line: 2427}, {PC: 53, Line: 2552}, {PC: 55, Line: 2610}}, + 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: 1059}, {PC: 18, Line: 1092}, {PC: 20, Line: 1107}, {PC: 22, Line: 1479}, {PC: 24, Line: 1699}, {PC: 26, Line: 1778}, {PC: 28, Line: 1809}, {PC: 30, Line: 1829}, {PC: 32, Line: 1869}, {PC: 34, Line: 1882}, {PC: 36, Line: 1922}, {PC: 38, Line: 2093}, {PC: 40, Line: 2129}, {PC: 42, Line: 2193}, {PC: 44, Line: 2301}, {PC: 46, Line: 2401}, {PC: 48, Line: 2457}, {PC: 50, Line: 2582}, {PC: 52, Line: 2640}}, FirstLine: 1, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -56,7 +56,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"other", "cmp", "", "right"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 254}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 49, Line: 109}, {PC: 56, Line: 25}, {PC: 66, Line: 27}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 18}, {PC: 8, Line: 19}, {PC: 23, Line: 259}, {PC: 36, Line: 21}, {PC: 39, Line: 23}, {PC: 43, Line: 25}, {PC: 49, Line: 109}, {PC: 56, Line: 25}, {PC: 66, Line: 27}}, FirstLine: 16, Super: "", }, @@ -225,7 +225,7 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 169}, {PC: 18, Line: 176}, {PC: 20, Line: 188}, {PC: 22, Line: 198}, {PC: 24, Line: 200}, {PC: 26, Line: 216}, {PC: 28, Line: 221}, {PC: 30, Line: 226}, {PC: 32, Line: 230}, {PC: 34, Line: 235}, {PC: 36, Line: 241}, {PC: 38, Line: 243}, {PC: 40, Line: 253}, {PC: 42, Line: 268}, {PC: 44, Line: 270}, {PC: 46, Line: 275}, {PC: 48, Line: 280}, {PC: 50, Line: 305}, {PC: 52, Line: 322}, {PC: 54, Line: 339}, {PC: 56, Line: 343}, {PC: 58, Line: 388}, {PC: 60, Line: 394}, {PC: 62, Line: 405}, {PC: 64, Line: 416}, {PC: 66, Line: 431}, {PC: 68, Line: 450}, {PC: 70, Line: 477}, {PC: 72, Line: 483}, {PC: 74, Line: 497}, {PC: 76, Line: 503}, {PC: 78, Line: 519}, {PC: 80, Line: 526}, {PC: 82, Line: 532}, {PC: 84, Line: 538}, {PC: 86, Line: 548}, {PC: 88, Line: 562}, {PC: 90, Line: 576}, {PC: 92, Line: 612}, {PC: 94, Line: 641}, {PC: 96, Line: 653}, {PC: 98, Line: 657}, {PC: 100, Line: 663}, {PC: 102, Line: 669}, {PC: 104, Line: 684}, {PC: 106, Line: 701}, {PC: 108, Line: 721}, {PC: 110, Line: 745}, {PC: 112, Line: 767}, {PC: 114, Line: 781}, {PC: 116, Line: 798}, {PC: 118, Line: 818}, {PC: 120, Line: 844}, {PC: 122, Line: 877}, {PC: 124, Line: 900}, {PC: 126, Line: 923}, {PC: 128, Line: 930}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 122}, {PC: 2, Line: 131}, {PC: 4, Line: 139}, {PC: 6, Line: 155}, {PC: 12, Line: 159}, {PC: 14, Line: 164}, {PC: 16, Line: 169}, {PC: 18, Line: 176}, {PC: 20, Line: 188}, {PC: 22, Line: 198}, {PC: 24, Line: 200}, {PC: 26, Line: 221}, {PC: 28, Line: 226}, {PC: 30, Line: 231}, {PC: 32, Line: 235}, {PC: 34, Line: 240}, {PC: 36, Line: 246}, {PC: 38, Line: 248}, {PC: 40, Line: 258}, {PC: 42, Line: 273}, {PC: 44, Line: 275}, {PC: 46, Line: 280}, {PC: 48, Line: 285}, {PC: 50, Line: 310}, {PC: 52, Line: 327}, {PC: 54, Line: 344}, {PC: 56, Line: 348}, {PC: 58, Line: 398}, {PC: 60, Line: 404}, {PC: 62, Line: 418}, {PC: 64, Line: 432}, {PC: 66, Line: 450}, {PC: 68, Line: 471}, {PC: 70, Line: 498}, {PC: 72, Line: 504}, {PC: 74, Line: 518}, {PC: 76, Line: 524}, {PC: 78, Line: 540}, {PC: 80, Line: 547}, {PC: 82, Line: 553}, {PC: 84, Line: 559}, {PC: 86, Line: 569}, {PC: 88, Line: 583}, {PC: 90, Line: 597}, {PC: 92, Line: 633}, {PC: 94, Line: 662}, {PC: 96, Line: 676}, {PC: 98, Line: 680}, {PC: 100, Line: 686}, {PC: 102, Line: 692}, {PC: 104, Line: 707}, {PC: 106, Line: 724}, {PC: 108, Line: 744}, {PC: 110, Line: 768}, {PC: 112, Line: 790}, {PC: 114, Line: 804}, {PC: 116, Line: 821}, {PC: 118, Line: 841}, {PC: 120, Line: 867}, {PC: 122, Line: 900}, {PC: 124, Line: 923}, {PC: 126, Line: 946}, {PC: 128, Line: 953}}, FirstLine: 116, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -276,7 +276,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 254}, {PC: 5, Line: 132}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 132}, {PC: 3, Line: 259}, {PC: 5, Line: 132}}, FirstLine: 131, Super: "", }, @@ -460,15 +460,17 @@ func embeddedPrelude() *bytecode.ISeq { }, &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, Flags: 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: 3}, {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}}, + 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, Flags: 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: 48}, {Op: 52}, {Op: 28, A: 38}, {Op: 5}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1}, {Op: 7, A: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 39}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 4}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7, C: 1}, {Op: 26, A: 55}, {Op: 52}, {Op: 28, A: 53}, {Op: 5}, {Op: 30, A: 7, C: 2}, {Op: 26, A: 55}, {Op: 5}, {Op: 30, A: 7, C: 3}, {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.NewString("given block not used"), + object.Symbol("uplevel"), }, - Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "[]", "each"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "warn", "[]", "each"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -477,7 +479,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "n", "item"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 201}, {PC: 22, Line: 202}, {PC: 25, Line: 203}, {PC: 29, Line: 204}, {PC: 34, Line: 205}, {PC: 39, Line: 207}, {PC: 42, Line: 209}, {PC: 45, Line: 211}}, + Lines: []bytecode.LineEntry{{PC: 0, Line: 201}, {PC: 22, Line: 202}, {PC: 25, Line: 203}, {PC: 29, Line: 208}, {PC: 40, Line: 209}, {PC: 45, Line: 210}, {PC: 50, Line: 212}, {PC: 53, Line: 214}, {PC: 56, Line: 216}}, FirstLine: 200, Children: []*bytecode.ISeq{ &bytecode.ISeq{ @@ -495,8 +497,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 205}}, - FirstLine: 205, + Lines: []bytecode.LineEntry{{PC: 0, Line: 210}}, + FirstLine: 210, Super: "", }, &bytecode.ISeq{ @@ -513,8 +515,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 207}}, - FirstLine: 207, + Lines: []bytecode.LineEntry{{PC: 0, Line: 212}}, + FirstLine: 212, Super: "", }, &bytecode.ISeq{ @@ -531,8 +533,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 209}}, - FirstLine: 209, + Lines: []bytecode.LineEntry{{PC: 0, Line: 214}}, + FirstLine: 214, Super: "", }, }, @@ -553,8 +555,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 217}, {PC: 16, Line: 218}}, - FirstLine: 216, + Lines: []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 16, Line: 223}}, + FirstLine: 221, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in min_by", @@ -569,8 +571,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 217}}, - FirstLine: 217, + Lines: []bytecode.LineEntry{{PC: 0, Line: 222}}, + FirstLine: 222, Super: "", }, &bytecode.ISeq{ @@ -584,8 +586,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 218}}, - FirstLine: 218, + Lines: []bytecode.LineEntry{{PC: 0, Line: 223}}, + FirstLine: 223, Super: "", }, }, @@ -606,8 +608,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 222}, {PC: 16, Line: 223}}, - FirstLine: 221, + Lines: []bytecode.LineEntry{{PC: 0, Line: 227}, {PC: 16, Line: 228}}, + FirstLine: 226, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in max_by", @@ -622,8 +624,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 222}}, - FirstLine: 222, + Lines: []bytecode.LineEntry{{PC: 0, Line: 227}}, + FirstLine: 227, Super: "", }, &bytecode.ISeq{ @@ -637,8 +639,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 223}}, - FirstLine: 223, + Lines: []bytecode.LineEntry{{PC: 0, Line: 228}}, + FirstLine: 228, Super: "", }, }, @@ -655,8 +657,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 227}}, - FirstLine: 226, + Lines: []bytecode.LineEntry{{PC: 0, Line: 232}}, + FirstLine: 231, Super: "", }, &bytecode.ISeq{ @@ -672,8 +674,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 231}, {PC: 10, Line: 232}}, - FirstLine: 230, + Lines: []bytecode.LineEntry{{PC: 0, Line: 236}, {PC: 10, Line: 237}}, + FirstLine: 235, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in sort_by", @@ -688,8 +690,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 231}}, - FirstLine: 231, + Lines: []bytecode.LineEntry{{PC: 0, Line: 236}}, + FirstLine: 236, Super: "", }, &bytecode.ISeq{ @@ -703,8 +705,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 232}}, - FirstLine: 232, + Lines: []bytecode.LineEntry{{PC: 0, Line: 237}}, + FirstLine: 237, Super: "", }, }, @@ -724,8 +726,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 236}, {PC: 10, Line: 237}, {PC: 13, Line: 238}, {PC: 16, Line: 239}}, - FirstLine: 235, + Lines: []bytecode.LineEntry{{PC: 0, Line: 241}, {PC: 10, Line: 242}, {PC: 13, Line: 243}, {PC: 16, Line: 244}}, + FirstLine: 240, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select", @@ -740,8 +742,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 236}}, - FirstLine: 236, + Lines: []bytecode.LineEntry{{PC: 0, Line: 241}}, + FirstLine: 241, Super: "", }, &bytecode.ISeq{ @@ -756,8 +758,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 238}}, - FirstLine: 238, + Lines: []bytecode.LineEntry{{PC: 0, Line: 243}}, + FirstLine: 243, Super: "", }, }, @@ -777,8 +779,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 244}, {PC: 10, Line: 245}, {PC: 13, Line: 246}, {PC: 16, Line: 247}}, - FirstLine: 243, + Lines: []bytecode.LineEntry{{PC: 0, Line: 249}, {PC: 10, Line: 250}, {PC: 13, Line: 251}, {PC: 16, Line: 252}}, + FirstLine: 248, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject", @@ -793,8 +795,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 244}}, - FirstLine: 244, + Lines: []bytecode.LineEntry{{PC: 0, Line: 249}}, + FirstLine: 249, Super: "", }, &bytecode.ISeq{ @@ -809,8 +811,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 246}}, - FirstLine: 246, + Lines: []bytecode.LineEntry{{PC: 0, Line: 251}}, + FirstLine: 251, Super: "", }, }, @@ -831,8 +833,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"ifnone", "found", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 253}, {PC: 2, Line: 254}, {PC: 16, Line: 255}, {PC: 19, Line: 254}, {PC: 22, Line: 257}, {PC: 25, Line: 265}, {PC: 32, Line: 266}, {PC: 35, Line: 254}}, - FirstLine: 253, + Lines: []bytecode.LineEntry{{PC: 0, Line: 258}, {PC: 2, Line: 259}, {PC: 16, Line: 260}, {PC: 19, Line: 259}, {PC: 22, Line: 262}, {PC: 25, Line: 270}, {PC: 32, Line: 271}, {PC: 35, Line: 259}}, + FirstLine: 258, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in find", @@ -843,8 +845,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 254, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 259, Super: "", }, &bytecode.ISeq{ @@ -858,8 +860,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 258}, {PC: 3, Line: 259}, {PC: 6, Line: 260}, {PC: 9, Line: 261}}, - FirstLine: 257, + Lines: []bytecode.LineEntry{{PC: 0, Line: 263}, {PC: 3, Line: 264}, {PC: 6, Line: 265}, {PC: 9, Line: 266}}, + FirstLine: 262, Super: "", }, }, @@ -877,8 +879,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"value", "found"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 271}, {PC: 3, Line: 272}, {PC: 6, Line: 273}}, - FirstLine: 270, + Lines: []bytecode.LineEntry{{PC: 0, Line: 276}, {PC: 3, Line: 277}, {PC: 6, Line: 278}}, + FirstLine: 275, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in include?", @@ -891,8 +893,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 272}}, - FirstLine: 272, + Lines: []bytecode.LineEntry{{PC: 0, Line: 277}}, + FirstLine: 277, Super: "", }, }, @@ -914,8 +916,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"init", "total", "compensation", "float_mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 280}, {PC: 5, Line: 281}, {PC: 8, Line: 282}, {PC: 11, Line: 283}, {PC: 16, Line: 284}, {PC: 19, Line: 298}}, - FirstLine: 280, + Lines: []bytecode.LineEntry{{PC: 0, Line: 285}, {PC: 5, Line: 286}, {PC: 8, Line: 287}, {PC: 11, Line: 288}, {PC: 16, Line: 289}, {PC: 19, Line: 303}}, + FirstLine: 285, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in sum", @@ -929,8 +931,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"x", "v", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 285}, {PC: 8, Line: 286}, {PC: 17, Line: 287}, {PC: 21, Line: 288}, {PC: 26, Line: 290}, {PC: 34, Line: 291}, {PC: 39, Line: 292}, {PC: 60, Line: 293}, {PC: 63, Line: 295}}, - FirstLine: 284, + Lines: []bytecode.LineEntry{{PC: 0, Line: 290}, {PC: 8, Line: 291}, {PC: 17, Line: 292}, {PC: 21, Line: 293}, {PC: 26, Line: 295}, {PC: 34, Line: 296}, {PC: 39, Line: 297}, {PC: 60, Line: 298}, {PC: 63, Line: 300}}, + FirstLine: 289, Super: "", }, }, @@ -948,8 +950,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 4, Locals: []string{"n", "block", "result", "first"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 305}, {PC: 2, Line: 254}, {PC: 5, Line: 306}, {PC: 19, Line: 254}, {PC: 22, Line: 308}, {PC: 25, Line: 309}, {PC: 28, Line: 319}}, - FirstLine: 305, + Lines: []bytecode.LineEntry{{PC: 0, Line: 310}, {PC: 2, Line: 259}, {PC: 5, Line: 311}, {PC: 19, Line: 259}, {PC: 22, Line: 313}, {PC: 25, Line: 314}, {PC: 28, Line: 324}}, + FirstLine: 310, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in min", @@ -970,8 +972,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "c"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 310}, {PC: 2, Line: 311}, {PC: 5, Line: 312}, {PC: 8, Line: 314}, {PC: 20, Line: 315}, {PC: 47, Line: 316}}, - FirstLine: 309, + Lines: []bytecode.LineEntry{{PC: 0, Line: 315}, {PC: 2, Line: 316}, {PC: 5, Line: 317}, {PC: 8, Line: 319}, {PC: 20, Line: 320}, {PC: 47, Line: 321}}, + FirstLine: 314, Super: "", }, }, @@ -989,8 +991,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 4, Locals: []string{"n", "block", "result", "first"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 322}, {PC: 2, Line: 254}, {PC: 5, Line: 323}, {PC: 20, Line: 254}, {PC: 23, Line: 325}, {PC: 26, Line: 326}, {PC: 29, Line: 336}}, - FirstLine: 322, + Lines: []bytecode.LineEntry{{PC: 0, Line: 327}, {PC: 2, Line: 259}, {PC: 5, Line: 328}, {PC: 20, Line: 259}, {PC: 23, Line: 330}, {PC: 26, Line: 331}, {PC: 29, Line: 341}}, + FirstLine: 327, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in max", @@ -1011,8 +1013,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "c"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 327}, {PC: 2, Line: 328}, {PC: 5, Line: 329}, {PC: 8, Line: 331}, {PC: 20, Line: 332}, {PC: 47, Line: 333}}, - FirstLine: 326, + Lines: []bytecode.LineEntry{{PC: 0, Line: 332}, {PC: 2, Line: 333}, {PC: 5, Line: 334}, {PC: 8, Line: 336}, {PC: 20, Line: 337}, {PC: 47, Line: 338}}, + FirstLine: 331, Super: "", }, }, @@ -1029,27 +1031,29 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 340}}, - FirstLine: 339, + Lines: []bytecode.LineEntry{{PC: 0, Line: 345}}, + FirstLine: 344, Super: "", }, &bytecode.ISeq{ Name: "reduce", - 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, Flags: 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: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 5}, {Op: 30, A: 4, B: 1, Flags: 3}, {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: 3}, {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: 3}, {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, Flags: 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: 3}, {Op: 10}, {Op: 27, A: 93}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 7, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 1, A: 7}, {Op: 30, A: 9, B: 1, Flags: 3}, {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, Flags: 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}}, + 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, Flags: 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: 64}, {Op: 52}, {Op: 10}, {Op: 28, A: 41}, {Op: 9}, {Op: 36, A: 4}, {Op: 28, A: 49}, {Op: 5}, {Op: 1, A: 4}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 7, A: 1}, {Op: 30, A: 5, B: 2}, {Op: 26, A: 50}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 11}, {Op: 1, A: 6}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 93}, {Op: 11}, {Op: 30, Flags: 1}, {Op: 1, A: 6}, {Op: 22}, {Op: 28, A: 84}, {Op: 52}, {Op: 28, A: 79}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 3}, {Op: 12, A: 2}, {Op: 26, A: 83}, {Op: 11}, {Op: 1, A: 7}, {Op: 30, A: 6, B: 1, Flags: 3}, {Op: 12, A: 1}, {Op: 26, A: 93}, {Op: 52}, {Op: 25}, {Op: 28, A: 92}, {Op: 5}, {Op: 33, A: 1}, {Op: 1, A: 8}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 93}, {Op: 2}, {Op: 9}, {Op: 11, A: 1}, {Op: 30, A: 7, Flags: 1}, {Op: 10}, {Op: 27, A: 102}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 8}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 10}, {Op: 27, A: 108}, {Op: 9}, {Op: 11, A: 1}, {Op: 33, A: 10}, {Op: 30, A: 9, B: 1, Flags: 3}, {Op: 25}, {Op: 28, A: 133}, {Op: 11, A: 1}, {Op: 1, A: 9}, {Op: 30, A: 11, B: 1, Flags: 3}, {Op: 28, A: 118}, {Op: 11, A: 1}, {Op: 30, A: 12, Flags: 1}, {Op: 12, A: 1}, {Op: 26, A: 132}, {Op: 5}, {Op: 33, A: 13}, {Op: 1, A: 10}, {Op: 1, A: 11}, {Op: 30, A: 2}, {Op: 13}, {Op: 11, A: 1}, {Op: 30, A: 14, Flags: 1}, {Op: 30, A: 2}, {Op: 13}, {Op: 1, A: 12}, {Op: 30, A: 2}, {Op: 13}, {Op: 30, A: 3, B: 2, Flags: 2}, {Op: 26, A: 134}, {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: 15, 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.NewString("given block not used"), + object.Symbol("uplevel"), object.IntValue(1), + object.IntValue(0), 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", "ArgumentError", "to_s", "raise", "[]", "nil?", "Symbol", "is_a?", "String", "respond_to?", "to_str", "TypeError", "inspect", "__each_packed"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "$VERBOSE", "warn", "[]", "nil?", "Symbol", "is_a?", "String", "respond_to?", "to_str", "TypeError", "inspect", "__each_packed"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -1058,8 +1062,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 6, Locals: []string{"args", "sym", "has_init", "init", "acc", "started"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 348}, {PC: 22, Line: 254}, {PC: 25, Line: 350}, {PC: 28, Line: 254}, {PC: 31, Line: 352}, {PC: 36, Line: 353}, {PC: 41, Line: 354}, {PC: 46, Line: 355}, {PC: 54, Line: 357}, {PC: 56, Line: 358}, {PC: 61, Line: 359}, {PC: 64, Line: 361}, {PC: 72, Line: 364}, {PC: 79, Line: 366}, {PC: 95, Line: 367}, {PC: 99, Line: 368}, {PC: 103, Line: 370}, {PC: 120, Line: 373}, {PC: 123, Line: 374}, {PC: 126, Line: 375}, {PC: 129, Line: 385}}, - FirstLine: 343, + Lines: []bytecode.LineEntry{{PC: 0, Line: 353}, {PC: 22, Line: 259}, {PC: 25, Line: 355}, {PC: 28, Line: 259}, {PC: 31, Line: 357}, {PC: 36, Line: 362}, {PC: 51, Line: 363}, {PC: 56, Line: 364}, {PC: 61, Line: 365}, {PC: 69, Line: 367}, {PC: 71, Line: 368}, {PC: 76, Line: 369}, {PC: 79, Line: 371}, {PC: 87, Line: 374}, {PC: 94, Line: 376}, {PC: 110, Line: 377}, {PC: 114, Line: 378}, {PC: 118, Line: 380}, {PC: 135, Line: 383}, {PC: 138, Line: 384}, {PC: 141, Line: 385}, {PC: 144, Line: 395}}, + FirstLine: 348, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reduce", @@ -1073,8 +1077,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 376}, {PC: 3, Line: 377}, {PC: 6, Line: 378}, {PC: 11, Line: 380}, {PC: 17, Line: 382}}, - FirstLine: 375, + Lines: []bytecode.LineEntry{{PC: 0, Line: 386}, {PC: 3, Line: 387}, {PC: 6, Line: 388}, {PC: 11, Line: 390}, {PC: 17, Line: 392}}, + FirstLine: 385, Super: "", }, }, @@ -1082,11 +1086,14 @@ func embeddedPrelude() *bytecode.ISeq { }, &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, Flags: 2}, {Op: 53}}, + 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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}}, Consts: []object.Value{ + object.NewString("given block not used"), + object.Symbol("uplevel"), + object.IntValue(1), object.Symbol("__enum_any"), }, - Names: []string{"catch"}, + Names: []string{"warn", "catch"}, Params: []string{"pattern"}, NumRequired: 0, SplatIndex: -1, @@ -1095,8 +1102,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 394}, {PC: 5, Line: 254}, {PC: 8, Line: 395}, {PC: 11, Line: 396}}, - FirstLine: 394, + Lines: []bytecode.LineEntry{{PC: 0, Line: 404}, {PC: 5, Line: 259}, {PC: 8, Line: 405}, {PC: 11, Line: 408}, {PC: 27, Line: 409}}, + FirstLine: 404, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in any?", @@ -1108,8 +1115,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 397}, {PC: 3, Line: 401}}, - FirstLine: 396, + Lines: []bytecode.LineEntry{{PC: 0, Line: 410}, {PC: 3, Line: 414}}, + FirstLine: 409, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in any?", @@ -1126,8 +1133,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 398}, {PC: 21, Line: 399}}, - FirstLine: 397, + Lines: []bytecode.LineEntry{{PC: 0, Line: 411}, {PC: 21, Line: 412}}, + FirstLine: 410, Super: "", }, }, @@ -1138,11 +1145,14 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "all?", - 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, Flags: 2}, {Op: 53}}, + 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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}}, Consts: []object.Value{ + object.NewString("given block not used"), + object.Symbol("uplevel"), + object.IntValue(1), object.Symbol("__enum_all"), }, - Names: []string{"catch"}, + Names: []string{"warn", "catch"}, Params: []string{"pattern"}, NumRequired: 0, SplatIndex: -1, @@ -1151,8 +1161,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 405}, {PC: 5, Line: 254}, {PC: 8, Line: 406}, {PC: 11, Line: 407}}, - FirstLine: 405, + Lines: []bytecode.LineEntry{{PC: 0, Line: 418}, {PC: 5, Line: 259}, {PC: 8, Line: 419}, {PC: 11, Line: 422}, {PC: 27, Line: 423}}, + FirstLine: 418, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in all?", @@ -1164,8 +1174,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 408}, {PC: 3, Line: 412}}, - FirstLine: 407, + Lines: []bytecode.LineEntry{{PC: 0, Line: 424}, {PC: 3, Line: 428}}, + FirstLine: 423, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in all?", @@ -1182,8 +1192,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 409}, {PC: 21, Line: 410}}, - FirstLine: 408, + Lines: []bytecode.LineEntry{{PC: 0, Line: 425}, {PC: 21, Line: 426}}, + FirstLine: 424, Super: "", }, }, @@ -1194,11 +1204,14 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "none?", - 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, Flags: 2}, {Op: 53}}, + 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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 5}, {Op: 1, A: 3}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 53}}, Consts: []object.Value{ + object.NewString("given block not used"), + object.Symbol("uplevel"), + object.IntValue(1), object.Symbol("__enum_none"), }, - Names: []string{"catch"}, + Names: []string{"warn", "catch"}, Params: []string{"pattern"}, NumRequired: 0, SplatIndex: -1, @@ -1207,8 +1220,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"pattern", "no_pat", "blk"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 416}, {PC: 5, Line: 254}, {PC: 8, Line: 417}, {PC: 11, Line: 418}}, - FirstLine: 416, + Lines: []bytecode.LineEntry{{PC: 0, Line: 432}, {PC: 5, Line: 259}, {PC: 8, Line: 433}, {PC: 11, Line: 436}, {PC: 27, Line: 437}}, + FirstLine: 432, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in none?", @@ -1220,8 +1233,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 419}, {PC: 3, Line: 423}}, - FirstLine: 418, + Lines: []bytecode.LineEntry{{PC: 0, Line: 438}, {PC: 3, Line: 442}}, + FirstLine: 437, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in none?", @@ -1238,8 +1251,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 420}, {PC: 21, Line: 421}}, - FirstLine: 419, + Lines: []bytecode.LineEntry{{PC: 0, Line: 439}, {PC: 21, Line: 440}}, + FirstLine: 438, Super: "", }, }, @@ -1250,13 +1263,15 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "one?", - 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: 1}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 1}, {Op: 30, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 2}, {Op: 22}, {Op: 53}}, + 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: 11, A: 2}, {Op: 10}, {Op: 28, A: 17}, {Op: 9}, {Op: 11, A: 1}, {Op: 25}, {Op: 28, A: 25}, {Op: 5}, {Op: 1}, {Op: 1, A: 1}, {Op: 1, A: 2}, {Op: 7, A: 1}, {Op: 30, B: 2}, {Op: 26, A: 26}, {Op: 2}, {Op: 9}, {Op: 1, A: 3}, {Op: 12, A: 3}, {Op: 9}, {Op: 5}, {Op: 1, A: 4}, {Op: 30, A: 1, B: 1, C: 1, Flags: 2}, {Op: 9}, {Op: 11, A: 3}, {Op: 1, A: 2}, {Op: 22}, {Op: 53}}, Consts: []object.Value{ + object.NewString("given block not used"), + object.Symbol("uplevel"), + object.IntValue(1), object.IntValue(0), object.Symbol("__enum_one"), - object.IntValue(1), }, - Names: []string{"catch"}, + Names: []string{"warn", "catch"}, Params: []string{"pattern"}, NumRequired: 0, SplatIndex: -1, @@ -1265,8 +1280,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"pattern", "no_pat", "blk", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 431}, {PC: 5, Line: 254}, {PC: 8, Line: 432}, {PC: 11, Line: 433}, {PC: 14, Line: 434}, {PC: 18, Line: 443}}, - FirstLine: 431, + Lines: []bytecode.LineEntry{{PC: 0, Line: 450}, {PC: 5, Line: 259}, {PC: 8, Line: 451}, {PC: 11, Line: 453}, {PC: 27, Line: 454}, {PC: 30, Line: 455}, {PC: 34, Line: 464}}, + FirstLine: 450, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in one?", @@ -1278,8 +1293,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 435}}, - FirstLine: 434, + Lines: []bytecode.LineEntry{{PC: 0, Line: 456}}, + FirstLine: 455, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in one?", @@ -1297,8 +1312,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "truth"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 436}, {PC: 21, Line: 437}, {PC: 23, Line: 438}, {PC: 28, Line: 439}}, - FirstLine: 435, + Lines: []bytecode.LineEntry{{PC: 0, Line: 457}, {PC: 21, Line: 458}, {PC: 23, Line: 459}, {PC: 28, Line: 460}}, + FirstLine: 456, Super: "", }, }, @@ -1318,8 +1333,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"result", "keys", "hashes"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 451}, {PC: 3, Line: 452}, {PC: 6, Line: 453}, {PC: 9, Line: 454}, {PC: 12, Line: 472}}, - FirstLine: 450, + Lines: []bytecode.LineEntry{{PC: 0, Line: 472}, {PC: 3, Line: 473}, {PC: 6, Line: 474}, {PC: 9, Line: 475}, {PC: 12, Line: 493}}, + FirstLine: 471, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in uniq", @@ -1337,8 +1352,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 6, Locals: []string{"x", "key", "h", "seen", "i", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 455}, {PC: 8, Line: 456}, {PC: 12, Line: 457}, {PC: 15, Line: 458}, {PC: 18, Line: 459}, {PC: 23, Line: 460}, {PC: 37, Line: 461}, {PC: 40, Line: 462}, {PC: 47, Line: 464}, {PC: 57, Line: 466}, {PC: 60, Line: 467}, {PC: 64, Line: 468}, {PC: 68, Line: 469}}, - FirstLine: 454, + Lines: []bytecode.LineEntry{{PC: 0, Line: 476}, {PC: 8, Line: 477}, {PC: 12, Line: 478}, {PC: 15, Line: 479}, {PC: 18, Line: 480}, {PC: 23, Line: 481}, {PC: 37, Line: 482}, {PC: 40, Line: 483}, {PC: 47, Line: 485}, {PC: 57, Line: 487}, {PC: 60, Line: 488}, {PC: 64, Line: 489}, {PC: 68, Line: 490}}, + FirstLine: 475, Super: "", }, }, @@ -1355,8 +1370,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 478}, {PC: 3, Line: 479}, {PC: 6, Line: 480}}, - FirstLine: 477, + Lines: []bytecode.LineEntry{{PC: 0, Line: 499}, {PC: 3, Line: 500}, {PC: 6, Line: 501}}, + FirstLine: 498, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in compact", @@ -1370,8 +1385,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 479}}, - FirstLine: 479, + Lines: []bytecode.LineEntry{{PC: 0, Line: 500}}, + FirstLine: 500, Super: "", }, }, @@ -1393,8 +1408,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 484}, {PC: 16, Line: 485}, {PC: 19, Line: 486}, {PC: 26, Line: 109}}, - FirstLine: 483, + Lines: []bytecode.LineEntry{{PC: 0, Line: 505}, {PC: 16, Line: 506}, {PC: 19, Line: 507}, {PC: 26, Line: 109}}, + FirstLine: 504, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_with_index", @@ -1409,8 +1424,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 484}}, - FirstLine: 484, + Lines: []bytecode.LineEntry{{PC: 0, Line: 505}}, + FirstLine: 505, Super: "", }, &bytecode.ISeq{ @@ -1428,8 +1443,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 487}, {PC: 6, Line: 488}}, - FirstLine: 486, + Lines: []bytecode.LineEntry{{PC: 0, Line: 508}, {PC: 6, Line: 509}}, + FirstLine: 507, Super: "", }, }, @@ -1449,8 +1464,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 498}, {PC: 10, Line: 499}, {PC: 15, Line: 109}}, - FirstLine: 497, + Lines: []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 10, Line: 520}, {PC: 15, Line: 109}}, + FirstLine: 518, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reverse_each", @@ -1465,8 +1480,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 498}, {PC: 7, Line: 254}}, - FirstLine: 498, + Lines: []bytecode.LineEntry{{PC: 0, Line: 519}, {PC: 7, Line: 259}}, + FirstLine: 519, Super: "", }, }, @@ -1486,8 +1501,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 504}, {PC: 10, Line: 505}, {PC: 13, Line: 506}, {PC: 16, Line: 515}}, - FirstLine: 503, + Lines: []bytecode.LineEntry{{PC: 0, Line: 525}, {PC: 10, Line: 526}, {PC: 13, Line: 527}, {PC: 16, Line: 536}}, + FirstLine: 524, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flat_map", @@ -1502,8 +1517,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 504}}, - FirstLine: 504, + Lines: []bytecode.LineEntry{{PC: 0, Line: 525}}, + FirstLine: 525, Super: "", }, &bytecode.ISeq{ @@ -1518,8 +1533,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"x", "v", "ary"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 507}, {PC: 4, Line: 508}, {PC: 9, Line: 509}, {PC: 12, Line: 510}, {PC: 16, Line: 512}}, - FirstLine: 506, + Lines: []bytecode.LineEntry{{PC: 0, Line: 528}, {PC: 4, Line: 529}, {PC: 9, Line: 530}, {PC: 12, Line: 531}, {PC: 16, Line: 533}}, + FirstLine: 527, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in flat_map", @@ -1533,8 +1548,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"e"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 512}}, - FirstLine: 512, + Lines: []bytecode.LineEntry{{PC: 0, Line: 533}}, + FirstLine: 533, Super: "", }, }, @@ -1558,8 +1573,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 527}, {PC: 16, Line: 528}, {PC: 23, Line: 109}}, - FirstLine: 526, + Lines: []bytecode.LineEntry{{PC: 0, Line: 548}, {PC: 16, Line: 549}, {PC: 23, Line: 109}}, + FirstLine: 547, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_entry", @@ -1574,8 +1589,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 527}}, - FirstLine: 527, + Lines: []bytecode.LineEntry{{PC: 0, Line: 548}}, + FirstLine: 548, Super: "", }, &bytecode.ISeq{ @@ -1590,8 +1605,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 528}}, - FirstLine: 528, + Lines: []bytecode.LineEntry{{PC: 0, Line: 549}}, + FirstLine: 549, Super: "", }, }, @@ -1612,8 +1627,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"memo"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 533}, {PC: 11, Line: 534}, {PC: 14, Line: 535}}, - FirstLine: 532, + Lines: []bytecode.LineEntry{{PC: 0, Line: 554}, {PC: 11, Line: 555}, {PC: 14, Line: 556}}, + FirstLine: 553, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_with_object", @@ -1628,8 +1643,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 533}}, - FirstLine: 533, + Lines: []bytecode.LineEntry{{PC: 0, Line: 554}}, + FirstLine: 554, Super: "", }, &bytecode.ISeq{ @@ -1643,8 +1658,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 534}}, - FirstLine: 534, + Lines: []bytecode.LineEntry{{PC: 0, Line: 555}}, + FirstLine: 555, Super: "", }, }, @@ -1664,8 +1679,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 539}, {PC: 10, Line: 540}, {PC: 13, Line: 541}, {PC: 16, Line: 545}}, - FirstLine: 538, + Lines: []bytecode.LineEntry{{PC: 0, Line: 560}, {PC: 10, Line: 561}, {PC: 13, Line: 562}, {PC: 16, Line: 566}}, + FirstLine: 559, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in filter_map", @@ -1680,8 +1695,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 539}}, - FirstLine: 539, + Lines: []bytecode.LineEntry{{PC: 0, Line: 560}}, + FirstLine: 560, Super: "", }, &bytecode.ISeq{ @@ -1696,8 +1711,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 542}, {PC: 4, Line: 543}}, - FirstLine: 541, + Lines: []bytecode.LineEntry{{PC: 0, Line: 563}, {PC: 4, Line: 564}}, + FirstLine: 562, Super: "", }, }, @@ -1717,8 +1732,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"yes", "no"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 549}, {PC: 10, Line: 550}, {PC: 13, Line: 551}, {PC: 16, Line: 552}, {PC: 19, Line: 559}}, - FirstLine: 548, + Lines: []bytecode.LineEntry{{PC: 0, Line: 570}, {PC: 10, Line: 571}, {PC: 13, Line: 572}, {PC: 16, Line: 573}, {PC: 19, Line: 580}}, + FirstLine: 569, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in partition", @@ -1733,8 +1748,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 549}}, - FirstLine: 549, + Lines: []bytecode.LineEntry{{PC: 0, Line: 570}}, + FirstLine: 570, Super: "", }, &bytecode.ISeq{ @@ -1749,8 +1764,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 553}, {PC: 3, Line: 554}, {PC: 7, Line: 556}}, - FirstLine: 552, + Lines: []bytecode.LineEntry{{PC: 0, Line: 574}, {PC: 3, Line: 575}, {PC: 7, Line: 577}}, + FirstLine: 573, Super: "", }, }, @@ -1770,8 +1785,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 563}, {PC: 10, Line: 564}, {PC: 13, Line: 565}, {PC: 16, Line: 569}}, - FirstLine: 562, + Lines: []bytecode.LineEntry{{PC: 0, Line: 584}, {PC: 10, Line: 585}, {PC: 13, Line: 586}, {PC: 16, Line: 590}}, + FirstLine: 583, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in group_by", @@ -1786,8 +1801,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 563}}, - FirstLine: 563, + Lines: []bytecode.LineEntry{{PC: 0, Line: 584}}, + FirstLine: 584, Super: "", }, &bytecode.ISeq{ @@ -1802,8 +1817,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"x", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 566}, {PC: 4, Line: 567}}, - FirstLine: 565, + Lines: []bytecode.LineEntry{{PC: 0, Line: 587}, {PC: 4, Line: 588}}, + FirstLine: 586, Super: "", }, }, @@ -1838,8 +1853,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "h", "a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 577}, {PC: 22, Line: 578}, {PC: 25, Line: 579}, {PC: 28, Line: 581}, {PC: 33, Line: 582}, {PC: 38, Line: 583}, {PC: 42, Line: 584}, {PC: 46, Line: 585}, {PC: 86, Line: 587}, {PC: 108, Line: 590}, {PC: 111, Line: 592}, {PC: 114, Line: 604}}, - FirstLine: 576, + Lines: []bytecode.LineEntry{{PC: 0, Line: 598}, {PC: 22, Line: 599}, {PC: 25, Line: 600}, {PC: 28, Line: 602}, {PC: 33, Line: 603}, {PC: 38, Line: 604}, {PC: 42, Line: 605}, {PC: 46, Line: 606}, {PC: 86, Line: 608}, {PC: 108, Line: 611}, {PC: 111, Line: 613}, {PC: 114, Line: 625}}, + FirstLine: 597, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in tally", @@ -1863,8 +1878,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"x", "c", "tn", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 593}, {PC: 4, Line: 594}, {PC: 9, Line: 595}, {PC: 14, Line: 596}, {PC: 35, Line: 597}, {PC: 51, Line: 600}, {PC: 54, Line: 602}}, - FirstLine: 592, + Lines: []bytecode.LineEntry{{PC: 0, Line: 614}, {PC: 4, Line: 615}, {PC: 9, Line: 616}, {PC: 14, Line: 617}, {PC: 35, Line: 618}, {PC: 51, Line: 621}, {PC: 54, Line: 623}}, + FirstLine: 613, Super: "", }, }, @@ -1885,8 +1900,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"others", "blk", "r", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 613}, {PC: 4, Line: 622}, {PC: 7, Line: 623}, {PC: 9, Line: 254}, {PC: 14, Line: 624}, {PC: 17, Line: 625}, {PC: 20, Line: 635}}, - FirstLine: 612, + Lines: []bytecode.LineEntry{{PC: 0, Line: 634}, {PC: 4, Line: 643}, {PC: 7, Line: 644}, {PC: 9, Line: 259}, {PC: 14, Line: 645}, {PC: 17, Line: 646}, {PC: 20, Line: 656}}, + FirstLine: 633, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in zip", @@ -1907,8 +1922,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 614}, {PC: 4, Line: 615}, {PC: 11, Line: 617}, {PC: 16, Line: 619}}, - FirstLine: 613, + Lines: []bytecode.LineEntry{{PC: 0, Line: 635}, {PC: 4, Line: 636}, {PC: 11, Line: 638}, {PC: 16, Line: 640}}, + FirstLine: 634, Super: "", }, &bytecode.ISeq{ @@ -1926,8 +1941,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "row"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 626}, {PC: 4, Line: 627}, {PC: 7, Line: 628}, {PC: 9, Line: 629}, {PC: 12, Line: 631}, {PC: 16, Line: 633}}, - FirstLine: 625, + Lines: []bytecode.LineEntry{{PC: 0, Line: 647}, {PC: 4, Line: 648}, {PC: 7, Line: 649}, {PC: 9, Line: 650}, {PC: 12, Line: 652}, {PC: 16, Line: 654}}, + FirstLine: 646, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in zip", @@ -1941,8 +1956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 627}}, - FirstLine: 627, + Lines: []bytecode.LineEntry{{PC: 0, Line: 648}}, + FirstLine: 648, Super: "", }, }, @@ -1953,16 +1968,18 @@ 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, Flags: 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, Flags: 2}, {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}}, + 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, Flags: 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, Flags: 2}, {Op: 53}, {Op: 26, A: 36}, {Op: 2}, {Op: 9}, {Op: 11}, {Op: 30, A: 4, Flags: 1}, {Op: 25}, {Op: 10}, {Op: 28, A: 44}, {Op: 9}, {Op: 52}, {Op: 28, A: 52}, {Op: 5}, {Op: 1, A: 5}, {Op: 1, A: 6}, {Op: 1}, {Op: 7, A: 1}, {Op: 30, A: 6, B: 2}, {Op: 26, A: 53}, {Op: 2}, {Op: 9}, {Op: 2}, {Op: 12, A: 1}, {Op: 9}, {Op: 1, A: 7}, {Op: 12, A: 2}, {Op: 9}, {Op: 5}, {Op: 30, A: 7, C: 2}, {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.Symbol("find_index"), + object.NewString("given block not used"), + object.Symbol("uplevel"), object.IntValue(0), }, - Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "each"}, + Names: []string{"length", "ArgumentError", "to_s", "raise", "empty?", "enum_for", "warn", "each"}, Params: []string{"args"}, NumRequired: 0, SplatIndex: 0, @@ -1971,8 +1988,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"args", "idx", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 642}, {PC: 22, Line: 643}, {PC: 37, Line: 254}, {PC: 40, Line: 645}, {PC: 43, Line: 646}, {PC: 46, Line: 650}}, - FirstLine: 641, + Lines: []bytecode.LineEntry{{PC: 0, Line: 663}, {PC: 22, Line: 664}, {PC: 37, Line: 666}, {PC: 54, Line: 259}, {PC: 57, Line: 668}, {PC: 60, Line: 669}, {PC: 63, Line: 673}}, + FirstLine: 662, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in find_index", @@ -1983,8 +2000,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 643, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 664, Super: "", }, &bytecode.ISeq{ @@ -2003,8 +2020,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 647}, {PC: 27, Line: 648}}, - FirstLine: 646, + Lines: []bytecode.LineEntry{{PC: 0, Line: 670}, {PC: 27, Line: 671}}, + FirstLine: 669, Super: "", }, }, @@ -2022,8 +2039,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"pattern", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 658}, {PC: 3, Line: 659}, {PC: 6, Line: 660}}, - FirstLine: 657, + Lines: []bytecode.LineEntry{{PC: 0, Line: 681}, {PC: 3, Line: 682}, {PC: 6, Line: 683}}, + FirstLine: 680, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in grep", @@ -2037,8 +2054,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 659}}, - FirstLine: 659, + Lines: []bytecode.LineEntry{{PC: 0, Line: 682}}, + FirstLine: 682, Super: "", }, }, @@ -2056,8 +2073,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"pattern", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 664}, {PC: 3, Line: 665}, {PC: 6, Line: 666}}, - FirstLine: 663, + Lines: []bytecode.LineEntry{{PC: 0, Line: 687}, {PC: 3, Line: 688}, {PC: 6, Line: 689}}, + FirstLine: 686, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in grep_v", @@ -2071,8 +2088,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 665}}, - FirstLine: 665, + Lines: []bytecode.LineEntry{{PC: 0, Line: 688}}, + FirstLine: 688, Super: "", }, }, @@ -2092,8 +2109,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"r", "taking"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 670}, {PC: 10, Line: 671}, {PC: 13, Line: 672}, {PC: 16, Line: 673}, {PC: 19, Line: 681}}, - FirstLine: 669, + Lines: []bytecode.LineEntry{{PC: 0, Line: 693}, {PC: 10, Line: 694}, {PC: 13, Line: 695}, {PC: 16, Line: 696}, {PC: 19, Line: 704}}, + FirstLine: 692, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in take_while", @@ -2104,8 +2121,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 670, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 693, Super: "", }, &bytecode.ISeq{ @@ -2120,8 +2137,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 674}, {PC: 8, Line: 675}, {PC: 14, Line: 676}, {PC: 20, Line: 678}}, - FirstLine: 673, + Lines: []bytecode.LineEntry{{PC: 0, Line: 697}, {PC: 8, Line: 698}, {PC: 14, Line: 699}, {PC: 20, Line: 701}}, + FirstLine: 696, Super: "", }, }, @@ -2141,8 +2158,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"r", "dropping"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 685}, {PC: 10, Line: 686}, {PC: 13, Line: 687}, {PC: 16, Line: 688}, {PC: 19, Line: 692}}, - FirstLine: 684, + Lines: []bytecode.LineEntry{{PC: 0, Line: 708}, {PC: 10, Line: 709}, {PC: 13, Line: 710}, {PC: 16, Line: 711}, {PC: 19, Line: 715}}, + FirstLine: 707, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in drop_while", @@ -2153,8 +2170,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 685, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 708, Super: "", }, &bytecode.ISeq{ @@ -2169,8 +2186,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 689}, {PC: 13, Line: 690}}, - FirstLine: 688, + Lines: []bytecode.LineEntry{{PC: 0, Line: 712}, {PC: 13, Line: 713}}, + FirstLine: 711, Super: "", }, }, @@ -2193,8 +2210,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "buf"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 702}, {PC: 5, Line: 703}, {PC: 16, Line: 704}, {PC: 19, Line: 705}, {PC: 27, Line: 709}, {PC: 30, Line: 710}, {PC: 33, Line: 717}, {PC: 42, Line: 109}}, - FirstLine: 701, + Lines: []bytecode.LineEntry{{PC: 0, Line: 725}, {PC: 5, Line: 726}, {PC: 16, Line: 727}, {PC: 19, Line: 728}, {PC: 27, Line: 732}, {PC: 30, Line: 733}, {PC: 33, Line: 740}, {PC: 42, Line: 109}}, + FirstLine: 724, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_slice", @@ -2211,8 +2228,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 706}, {PC: 18, Line: 254}}, - FirstLine: 705, + Lines: []bytecode.LineEntry{{PC: 0, Line: 729}, {PC: 18, Line: 259}}, + FirstLine: 728, Super: "", }, &bytecode.ISeq{ @@ -2227,8 +2244,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 711}, {PC: 4, Line: 712}, {PC: 9, Line: 713}, {PC: 12, Line: 714}}, - FirstLine: 710, + Lines: []bytecode.LineEntry{{PC: 0, Line: 734}, {PC: 4, Line: 735}, {PC: 9, Line: 736}, {PC: 12, Line: 737}}, + FirstLine: 733, Super: "", }, }, @@ -2251,8 +2268,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "window"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 722}, {PC: 5, Line: 723}, {PC: 16, Line: 724}, {PC: 19, Line: 725}, {PC: 27, Line: 731}, {PC: 30, Line: 732}, {PC: 33, Line: 109}}, - FirstLine: 721, + Lines: []bytecode.LineEntry{{PC: 0, Line: 745}, {PC: 5, Line: 746}, {PC: 16, Line: 747}, {PC: 19, Line: 748}, {PC: 27, Line: 754}, {PC: 30, Line: 755}, {PC: 33, Line: 109}}, + FirstLine: 744, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_cons", @@ -2270,8 +2287,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 726}, {PC: 10, Line: 727}}, - FirstLine: 725, + Lines: []bytecode.LineEntry{{PC: 0, Line: 749}, {PC: 10, Line: 750}}, + FirstLine: 748, Super: "", }, &bytecode.ISeq{ @@ -2286,8 +2303,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 733}, {PC: 4, Line: 734}, {PC: 14, Line: 735}}, - FirstLine: 732, + Lines: []bytecode.LineEntry{{PC: 0, Line: 756}, {PC: 4, Line: 757}, {PC: 14, Line: 758}}, + FirstLine: 755, Super: "", }, }, @@ -2314,8 +2331,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "result", "n", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 746}, {PC: 22, Line: 747}, {PC: 25, Line: 254}, {PC: 28, Line: 749}, {PC: 32, Line: 752}, {PC: 37, Line: 754}, {PC: 44, Line: 755}, {PC: 55, Line: 756}, {PC: 64, Line: 757}, {PC: 67, Line: 758}, {PC: 71, Line: 764}}, - FirstLine: 745, + Lines: []bytecode.LineEntry{{PC: 0, Line: 769}, {PC: 22, Line: 770}, {PC: 25, Line: 259}, {PC: 28, Line: 772}, {PC: 32, Line: 775}, {PC: 37, Line: 777}, {PC: 44, Line: 778}, {PC: 55, Line: 779}, {PC: 64, Line: 780}, {PC: 67, Line: 781}, {PC: 71, Line: 787}}, + FirstLine: 768, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in first", @@ -2327,8 +2344,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 750}}, - FirstLine: 749, + Lines: []bytecode.LineEntry{{PC: 0, Line: 773}}, + FirstLine: 772, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in first", @@ -2345,8 +2362,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 750}}, - FirstLine: 750, + Lines: []bytecode.LineEntry{{PC: 0, Line: 773}}, + FirstLine: 773, Super: "", }, }, @@ -2362,8 +2379,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 759}}, - FirstLine: 758, + Lines: []bytecode.LineEntry{{PC: 0, Line: 782}}, + FirstLine: 781, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in first", @@ -2380,8 +2397,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 760}, {PC: 4, Line: 761}}, - FirstLine: 759, + Lines: []bytecode.LineEntry{{PC: 0, Line: 783}, {PC: 4, Line: 784}}, + FirstLine: 782, Super: "", }, }, @@ -2407,8 +2424,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 768}, {PC: 5, Line: 769}, {PC: 16, Line: 770}, {PC: 25, Line: 771}, {PC: 28, Line: 772}, {PC: 32, Line: 778}}, - FirstLine: 767, + Lines: []bytecode.LineEntry{{PC: 0, Line: 791}, {PC: 5, Line: 792}, {PC: 16, Line: 793}, {PC: 25, Line: 794}, {PC: 28, Line: 795}, {PC: 32, Line: 801}}, + FirstLine: 790, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in take", @@ -2420,8 +2437,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 773}}, - FirstLine: 772, + Lines: []bytecode.LineEntry{{PC: 0, Line: 796}}, + FirstLine: 795, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in take", @@ -2438,8 +2455,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 774}, {PC: 4, Line: 775}}, - FirstLine: 773, + Lines: []bytecode.LineEntry{{PC: 0, Line: 797}, {PC: 4, Line: 798}}, + FirstLine: 796, Super: "", }, }, @@ -2464,8 +2481,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"n", "r", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 782}, {PC: 5, Line: 783}, {PC: 16, Line: 784}, {PC: 19, Line: 785}, {PC: 22, Line: 786}, {PC: 25, Line: 790}}, - FirstLine: 781, + Lines: []bytecode.LineEntry{{PC: 0, Line: 805}, {PC: 5, Line: 806}, {PC: 16, Line: 807}, {PC: 19, Line: 808}, {PC: 22, Line: 809}, {PC: 25, Line: 813}}, + FirstLine: 804, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in drop", @@ -2482,8 +2499,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 787}, {PC: 10, Line: 788}}, - FirstLine: 786, + Lines: []bytecode.LineEntry{{PC: 0, Line: 810}, {PC: 10, Line: 811}}, + FirstLine: 809, Super: "", }, }, @@ -2506,8 +2523,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"a", "chunks", "cur", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 799}, {PC: 10, Line: 800}, {PC: 14, Line: 801}, {PC: 24, Line: 802}, {PC: 27, Line: 803}, {PC: 33, Line: 804}, {PC: 36, Line: 805}, {PC: 41, Line: 806}, {PC: 51, Line: 807}, {PC: 57, Line: 809}, {PC: 61, Line: 810}, {PC: 67, Line: 812}, {PC: 75, Line: 814}, {PC: 79, Line: 815}}, - FirstLine: 798, + Lines: []bytecode.LineEntry{{PC: 0, Line: 822}, {PC: 10, Line: 823}, {PC: 14, Line: 824}, {PC: 24, Line: 825}, {PC: 27, Line: 826}, {PC: 33, Line: 827}, {PC: 36, Line: 828}, {PC: 41, Line: 829}, {PC: 51, Line: 830}, {PC: 57, Line: 832}, {PC: 61, Line: 833}, {PC: 67, Line: 835}, {PC: 75, Line: 837}, {PC: 79, Line: 838}}, + FirstLine: 821, Super: "", }, &bytecode.ISeq{ @@ -2527,8 +2544,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"a", "chunks", "cur", "i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 819}, {PC: 10, Line: 820}, {PC: 14, Line: 821}, {PC: 24, Line: 822}, {PC: 27, Line: 823}, {PC: 33, Line: 824}, {PC: 36, Line: 825}, {PC: 41, Line: 826}, {PC: 51, Line: 827}, {PC: 55, Line: 828}, {PC: 61, Line: 830}, {PC: 67, Line: 832}, {PC: 75, Line: 834}, {PC: 79, Line: 835}}, - FirstLine: 818, + Lines: []bytecode.LineEntry{{PC: 0, Line: 842}, {PC: 10, Line: 843}, {PC: 14, Line: 844}, {PC: 24, Line: 845}, {PC: 27, Line: 846}, {PC: 33, Line: 847}, {PC: 36, Line: 848}, {PC: 41, Line: 849}, {PC: 51, Line: 850}, {PC: 55, Line: 851}, {PC: 61, Line: 853}, {PC: 67, Line: 855}, {PC: 75, Line: 857}, {PC: 79, Line: 858}}, + FirstLine: 841, Super: "", }, &bytecode.ISeq{ @@ -2546,8 +2563,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"result", "open"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 845}, {PC: 10, Line: 846}, {PC: 13, Line: 847}, {PC: 16, Line: 848}, {PC: 19, Line: 867}}, - FirstLine: 844, + Lines: []bytecode.LineEntry{{PC: 0, Line: 868}, {PC: 10, Line: 869}, {PC: 13, Line: 870}, {PC: 16, Line: 871}, {PC: 19, Line: 890}}, + FirstLine: 867, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in chunk", @@ -2558,8 +2575,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 845, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 868, Super: "", }, &bytecode.ISeq{ @@ -2583,8 +2600,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"x", "k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 849}, {PC: 4, Line: 850}, {PC: 13, Line: 851}, {PC: 20, Line: 853}, {PC: 27, Line: 854}, {PC: 30, Line: 856}, {PC: 41, Line: 857}, {PC: 48, Line: 859}, {PC: 60, Line: 860}, {PC: 68, Line: 862}, {PC: 75, Line: 863}}, - FirstLine: 848, + Lines: []bytecode.LineEntry{{PC: 0, Line: 872}, {PC: 4, Line: 873}, {PC: 13, Line: 874}, {PC: 20, Line: 876}, {PC: 27, Line: 877}, {PC: 30, Line: 879}, {PC: 41, Line: 880}, {PC: 48, Line: 882}, {PC: 60, Line: 883}, {PC: 68, Line: 885}, {PC: 75, Line: 886}}, + FirstLine: 871, Super: "", }, &bytecode.ISeq{ @@ -2596,8 +2613,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 867, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 890, Super: "", }, }, @@ -2625,8 +2642,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "pat", "runs", "cur"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 878}, {PC: 22, Line: 879}, {PC: 24, Line: 880}, {PC: 35, Line: 882}, {PC: 45, Line: 883}, {PC: 50, Line: 885}, {PC: 53, Line: 254}, {PC: 56, Line: 887}, {PC: 59, Line: 896}, {PC: 69, Line: 897}}, - FirstLine: 877, + Lines: []bytecode.LineEntry{{PC: 0, Line: 901}, {PC: 22, Line: 902}, {PC: 24, Line: 903}, {PC: 35, Line: 905}, {PC: 45, Line: 906}, {PC: 50, Line: 908}, {PC: 53, Line: 259}, {PC: 56, Line: 910}, {PC: 59, Line: 919}, {PC: 69, Line: 920}}, + FirstLine: 900, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in slice_before", @@ -2640,8 +2657,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 888}, {PC: 9, Line: 889}, {PC: 19, Line: 890}, {PC: 23, Line: 892}, {PC: 31, Line: 893}}, - FirstLine: 887, + Lines: []bytecode.LineEntry{{PC: 0, Line: 911}, {PC: 9, Line: 912}, {PC: 19, Line: 913}, {PC: 23, Line: 915}, {PC: 31, Line: 916}}, + FirstLine: 910, Super: "", }, &bytecode.ISeq{ @@ -2653,8 +2670,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 897, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 920, Super: "", }, }, @@ -2682,8 +2699,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"args", "pat", "runs", "cur"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 901}, {PC: 22, Line: 902}, {PC: 24, Line: 903}, {PC: 35, Line: 905}, {PC: 45, Line: 906}, {PC: 50, Line: 908}, {PC: 53, Line: 909}, {PC: 56, Line: 910}, {PC: 59, Line: 917}, {PC: 69, Line: 918}}, - FirstLine: 900, + Lines: []bytecode.LineEntry{{PC: 0, Line: 924}, {PC: 22, Line: 925}, {PC: 24, Line: 926}, {PC: 35, Line: 928}, {PC: 45, Line: 929}, {PC: 50, Line: 931}, {PC: 53, Line: 932}, {PC: 56, Line: 933}, {PC: 59, Line: 940}, {PC: 69, Line: 941}}, + FirstLine: 923, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in slice_after", @@ -2697,8 +2714,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 911}, {PC: 4, Line: 912}, {PC: 13, Line: 913}, {PC: 17, Line: 914}}, - FirstLine: 910, + Lines: []bytecode.LineEntry{{PC: 0, Line: 934}, {PC: 4, Line: 935}, {PC: 13, Line: 936}, {PC: 17, Line: 937}}, + FirstLine: 933, Super: "", }, &bytecode.ISeq{ @@ -2710,8 +2727,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 254}}, - FirstLine: 918, + Lines: []bytecode.LineEntry{{PC: 0, Line: 259}}, + FirstLine: 941, Super: "", }, }, @@ -2730,8 +2747,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 924}, {PC: 10, Line: 925}}, - FirstLine: 923, + Lines: []bytecode.LineEntry{{PC: 0, Line: 947}, {PC: 10, Line: 948}}, + FirstLine: 946, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in minmax_by", @@ -2746,8 +2763,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 924}}, - FirstLine: 924, + Lines: []bytecode.LineEntry{{PC: 0, Line: 947}}, + FirstLine: 947, Super: "", }, &bytecode.ISeq{ @@ -2761,8 +2778,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 925}}, - FirstLine: 925, + Lines: []bytecode.LineEntry{{PC: 0, Line: 948}}, + FirstLine: 948, Super: "", }, &bytecode.ISeq{ @@ -2776,8 +2793,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 925}}, - FirstLine: 925, + Lines: []bytecode.LineEntry{{PC: 0, Line: 948}}, + FirstLine: 948, Super: "", }, }, @@ -2800,8 +2817,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"n", "buffer"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 930}, {PC: 2, Line: 254}, {PC: 5, Line: 931}, {PC: 8, Line: 936}, {PC: 16, Line: 948}, {PC: 20, Line: 949}, {PC: 25, Line: 950}, {PC: 29, Line: 254}, {PC: 36, Line: 954}, {PC: 39, Line: 955}, {PC: 42, Line: 960}, {PC: 45, Line: 254}, {PC: 50, Line: 961}, {PC: 53, Line: 962}, {PC: 56, Line: 964}, {PC: 61, Line: 254}}, - FirstLine: 930, + Lines: []bytecode.LineEntry{{PC: 0, Line: 953}, {PC: 2, Line: 259}, {PC: 5, Line: 954}, {PC: 8, Line: 959}, {PC: 16, Line: 971}, {PC: 20, Line: 972}, {PC: 25, Line: 973}, {PC: 29, Line: 259}, {PC: 36, Line: 977}, {PC: 39, Line: 978}, {PC: 42, Line: 983}, {PC: 45, Line: 259}, {PC: 50, Line: 984}, {PC: 53, Line: 985}, {PC: 56, Line: 987}, {PC: 61, Line: 259}}, + FirstLine: 953, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in cycle", @@ -2818,8 +2835,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sz"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 937}, {PC: 7, Line: 254}, {PC: 10, Line: 938}, {PC: 19, Line: 939}, {PC: 24, Line: 941}, {PC: 27, Line: 943}}, - FirstLine: 936, + Lines: []bytecode.LineEntry{{PC: 0, Line: 960}, {PC: 7, Line: 259}, {PC: 10, Line: 961}, {PC: 19, Line: 962}, {PC: 24, Line: 964}, {PC: 27, Line: 966}}, + FirstLine: 959, Super: "", }, &bytecode.ISeq{ @@ -2834,8 +2851,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"a", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 956}, {PC: 5, Line: 957}, {PC: 9, Line: 958}}, - FirstLine: 955, + Lines: []bytecode.LineEntry{{PC: 0, Line: 979}, {PC: 5, Line: 980}, {PC: 9, Line: 981}}, + FirstLine: 978, Super: "", }, &bytecode.ISeq{ @@ -2848,8 +2865,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 962}}, - FirstLine: 962, + Lines: []bytecode.LineEntry{{PC: 0, Line: 985}}, + FirstLine: 985, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in cycle", @@ -2862,8 +2879,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 962}}, - FirstLine: 962, + Lines: []bytecode.LineEntry{{PC: 0, Line: 985}}, + FirstLine: 985, Super: "", }, }, @@ -2879,8 +2896,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 964}}, - FirstLine: 964, + Lines: []bytecode.LineEntry{{PC: 0, Line: 987}}, + FirstLine: 987, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in cycle", @@ -2893,8 +2910,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 964}}, - FirstLine: 964, + Lines: []bytecode.LineEntry{{PC: 0, Line: 987}}, + FirstLine: 987, Super: "", }, }, @@ -2916,8 +2933,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 976}, {PC: 4, Line: 981}, {PC: 6, Line: 985}}, - FirstLine: 975, + Lines: []bytecode.LineEntry{{PC: 0, Line: 999}, {PC: 4, Line: 1004}, {PC: 6, Line: 1008}}, + FirstLine: 998, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -2929,8 +2946,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 982}}, - FirstLine: 981, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1005}}, + FirstLine: 1004, Super: "", }, &bytecode.ISeq{ @@ -2943,8 +2960,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 986}}, - FirstLine: 985, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1009}}, + FirstLine: 1008, Super: "", }, }, @@ -2960,8 +2977,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 992}, {PC: 2, Line: 996}}, - FirstLine: 990, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1015}, {PC: 2, Line: 1019}}, + FirstLine: 1013, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -2973,7 +2990,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 992, + FirstLine: 1015, Super: "", }, &bytecode.ISeq{ @@ -2988,8 +3005,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 997}}, - FirstLine: 996, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1020}}, + FirstLine: 1019, Super: "", }, }, @@ -3005,8 +3022,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1005}, {PC: 2, Line: 1009}}, - FirstLine: 1001, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1028}, {PC: 2, Line: 1032}}, + FirstLine: 1024, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "numerator", @@ -3018,8 +3035,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1006}, {PC: 7, Line: 109}}, - FirstLine: 1005, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1029}, {PC: 7, Line: 109}}, + FirstLine: 1028, Super: "", }, &bytecode.ISeq{ @@ -3035,8 +3052,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1010}}, - FirstLine: 1009, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1033}}, + FirstLine: 1032, Super: "", }, }, @@ -3052,8 +3069,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1015}}, - FirstLine: 1014, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1038}}, + FirstLine: 1037, Super: "", }, &bytecode.ISeq{ @@ -3066,8 +3083,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1019}}, - FirstLine: 1018, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1042}}, + FirstLine: 1041, Super: "", }, &bytecode.ISeq{ @@ -3080,8 +3097,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1028}, {PC: 4, Line: 1031}}, - FirstLine: 1027, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1051}, {PC: 4, Line: 1054}}, + FirstLine: 1050, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct", @@ -3093,7 +3110,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1031, + FirstLine: 1054, Super: "", }, }, @@ -3109,8 +3126,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1037}, {PC: 4, Line: 1044}, {PC: 6, Line: 1051}, {PC: 8, Line: 1061}}, - FirstLine: 1036, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1060}, {PC: 4, Line: 1067}, {PC: 6, Line: 1074}, {PC: 8, Line: 1084}}, + FirstLine: 1059, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "==", @@ -3124,8 +3141,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1045}, {PC: 9, Line: 1046}, {PC: 19, Line: 109}}, - FirstLine: 1044, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1068}, {PC: 9, Line: 1069}, {PC: 19, Line: 109}}, + FirstLine: 1067, Super: "", }, &bytecode.ISeq{ @@ -3140,8 +3157,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1052}, {PC: 9, Line: 1053}, {PC: 19, Line: 109}}, - FirstLine: 1051, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1075}, {PC: 9, Line: 1076}, {PC: 19, Line: 109}}, + FirstLine: 1074, Super: "", }, &bytecode.ISeq{ @@ -3155,7 +3172,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1061, + FirstLine: 1084, Super: "", }, }, @@ -3171,8 +3188,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1070}, {PC: 4, Line: 1073}}, - FirstLine: 1069, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1093}, {PC: 4, Line: 1096}}, + FirstLine: 1092, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "deconstruct_keys", @@ -3186,7 +3203,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"keys"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1073, + FirstLine: 1096, Super: "", }, }, @@ -3208,8 +3225,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1085}, {PC: 4, Line: 1091}, {PC: 6, Line: 1100}, {PC: 10, Line: 1104}, {PC: 12, Line: 1112}, {PC: 16, Line: 1116}, {PC: 18, Line: 1122}, {PC: 20, Line: 1128}, {PC: 22, Line: 1132}, {PC: 24, Line: 1138}, {PC: 26, Line: 1143}, {PC: 28, Line: 1144}, {PC: 30, Line: 1148}, {PC: 32, Line: 1153}, {PC: 34, Line: 1157}, {PC: 36, Line: 1162}, {PC: 38, Line: 1166}, {PC: 40, Line: 1173}, {PC: 42, Line: 1179}, {PC: 44, Line: 1187}, {PC: 46, Line: 1201}, {PC: 48, Line: 1209}, {PC: 50, Line: 1214}, {PC: 52, Line: 1217}, {PC: 54, Line: 1222}, {PC: 56, Line: 1225}, {PC: 58, Line: 1230}, {PC: 60, Line: 1233}, {PC: 62, Line: 1238}, {PC: 64, Line: 1242}, {PC: 66, Line: 1253}, {PC: 68, Line: 1262}, {PC: 70, Line: 1266}, {PC: 72, Line: 1272}, {PC: 74, Line: 1280}, {PC: 76, Line: 1286}, {PC: 78, Line: 1292}, {PC: 80, Line: 1300}, {PC: 82, Line: 1306}, {PC: 84, Line: 1308}, {PC: 86, Line: 1317}, {PC: 88, Line: 1324}, {PC: 90, Line: 1328}, {PC: 92, Line: 1342}, {PC: 94, Line: 1351}, {PC: 96, Line: 1395}, {PC: 100, Line: 1401}, {PC: 102, Line: 1405}, {PC: 104, Line: 1416}, {PC: 106, Line: 1429}, {PC: 110, Line: 1432}, {PC: 112, Line: 1437}}, - FirstLine: 1084, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1108}, {PC: 4, Line: 1114}, {PC: 6, Line: 1123}, {PC: 10, Line: 1127}, {PC: 12, Line: 1135}, {PC: 16, Line: 1139}, {PC: 18, Line: 1145}, {PC: 20, Line: 1151}, {PC: 22, Line: 1155}, {PC: 24, Line: 1161}, {PC: 26, Line: 1166}, {PC: 28, Line: 1167}, {PC: 30, Line: 1171}, {PC: 32, Line: 1176}, {PC: 34, Line: 1180}, {PC: 36, Line: 1185}, {PC: 38, Line: 1189}, {PC: 40, Line: 1196}, {PC: 42, Line: 1202}, {PC: 44, Line: 1210}, {PC: 46, Line: 1224}, {PC: 48, Line: 1232}, {PC: 50, Line: 1237}, {PC: 52, Line: 1240}, {PC: 54, Line: 1245}, {PC: 56, Line: 1248}, {PC: 58, Line: 1253}, {PC: 60, Line: 1256}, {PC: 62, Line: 1261}, {PC: 64, Line: 1265}, {PC: 66, Line: 1276}, {PC: 68, Line: 1285}, {PC: 70, Line: 1289}, {PC: 72, Line: 1295}, {PC: 74, Line: 1303}, {PC: 76, Line: 1309}, {PC: 78, Line: 1315}, {PC: 80, Line: 1323}, {PC: 82, Line: 1329}, {PC: 84, Line: 1331}, {PC: 86, Line: 1340}, {PC: 88, Line: 1347}, {PC: 90, Line: 1351}, {PC: 92, Line: 1365}, {PC: 94, Line: 1374}, {PC: 96, Line: 1418}, {PC: 100, Line: 1424}, {PC: 102, Line: 1428}, {PC: 104, Line: 1439}, {PC: 106, Line: 1452}, {PC: 110, Line: 1455}, {PC: 112, Line: 1460}}, + FirstLine: 1107, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__do_with_enum", @@ -3228,8 +3245,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1092}, {PC: 4, Line: 1093}, {PC: 12, Line: 1095}, {PC: 16, Line: 1097}}, - FirstLine: 1091, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1115}, {PC: 4, Line: 1116}, {PC: 12, Line: 1118}, {PC: 16, Line: 1120}}, + FirstLine: 1114, Super: "", }, &bytecode.ISeq{ @@ -3244,8 +3261,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"enum", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1104}, {PC: 2, Line: 254}, {PC: 5, Line: 1105}, {PC: 13, Line: 1106}, {PC: 15, Line: 1107}, {PC: 19, Line: 1109}}, - FirstLine: 1104, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1127}, {PC: 2, Line: 259}, {PC: 5, Line: 1128}, {PC: 13, Line: 1129}, {PC: 15, Line: 1130}, {PC: 19, Line: 1132}}, + FirstLine: 1127, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -3259,8 +3276,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1107}}, - FirstLine: 1107, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1130}}, + FirstLine: 1130, Super: "", }, &bytecode.ISeq{ @@ -3275,8 +3292,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1109}}, - FirstLine: 1109, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1132}}, + FirstLine: 1132, Super: "", }, }, @@ -3296,8 +3313,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1117}, {PC: 10, Line: 1118}, {PC: 14, Line: 109}}, - FirstLine: 1116, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1140}, {PC: 10, Line: 1141}, {PC: 14, Line: 109}}, + FirstLine: 1139, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each", @@ -3309,8 +3326,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1117}}, - FirstLine: 1117, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1140}}, + FirstLine: 1140, Super: "", }, }, @@ -3329,8 +3346,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1123}}, - FirstLine: 1122, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1146}}, + FirstLine: 1145, Super: "", }, &bytecode.ISeq{ @@ -3345,8 +3362,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1129}, {PC: 4, Line: 254}}, - FirstLine: 1128, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1152}, {PC: 4, Line: 259}}, + FirstLine: 1151, Super: "", }, &bytecode.ISeq{ @@ -3361,8 +3378,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1133}, {PC: 8, Line: 254}}, - FirstLine: 1132, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1156}, {PC: 8, Line: 259}}, + FirstLine: 1155, Super: "", }, &bytecode.ISeq{ @@ -3377,8 +3394,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1139}, {PC: 4, Line: 1140}, {PC: 8, Line: 1141}}, - FirstLine: 1138, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1162}, {PC: 4, Line: 1163}, {PC: 8, Line: 1164}}, + FirstLine: 1161, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in |", @@ -3392,8 +3409,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1140}}, - FirstLine: 1140, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1163}}, + FirstLine: 1163, Super: "", }, }, @@ -3411,8 +3428,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1150}, {PC: 9, Line: 1151}}, - FirstLine: 1148, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 5, Line: 1173}, {PC: 9, Line: 1174}}, + FirstLine: 1171, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in &", @@ -3426,8 +3443,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1150}}, - FirstLine: 1150, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1173}}, + FirstLine: 1173, Super: "", }, }, @@ -3445,8 +3462,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1158}, {PC: 4, Line: 1159}, {PC: 8, Line: 1160}}, - FirstLine: 1157, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1181}, {PC: 4, Line: 1182}, {PC: 8, Line: 1183}}, + FirstLine: 1180, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in -", @@ -3460,8 +3477,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1159}}, - FirstLine: 1159, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1182}}, + FirstLine: 1182, Super: "", }, }, @@ -3479,8 +3496,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1168}, {PC: 9, Line: 1169}}, - FirstLine: 1166, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1191}, {PC: 9, Line: 1192}}, + FirstLine: 1189, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ^", @@ -3494,8 +3511,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1168}}, - FirstLine: 1168, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1191}}, + FirstLine: 1191, Super: "", }, }, @@ -3513,8 +3530,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enums"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1174}, {PC: 3, Line: 109}}, - FirstLine: 1173, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}, {PC: 3, Line: 109}}, + FirstLine: 1196, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in merge", @@ -3528,8 +3545,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"enum"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1174}}, - FirstLine: 1174, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}}, + FirstLine: 1197, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in merge", @@ -3543,8 +3560,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1174}}, - FirstLine: 1174, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1197}}, + FirstLine: 1197, Super: "", }, }, @@ -3565,8 +3582,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1180}, {PC: 4, Line: 109}}, - FirstLine: 1179, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1203}, {PC: 4, Line: 109}}, + FirstLine: 1202, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subtract", @@ -3580,8 +3597,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1180}}, - FirstLine: 1180, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1203}}, + FirstLine: 1203, Super: "", }, }, @@ -3604,8 +3621,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1188}, {PC: 4, Line: 1189}, {PC: 9, Line: 1190}, {PC: 12, Line: 1192}, {PC: 30, Line: 1193}, {PC: 35, Line: 1194}, {PC: 39, Line: 109}}, - FirstLine: 1187, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1211}, {PC: 4, Line: 1212}, {PC: 9, Line: 1213}, {PC: 12, Line: 1215}, {PC: 30, Line: 1216}, {PC: 35, Line: 1217}, {PC: 39, Line: 109}}, + FirstLine: 1210, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in replace", @@ -3619,8 +3636,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1190}}, - FirstLine: 1190, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1213}}, + FirstLine: 1213, Super: "", }, &bytecode.ISeq{ @@ -3635,8 +3652,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1194}}, - FirstLine: 1194, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1217}}, + FirstLine: 1217, Super: "", }, }, @@ -3653,8 +3670,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1202}, {PC: 4, Line: 1203}, {PC: 9, Line: 1204}, {PC: 12, Line: 109}}, - FirstLine: 1201, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1225}, {PC: 4, Line: 1226}, {PC: 9, Line: 1227}, {PC: 12, Line: 109}}, + FirstLine: 1224, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reset", @@ -3668,8 +3685,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1204}}, - FirstLine: 1204, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1227}}, + FirstLine: 1227, Super: "", }, }, @@ -3690,8 +3707,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1210}, {PC: 12, Line: 1211}, {PC: 23, Line: 1212}}, - FirstLine: 1209, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1233}, {PC: 12, Line: 1234}, {PC: 23, Line: 1235}}, + FirstLine: 1232, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in subset?", @@ -3705,8 +3722,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1212}}, - FirstLine: 1212, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1235}}, + FirstLine: 1235, Super: "", }, }, @@ -3727,8 +3744,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1218}, {PC: 12, Line: 1219}, {PC: 23, Line: 1220}}, - FirstLine: 1217, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1241}, {PC: 12, Line: 1242}, {PC: 23, Line: 1243}}, + FirstLine: 1240, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_subset?", @@ -3742,8 +3759,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1220}}, - FirstLine: 1220, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1243}}, + FirstLine: 1243, Super: "", }, }, @@ -3764,8 +3781,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1226}, {PC: 12, Line: 1227}, {PC: 23, Line: 1228}}, - FirstLine: 1225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1249}, {PC: 12, Line: 1250}, {PC: 23, Line: 1251}}, + FirstLine: 1248, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in superset?", @@ -3779,8 +3796,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1228}}, - FirstLine: 1228, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1251}}, + FirstLine: 1251, Super: "", }, }, @@ -3801,8 +3818,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1234}, {PC: 12, Line: 1235}, {PC: 23, Line: 1236}}, - FirstLine: 1233, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1257}, {PC: 12, Line: 1258}, {PC: 23, Line: 1259}}, + FirstLine: 1256, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in proper_superset?", @@ -3816,8 +3833,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1236}}, - FirstLine: 1236, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1259}}, + FirstLine: 1259, Super: "", }, }, @@ -3840,8 +3857,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1243}, {PC: 5, Line: 254}, {PC: 10, Line: 1244}, {PC: 22, Line: 1245}, {PC: 28, Line: 254}, {PC: 35, Line: 1246}, {PC: 41, Line: 254}, {PC: 43, Line: 109}, {PC: 49, Line: 254}}, - FirstLine: 1242, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1266}, {PC: 5, Line: 259}, {PC: 10, Line: 1267}, {PC: 22, Line: 1268}, {PC: 28, Line: 259}, {PC: 35, Line: 1269}, {PC: 41, Line: 259}, {PC: 43, Line: 109}, {PC: 49, Line: 259}}, + FirstLine: 1265, Super: "", }, &bytecode.ISeq{ @@ -3859,8 +3876,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1254}, {PC: 9, Line: 1255}, {PC: 19, Line: 1256}, {PC: 31, Line: 1257}, {PC: 36, Line: 1259}, {PC: 48, Line: 1260}}, - FirstLine: 1253, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1277}, {PC: 9, Line: 1278}, {PC: 19, Line: 1279}, {PC: 31, Line: 1280}, {PC: 36, Line: 1282}, {PC: 48, Line: 1283}}, + FirstLine: 1276, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ==", @@ -3874,8 +3891,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1260}}, - FirstLine: 1260, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1283}}, + FirstLine: 1283, Super: "", }, }, @@ -3894,8 +3911,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1267}}, - FirstLine: 1266, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1290}}, + FirstLine: 1289, Super: "", }, &bytecode.ISeq{ @@ -3910,8 +3927,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1273}, {PC: 6, Line: 1274}, {PC: 9, Line: 1276}}, - FirstLine: 1272, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1296}, {PC: 6, Line: 1297}, {PC: 9, Line: 1299}}, + FirstLine: 1295, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in disjoint?", @@ -3925,8 +3942,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1274}}, - FirstLine: 1274, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1297}}, + FirstLine: 1297, Super: "", }, &bytecode.ISeq{ @@ -3941,8 +3958,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1276}}, - FirstLine: 1276, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1299}}, + FirstLine: 1299, Super: "", }, }, @@ -3960,8 +3977,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1281}}, - FirstLine: 1280, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1304}}, + FirstLine: 1303, Super: "", }, &bytecode.ISeq{ @@ -3978,8 +3995,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1287}, {PC: 10, Line: 1288}, {PC: 14, Line: 109}}, - FirstLine: 1286, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1310}, {PC: 10, Line: 1311}, {PC: 14, Line: 109}}, + FirstLine: 1309, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in delete_if", @@ -3991,8 +4008,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1287}}, - FirstLine: 1287, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1310}}, + FirstLine: 1310, Super: "", }, &bytecode.ISeq{ @@ -4007,8 +4024,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1288}}, - FirstLine: 1288, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1311}}, + FirstLine: 1311, Super: "", }, }, @@ -4028,8 +4045,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1293}, {PC: 10, Line: 1294}, {PC: 14, Line: 109}}, - FirstLine: 1292, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1316}, {PC: 10, Line: 1317}, {PC: 14, Line: 109}}, + FirstLine: 1315, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in keep_if", @@ -4041,8 +4058,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1293}}, - FirstLine: 1293, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1316}}, + FirstLine: 1316, Super: "", }, &bytecode.ISeq{ @@ -4057,8 +4074,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1294}}, - FirstLine: 1294, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1317}}, + FirstLine: 1317, Super: "", }, }, @@ -4078,8 +4095,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1301}, {PC: 10, Line: 1302}, {PC: 14, Line: 1303}, {PC: 18, Line: 1304}, {PC: 23, Line: 254}, {PC: 25, Line: 109}}, - FirstLine: 1300, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1324}, {PC: 10, Line: 1325}, {PC: 14, Line: 1326}, {PC: 18, Line: 1327}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1323, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in select!", @@ -4091,8 +4108,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1301}}, - FirstLine: 1301, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1324}}, + FirstLine: 1324, Super: "", }, }, @@ -4112,8 +4129,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1309}, {PC: 10, Line: 1310}, {PC: 14, Line: 1311}, {PC: 18, Line: 1312}, {PC: 23, Line: 254}, {PC: 25, Line: 109}}, - FirstLine: 1308, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1332}, {PC: 10, Line: 1333}, {PC: 14, Line: 1334}, {PC: 18, Line: 1335}, {PC: 23, Line: 259}, {PC: 25, Line: 109}}, + FirstLine: 1331, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in reject!", @@ -4125,8 +4142,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1309}}, - FirstLine: 1309, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1332}}, + FirstLine: 1332, Super: "", }, }, @@ -4146,8 +4163,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "vals"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1318}, {PC: 10, Line: 1319}, {PC: 16, Line: 1320}, {PC: 20, Line: 1321}, {PC: 23, Line: 109}}, - FirstLine: 1317, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1341}, {PC: 10, Line: 1342}, {PC: 16, Line: 1343}, {PC: 20, Line: 1344}, {PC: 23, Line: 109}}, + FirstLine: 1340, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in map!", @@ -4159,8 +4176,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1318}}, - FirstLine: 1318, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1341}}, + FirstLine: 1341, Super: "", }, &bytecode.ISeq{ @@ -4175,8 +4192,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1321}}, - FirstLine: 1321, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1344}}, + FirstLine: 1344, Super: "", }, }, @@ -4196,8 +4213,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 2, Locals: []string{"block", "h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1329}, {PC: 10, Line: 1330}, {PC: 13, Line: 1331}, {PC: 16, Line: 1335}}, - FirstLine: 1328, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 10, Line: 1353}, {PC: 13, Line: 1354}, {PC: 16, Line: 1358}}, + FirstLine: 1351, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in classify", @@ -4209,8 +4226,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1329}}, - FirstLine: 1329, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}}, + FirstLine: 1352, Super: "", }, &bytecode.ISeq{ @@ -4225,8 +4242,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"o", "k", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1332}, {PC: 5, Line: 1333}, {PC: 17, Line: 109}}, - FirstLine: 1331, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1355}, {PC: 5, Line: 1356}, {PC: 17, Line: 109}}, + FirstLine: 1354, Super: "", }, }, @@ -4247,8 +4264,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 1, Locals: []string{"func"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1343}, {PC: 10, Line: 1344}, {PC: 15, Line: 1345}, {PC: 19, Line: 109}}, - FirstLine: 1342, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1366}, {PC: 10, Line: 1367}, {PC: 15, Line: 1368}, {PC: 19, Line: 109}}, + FirstLine: 1365, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in divide", @@ -4260,8 +4277,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1343}}, - FirstLine: 1343, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1366}}, + FirstLine: 1366, Super: "", }, }, @@ -4281,8 +4298,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 0, NumLocals: 11, Locals: []string{"func", "items", "n", "adj", "idx", "indices", "low", "onstack", "stack", "comps", "connect"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1352}, {PC: 4, Line: 1353}, {PC: 8, Line: 1354}, {PC: 13, Line: 1355}, {PC: 16, Line: 1360}, {PC: 19, Line: 1361}, {PC: 24, Line: 1362}, {PC: 30, Line: 1363}, {PC: 36, Line: 1364}, {PC: 39, Line: 1365}, {PC: 42, Line: 254}, {PC: 45, Line: 1367}, {PC: 49, Line: 1392}, {PC: 52, Line: 109}}, - FirstLine: 1351, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1375}, {PC: 4, Line: 1376}, {PC: 8, Line: 1377}, {PC: 13, Line: 1378}, {PC: 16, Line: 1383}, {PC: 19, Line: 1384}, {PC: 24, Line: 1385}, {PC: 30, Line: 1386}, {PC: 36, Line: 1387}, {PC: 39, Line: 1388}, {PC: 42, Line: 259}, {PC: 45, Line: 1390}, {PC: 49, Line: 1415}, {PC: 52, Line: 109}}, + FirstLine: 1374, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in __divide_graph", @@ -4293,8 +4310,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1354}}, - FirstLine: 1354, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1377}}, + FirstLine: 1377, Super: "", }, &bytecode.ISeq{ @@ -4309,8 +4326,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"i"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1356}}, - FirstLine: 1355, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1379}}, + FirstLine: 1378, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4324,8 +4341,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"j"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1357}}, - FirstLine: 1356, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1380}}, + FirstLine: 1379, Super: "", }, }, @@ -4346,8 +4363,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"v", "", "", "", "comp"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1368}, {PC: 8, Line: 1369}, {PC: 16, Line: 1370}, {PC: 21, Line: 1371}, {PC: 25, Line: 1372}, {PC: 33, Line: 1373}, {PC: 38, Line: 1381}, {PC: 46, Line: 1382}, {PC: 49, Line: 1383}, {PC: 52, Line: 1389}}, - FirstLine: 1367, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1391}, {PC: 8, Line: 1392}, {PC: 16, Line: 1393}, {PC: 21, Line: 1394}, {PC: 25, Line: 1395}, {PC: 33, Line: 1396}, {PC: 38, Line: 1404}, {PC: 46, Line: 1405}, {PC: 49, Line: 1406}, {PC: 52, Line: 1412}}, + FirstLine: 1390, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in __divide_graph", @@ -4361,8 +4378,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"w", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1374}, {PC: 5, Line: 1375}, {PC: 9, Line: 1376}, {PC: 33, Line: 1378}}, - FirstLine: 1373, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1397}, {PC: 5, Line: 1398}, {PC: 9, Line: 1399}, {PC: 33, Line: 1401}}, + FirstLine: 1396, Super: "", }, &bytecode.ISeq{ @@ -4376,8 +4393,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"w", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1384}, {PC: 4, Line: 1385}, {PC: 12, Line: 1386}, {PC: 18, Line: 1387}}, - FirstLine: 1383, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1407}, {PC: 4, Line: 1408}, {PC: 12, Line: 1409}, {PC: 18, Line: 1410}}, + FirstLine: 1406, Super: "", }, }, @@ -4395,8 +4412,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1392}}, - FirstLine: 1392, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1415}}, + FirstLine: 1415, Super: "", }, &bytecode.ISeq{ @@ -4429,7 +4446,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1401, + FirstLine: 1424, Super: "", }, &bytecode.ISeq{ @@ -4442,8 +4459,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1406}, {PC: 3, Line: 1407}, {PC: 8, Line: 109}, {PC: 10, Line: 254}}, - FirstLine: 1405, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1429}, {PC: 3, Line: 1430}, {PC: 8, Line: 109}, {PC: 10, Line: 259}}, + FirstLine: 1428, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten!", @@ -4457,8 +4474,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"o"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1406}}, - FirstLine: 1406, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1429}}, + FirstLine: 1429, Super: "", }, }, @@ -4476,8 +4493,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"other", "seen"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1416}, {PC: 5, Line: 1417}, {PC: 8, Line: 109}}, - FirstLine: 1416, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1439}, {PC: 5, Line: 1440}, {PC: 8, Line: 109}}, + FirstLine: 1439, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in flatten_merge", @@ -4494,8 +4511,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"o", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1418}, {PC: 4, Line: 1419}, {PC: 16, Line: 1420}, {PC: 25, Line: 1421}, {PC: 30, Line: 1422}, {PC: 35, Line: 1424}}, - FirstLine: 1417, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1441}, {PC: 4, Line: 1442}, {PC: 16, Line: 1443}, {PC: 25, Line: 1444}, {PC: 30, Line: 1445}, {PC: 35, Line: 1447}}, + FirstLine: 1440, Super: "", }, }, @@ -4513,8 +4530,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"sep"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1432}, {PC: 2, Line: 254}, {PC: 5, Line: 1433}}, - FirstLine: 1432, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1455}, {PC: 2, Line: 259}, {PC: 5, Line: 1456}}, + FirstLine: 1455, Super: "", }, &bytecode.ISeq{ @@ -4527,7 +4544,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1437, + FirstLine: 1460, Super: "", }, }, @@ -4543,8 +4560,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1460}, {PC: 2, Line: 1584}, {PC: 4, Line: 1641}, {PC: 6, Line: 1645}, {PC: 8, Line: 1651}, {PC: 10, Line: 1655}}, - FirstLine: 1456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1483}, {PC: 2, Line: 1607}, {PC: 4, Line: 1664}, {PC: 6, Line: 1668}, {PC: 8, Line: 1674}, {PC: 10, Line: 1678}}, + FirstLine: 1479, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -4562,8 +4579,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1461}, {PC: 4, Line: 1463}, {PC: 7, Line: 1464}, {PC: 16, Line: 1468}, {PC: 18, Line: 1473}, {PC: 20, Line: 1483}, {PC: 24, Line: 1485}, {PC: 26, Line: 1493}, {PC: 28, Line: 1497}, {PC: 30, Line: 1503}, {PC: 32, Line: 1510}, {PC: 34, Line: 1514}, {PC: 36, Line: 1523}, {PC: 38, Line: 1531}, {PC: 40, Line: 1551}, {PC: 42, Line: 1557}, {PC: 44, Line: 1561}, {PC: 46, Line: 1565}, {PC: 49, Line: 1569}}, - FirstLine: 1460, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1484}, {PC: 4, Line: 1486}, {PC: 7, Line: 1487}, {PC: 16, Line: 1491}, {PC: 18, Line: 1496}, {PC: 20, Line: 1506}, {PC: 24, Line: 1508}, {PC: 26, Line: 1516}, {PC: 28, Line: 1520}, {PC: 30, Line: 1526}, {PC: 32, Line: 1533}, {PC: 34, Line: 1537}, {PC: 36, Line: 1546}, {PC: 38, Line: 1554}, {PC: 40, Line: 1574}, {PC: 42, Line: 1580}, {PC: 44, Line: 1584}, {PC: 46, Line: 1588}, {PC: 49, Line: 1592}}, + FirstLine: 1483, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "correct?", @@ -4577,8 +4594,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"str"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1469}, {PC: 8, Line: 1470}}, - FirstLine: 1468, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1492}, {PC: 8, Line: 1493}}, + FirstLine: 1491, Super: "", }, &bytecode.ISeq{ @@ -4593,8 +4610,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1474}, {PC: 4, Line: 1475}, {PC: 9, Line: 254}, {PC: 11, Line: 1479}}, - FirstLine: 1473, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1497}, {PC: 4, Line: 1498}, {PC: 9, Line: 259}, {PC: 11, Line: 1502}}, + FirstLine: 1496, Super: "", }, &bytecode.ISeq{ @@ -4617,8 +4634,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1487}, {PC: 22, Line: 1489}, {PC: 30, Line: 1490}}, - FirstLine: 1485, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1510}, {PC: 22, Line: 1512}, {PC: 30, Line: 1513}}, + FirstLine: 1508, Super: "", }, &bytecode.ISeq{ @@ -4631,8 +4648,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1494}}, - FirstLine: 1493, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1517}}, + FirstLine: 1516, Super: "", }, &bytecode.ISeq{ @@ -4651,8 +4668,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1498}, {PC: 4, Line: 109}, {PC: 12, Line: 1498}}, - FirstLine: 1497, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1521}, {PC: 4, Line: 109}, {PC: 12, Line: 1521}}, + FirstLine: 1520, Super: "", }, &bytecode.ISeq{ @@ -4665,8 +4682,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1504}}, - FirstLine: 1503, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1527}}, + FirstLine: 1526, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in segments", @@ -4680,8 +4697,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1505}}, - FirstLine: 1504, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1528}}, + FirstLine: 1527, Super: "", }, }, @@ -4697,8 +4714,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1511}}, - FirstLine: 1510, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1534}}, + FirstLine: 1533, Super: "", }, &bytecode.ISeq{ @@ -4715,8 +4732,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"segs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1515}, {PC: 4, Line: 109}, {PC: 9, Line: 1516}, {PC: 13, Line: 1517}, {PC: 31, Line: 109}}, - FirstLine: 1514, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1538}, {PC: 4, Line: 109}, {PC: 9, Line: 1539}, {PC: 13, Line: 1540}, {PC: 31, Line: 109}}, + FirstLine: 1537, Super: "", }, &bytecode.ISeq{ @@ -4735,8 +4752,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"segs", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1524}, {PC: 5, Line: 1525}, {PC: 23, Line: 1526}, {PC: 33, Line: 1527}, {PC: 45, Line: 109}}, - FirstLine: 1523, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1547}, {PC: 5, Line: 1548}, {PC: 23, Line: 1549}, {PC: 33, Line: 1550}, {PC: 45, Line: 109}}, + FirstLine: 1546, Super: "", }, &bytecode.ISeq{ @@ -4755,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: 1533}, {PC: 9, Line: 254}, {PC: 14, Line: 1534}, {PC: 18, Line: 1535}, {PC: 22, Line: 1536}, {PC: 35, Line: 1537}, {PC: 38, Line: 1538}, {PC: 42, Line: 1539}, {PC: 47, Line: 1540}, {PC: 52, Line: 1542}, {PC: 60, Line: 1543}, {PC: 68, Line: 1544}, {PC: 74, Line: 1545}, {PC: 84, Line: 1546}, {PC: 92, Line: 1548}}, - FirstLine: 1531, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1556}, {PC: 9, Line: 259}, {PC: 14, Line: 1557}, {PC: 18, Line: 1558}, {PC: 22, Line: 1559}, {PC: 35, Line: 1560}, {PC: 38, Line: 1561}, {PC: 42, Line: 1562}, {PC: 47, Line: 1563}, {PC: 52, Line: 1565}, {PC: 60, Line: 1566}, {PC: 68, Line: 1567}, {PC: 74, Line: 1568}, {PC: 84, Line: 1569}, {PC: 92, Line: 1571}}, + FirstLine: 1554, Super: "", }, &bytecode.ISeq{ @@ -4774,8 +4791,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1553}, {PC: 14, Line: 109}}, - FirstLine: 1551, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 6, Line: 1576}, {PC: 14, Line: 109}}, + FirstLine: 1574, Super: "", }, &bytecode.ISeq{ @@ -4790,8 +4807,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1558}}, - FirstLine: 1557, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1581}}, + FirstLine: 1580, Super: "", }, &bytecode.ISeq{ @@ -4804,8 +4821,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1562}}, - FirstLine: 1561, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1585}}, + FirstLine: 1584, Super: "", }, &bytecode.ISeq{ @@ -4824,8 +4841,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"l", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1570}, {PC: 10, Line: 1571}, {PC: 24, Line: 1573}, {PC: 32, Line: 1575}, {PC: 34, Line: 1577}}, - FirstLine: 1569, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1593}, {PC: 10, Line: 1594}, {PC: 24, Line: 1596}, {PC: 32, Line: 1598}, {PC: 34, Line: 1600}}, + FirstLine: 1592, Super: "", }, }, @@ -4853,8 +4870,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1585}, {PC: 24, Line: 1598}, {PC: 34, Line: 1600}, {PC: 36, Line: 1604}, {PC: 38, Line: 1608}, {PC: 42, Line: 1610}, {PC: 44, Line: 1618}, {PC: 46, Line: 1627}, {PC: 48, Line: 1631}, {PC: 50, Line: 1632}, {PC: 52, Line: 1634}}, - FirstLine: 1584, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1608}, {PC: 24, Line: 1621}, {PC: 34, Line: 1623}, {PC: 36, Line: 1627}, {PC: 38, Line: 1631}, {PC: 42, Line: 1633}, {PC: 44, Line: 1641}, {PC: 46, Line: 1650}, {PC: 48, Line: 1654}, {PC: 50, Line: 1655}, {PC: 52, Line: 1657}}, + FirstLine: 1607, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ", @@ -4867,8 +4884,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1586}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1609}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4882,8 +4899,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1587}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1610}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4897,8 +4914,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1588}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1611}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4912,8 +4929,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1589}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1612}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4927,8 +4944,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1590}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1613}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4942,8 +4959,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1591}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1614}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4958,8 +4975,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"v", "r"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1592}}, - FirstLine: 1585, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1615}}, + FirstLine: 1608, Super: "", }, &bytecode.ISeq{ @@ -4974,8 +4991,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"input"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1601}}, - FirstLine: 1600, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1624}}, + FirstLine: 1623, Super: "", }, &bytecode.ISeq{ @@ -4991,8 +5008,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1605}}, - FirstLine: 1604, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1628}}, + FirstLine: 1627, Super: "", }, &bytecode.ISeq{ @@ -5010,8 +5027,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"reqs"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1611}, {PC: 4, Line: 1612}, {PC: 13, Line: 1613}}, - FirstLine: 1610, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1634}, {PC: 4, Line: 1635}, {PC: 13, Line: 1636}}, + FirstLine: 1633, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5026,7 +5043,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"r"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1613, + FirstLine: 1636, Super: "", }, }, @@ -5053,8 +5070,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"obj", "m", "op"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1619}, {PC: 11, Line: 1620}, {PC: 17, Line: 1621}, {PC: 37, Line: 1622}, {PC: 46, Line: 1623}}, - FirstLine: 1618, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1642}, {PC: 11, Line: 1643}, {PC: 17, Line: 1644}, {PC: 37, Line: 1645}, {PC: 46, Line: 1646}}, + FirstLine: 1641, Super: "", }, &bytecode.ISeq{ @@ -5069,8 +5086,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"version"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1628}, {PC: 5, Line: 1629}}, - FirstLine: 1627, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1651}, {PC: 5, Line: 1652}}, + FirstLine: 1650, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in satisfied_by?", @@ -5084,8 +5101,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1629}}, - FirstLine: 1629, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1652}}, + FirstLine: 1652, Super: "", }, }, @@ -5104,8 +5121,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1635}}, - FirstLine: 1634, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, + FirstLine: 1657, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in to_s", @@ -5125,8 +5142,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"op", "req"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1635}}, - FirstLine: 1635, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1658}}, + FirstLine: 1658, Super: "", }, }, @@ -5145,8 +5162,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1642}}, - FirstLine: 1641, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1665}}, + FirstLine: 1664, Super: "", }, &bytecode.ISeq{ @@ -5158,8 +5175,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1646}}, - FirstLine: 1645, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1669}}, + FirstLine: 1668, Super: "", }, &bytecode.ISeq{ @@ -5171,8 +5188,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1651}}, - FirstLine: 1651, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1674}}, + FirstLine: 1674, Super: "", }, &bytecode.ISeq{ @@ -5185,8 +5202,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1656}}, - FirstLine: 1655, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1679}}, + FirstLine: 1678, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "stubs", @@ -5197,8 +5214,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1657}}, - FirstLine: 1656, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1680}}, + FirstLine: 1679, Super: "", }, }, @@ -5217,8 +5234,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1677}, {PC: 2, Line: 1684}, {PC: 4, Line: 1688}, {PC: 6, Line: 1692}, {PC: 8, Line: 1696}, {PC: 10, Line: 1702}, {PC: 12, Line: 1706}, {PC: 14, Line: 1710}, {PC: 16, Line: 1714}, {PC: 18, Line: 1719}, {PC: 20, Line: 1731}, {PC: 22, Line: 1734}, {PC: 24, Line: 1736}, {PC: 26, Line: 1740}, {PC: 28, Line: 1743}}, - FirstLine: 1676, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}, {PC: 2, Line: 1707}, {PC: 4, Line: 1711}, {PC: 6, Line: 1715}, {PC: 8, Line: 1719}, {PC: 10, Line: 1725}, {PC: 12, Line: 1729}, {PC: 14, Line: 1733}, {PC: 16, Line: 1737}, {PC: 18, Line: 1742}, {PC: 20, Line: 1754}, {PC: 22, Line: 1757}, {PC: 24, Line: 1759}, {PC: 26, Line: 1763}, {PC: 28, Line: 1766}}, + FirstLine: 1699, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5232,8 +5249,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"hash"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1677}, {PC: 2, Line: 254}, {PC: 5, Line: 1678}, {PC: 8, Line: 1679}, {PC: 10, Line: 1680}}, - FirstLine: 1677, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1700}, {PC: 2, Line: 259}, {PC: 5, Line: 1701}, {PC: 8, Line: 1702}, {PC: 10, Line: 1703}}, + FirstLine: 1700, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -5247,8 +5264,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1680}}, - FirstLine: 1680, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1703}}, + FirstLine: 1703, Super: "", }, }, @@ -5266,8 +5283,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1685}}, - FirstLine: 1684, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1708}}, + FirstLine: 1707, Super: "", }, &bytecode.ISeq{ @@ -5282,8 +5299,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "value", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1689}}, - FirstLine: 1688, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1712}}, + FirstLine: 1711, Super: "", }, &bytecode.ISeq{ @@ -5296,8 +5313,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1693}}, - FirstLine: 1692, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1716}}, + FirstLine: 1715, Super: "", }, &bytecode.ISeq{ @@ -5313,8 +5330,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1697}, {PC: 10, Line: 1698}, {PC: 13, Line: 109}}, - FirstLine: 1696, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 10, Line: 1721}, {PC: 13, Line: 109}}, + FirstLine: 1719, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_pair", @@ -5327,8 +5344,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1698}}, - FirstLine: 1698, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1721}}, + FirstLine: 1721, Super: "", }, }, @@ -5344,8 +5361,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1703}}, - FirstLine: 1702, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1726}}, + FirstLine: 1725, Super: "", }, &bytecode.ISeq{ @@ -5360,8 +5377,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"names"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1707}}, - FirstLine: 1706, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1730}}, + FirstLine: 1729, Super: "", }, &bytecode.ISeq{ @@ -5376,8 +5393,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"name"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1711}}, - FirstLine: 1710, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1734}}, + FirstLine: 1733, Super: "", }, &bytecode.ISeq{ @@ -5395,8 +5412,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"name", "include_private", "n"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1714}, {PC: 5, Line: 1715}, {PC: 9, Line: 1716}}, - FirstLine: 1714, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1737}, {PC: 5, Line: 1738}, {PC: 9, Line: 1739}}, + FirstLine: 1737, Super: "", }, &bytecode.ISeq{ @@ -5420,8 +5437,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 4, Locals: []string{"name", "args", "n", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1720}, {PC: 4, Line: 1721}, {PC: 8, Line: 1722}, {PC: 31, Line: 1723}, {PC: 49, Line: 1725}, {PC: 53, Line: 1727}}, - FirstLine: 1719, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1743}, {PC: 4, Line: 1744}, {PC: 8, Line: 1745}, {PC: 31, Line: 1746}, {PC: 49, Line: 1748}, {PC: 53, Line: 1750}}, + FirstLine: 1742, Super: "", }, &bytecode.ISeq{ @@ -5436,8 +5453,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1732}, {PC: 9, Line: 254}}, - FirstLine: 1731, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1755}, {PC: 9, Line: 259}}, + FirstLine: 1754, Super: "", }, &bytecode.ISeq{ @@ -5452,8 +5469,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1736}, {PC: 5, Line: 1737}}, - FirstLine: 1736, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1759}, {PC: 5, Line: 1760}}, + FirstLine: 1759, Super: "", }, &bytecode.ISeq{ @@ -5466,8 +5483,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1741}}, - FirstLine: 1740, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1764}}, + FirstLine: 1763, Super: "", }, }, @@ -5483,8 +5500,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1758}, {PC: 2, Line: 1766}, {PC: 4, Line: 1769}, {PC: 6, Line: 1775}}, - FirstLine: 1755, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 2, Line: 1789}, {PC: 4, Line: 1792}, {PC: 6, Line: 1798}}, + FirstLine: 1778, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_delegator", @@ -5498,8 +5515,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1758}, {PC: 5, Line: 1759}, {PC: 9, Line: 1760}, {PC: 13, Line: 1764}}, - FirstLine: 1758, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1781}, {PC: 5, Line: 1782}, {PC: 9, Line: 1783}, {PC: 13, Line: 1787}}, + FirstLine: 1781, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegator", @@ -5513,8 +5530,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1761}, {PC: 1, Line: 109}, {PC: 6, Line: 1762}}, - FirstLine: 1760, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1784}, {PC: 1, Line: 109}, {PC: 6, Line: 1785}}, + FirstLine: 1783, Super: "", }, }, @@ -5532,8 +5549,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1770}}, - FirstLine: 1769, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1793}}, + FirstLine: 1792, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_delegators", @@ -5547,8 +5564,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1770}}, - FirstLine: 1770, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1793}}, + FirstLine: 1793, Super: "", }, }, @@ -5569,8 +5586,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"obj", "accessor"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1776}, {PC: 4, Line: 1777}, {PC: 9, Line: 1779}}, - FirstLine: 1775, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1799}, {PC: 4, Line: 1800}, {PC: 9, Line: 1802}}, + FirstLine: 1798, Super: "", }, }, @@ -5586,8 +5603,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1787}, {PC: 2, Line: 1795}, {PC: 4, Line: 1797}}, - FirstLine: 1786, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 2, Line: 1818}, {PC: 4, Line: 1820}}, + FirstLine: 1809, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "def_single_delegator", @@ -5601,8 +5618,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"accessor", "method", "ali"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1787}, {PC: 5, Line: 1788}, {PC: 9, Line: 1789}, {PC: 13, Line: 1793}}, - FirstLine: 1787, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1810}, {PC: 5, Line: 1811}, {PC: 9, Line: 1812}, {PC: 13, Line: 1816}}, + FirstLine: 1810, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegator", @@ -5616,8 +5633,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 3, Locals: []string{"args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1790}, {PC: 1, Line: 109}, {PC: 6, Line: 1791}}, - FirstLine: 1789, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1813}, {PC: 1, Line: 109}, {PC: 6, Line: 1814}}, + FirstLine: 1812, Super: "", }, }, @@ -5635,8 +5652,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"accessor", "methods"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1798}}, - FirstLine: 1797, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1821}}, + FirstLine: 1820, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in def_single_delegators", @@ -5650,8 +5667,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1798}}, - FirstLine: 1798, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1821}}, + FirstLine: 1821, Super: "", }, }, @@ -5670,8 +5687,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1807}, {PC: 2, Line: 1813}, {PC: 4, Line: 1822}, {PC: 6, Line: 1826}, {PC: 8, Line: 1830}, {PC: 10, Line: 1835}, {PC: 12, Line: 1839}}, - FirstLine: 1806, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1830}, {PC: 2, Line: 1836}, {PC: 4, Line: 1845}, {PC: 6, Line: 1849}, {PC: 8, Line: 1853}, {PC: 10, Line: 1858}, {PC: 12, Line: 1862}}, + FirstLine: 1829, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5685,8 +5702,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1808}}, - FirstLine: 1807, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1831}}, + FirstLine: 1830, Super: "", }, &bytecode.ISeq{ @@ -5701,8 +5718,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 4, Locals: []string{"name", "args", "block", "target"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1814}, {PC: 4, Line: 1815}, {PC: 8, Line: 1816}, {PC: 19, Line: 1818}}, - FirstLine: 1813, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1837}, {PC: 4, Line: 1838}, {PC: 8, Line: 1839}, {PC: 19, Line: 1841}}, + FirstLine: 1836, Super: "", }, &bytecode.ISeq{ @@ -5717,8 +5734,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1822}, {PC: 5, Line: 1823}}, - FirstLine: 1822, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1845}, {PC: 5, Line: 1846}}, + FirstLine: 1845, Super: "", }, &bytecode.ISeq{ @@ -5733,8 +5750,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1826}, {PC: 5, Line: 1827}}, - FirstLine: 1826, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1849}, {PC: 5, Line: 1850}}, + FirstLine: 1849, Super: "", }, &bytecode.ISeq{ @@ -5749,8 +5766,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1831}, {PC: 1, Line: 109}, {PC: 9, Line: 1832}}, - FirstLine: 1830, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1854}, {PC: 1, Line: 109}, {PC: 9, Line: 1855}}, + FirstLine: 1853, Super: "", }, &bytecode.ISeq{ @@ -5768,8 +5785,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1836}, {PC: 6, Line: 109}}, - FirstLine: 1835, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1859}, {PC: 6, Line: 109}}, + FirstLine: 1858, Super: "", }, &bytecode.ISeq{ @@ -5789,8 +5806,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"_obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1840}, {PC: 6, Line: 109}}, - FirstLine: 1839, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}, {PC: 6, Line: 109}}, + FirstLine: 1862, Super: "", }, }, @@ -5806,8 +5823,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1847}, {PC: 2, Line: 1851}}, - FirstLine: 1846, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1870}, {PC: 2, Line: 1874}}, + FirstLine: 1869, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5819,8 +5836,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1848}}, - FirstLine: 1847, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1871}}, + FirstLine: 1870, Super: "", }, &bytecode.ISeq{ @@ -5835,8 +5852,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1852}}, - FirstLine: 1851, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1875}}, + FirstLine: 1874, Super: "", }, }, @@ -5879,8 +5896,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"superclass", "klass", "skip"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1860}, {PC: 5, Line: 1861}, {PC: 8, Line: 1879}, {PC: 34, Line: 1886}, {PC: 38, Line: 1892}}, - FirstLine: 1859, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1883}, {PC: 5, Line: 1884}, {PC: 8, Line: 1902}, {PC: 34, Line: 1909}, {PC: 38, Line: 1915}}, + FirstLine: 1882, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in DelegateClass", @@ -5892,8 +5909,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1862}, {PC: 2, Line: 1866}}, - FirstLine: 1861, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1885}, {PC: 2, Line: 1889}}, + FirstLine: 1884, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "__getobj__", @@ -5905,8 +5922,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1863}}, - FirstLine: 1862, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1886}}, + FirstLine: 1885, Super: "", }, &bytecode.ISeq{ @@ -5921,8 +5938,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"obj"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1867}}, - FirstLine: 1866, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1890}}, + FirstLine: 1889, Super: "", }, }, @@ -5943,8 +5960,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"m"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1887}, {PC: 9, Line: 1888}}, - FirstLine: 1886, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1910}, {PC: 9, Line: 1911}}, + FirstLine: 1909, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in DelegateClass", @@ -5958,8 +5975,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1889}}, - FirstLine: 1888, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1912}}, + FirstLine: 1911, Super: "", }, }, @@ -5981,8 +5998,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1900}, {PC: 4, Line: 1901}, {PC: 7, Line: 1903}, {PC: 9, Line: 1909}, {PC: 11, Line: 1912}, {PC: 13, Line: 1914}, {PC: 15, Line: 1918}, {PC: 17, Line: 1922}, {PC: 19, Line: 1927}, {PC: 21, Line: 1930}, {PC: 23, Line: 1932}, {PC: 25, Line: 1937}, {PC: 27, Line: 1947}, {PC: 29, Line: 1951}, {PC: 31, Line: 1955}, {PC: 33, Line: 1962}, {PC: 35, Line: 1967}, {PC: 37, Line: 1971}, {PC: 39, Line: 1979}, {PC: 41, Line: 1983}, {PC: 43, Line: 1986}, {PC: 45, Line: 1988}, {PC: 47, Line: 1992}, {PC: 49, Line: 1996}, {PC: 51, Line: 2003}, {PC: 53, Line: 2009}, {PC: 55, Line: 2016}, {PC: 57, Line: 2020}, {PC: 59, Line: 2028}, {PC: 61, Line: 2037}, {PC: 63, Line: 2041}, {PC: 65, Line: 2045}, {PC: 67, Line: 2049}, {PC: 69, Line: 2053}, {PC: 71, Line: 2057}, {PC: 73, Line: 2061}}, - FirstLine: 1899, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 4, Line: 1924}, {PC: 7, Line: 1926}, {PC: 9, Line: 1932}, {PC: 11, Line: 1935}, {PC: 13, Line: 1937}, {PC: 15, Line: 1941}, {PC: 17, Line: 1945}, {PC: 19, Line: 1950}, {PC: 21, Line: 1953}, {PC: 23, Line: 1955}, {PC: 25, Line: 1960}, {PC: 27, Line: 1970}, {PC: 29, Line: 1974}, {PC: 31, Line: 1978}, {PC: 33, Line: 1985}, {PC: 35, Line: 1990}, {PC: 37, Line: 1994}, {PC: 39, Line: 2002}, {PC: 41, Line: 2006}, {PC: 43, Line: 2009}, {PC: 45, Line: 2011}, {PC: 47, Line: 2015}, {PC: 49, Line: 2019}, {PC: 51, Line: 2026}, {PC: 53, Line: 2032}, {PC: 55, Line: 2039}, {PC: 57, Line: 2043}, {PC: 59, Line: 2051}, {PC: 61, Line: 2060}, {PC: 63, Line: 2064}, {PC: 65, Line: 2068}, {PC: 67, Line: 2072}, {PC: 69, Line: 2076}, {PC: 71, Line: 2080}, {PC: 73, Line: 2084}}, + FirstLine: 1922, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -5999,8 +6016,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"path"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1904}, {PC: 10, Line: 1905}, {PC: 22, Line: 1906}}, - FirstLine: 1903, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1927}, {PC: 10, Line: 1928}, {PC: 22, Line: 1929}}, + FirstLine: 1926, Super: "", }, &bytecode.ISeq{ @@ -6013,8 +6030,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1910}}, - FirstLine: 1909, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}}, + FirstLine: 1932, Super: "", }, &bytecode.ISeq{ @@ -6032,8 +6049,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1915}}, - FirstLine: 1914, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1938}}, + FirstLine: 1937, Super: "", }, &bytecode.ISeq{ @@ -6046,8 +6063,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1919}}, - FirstLine: 1918, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1942}}, + FirstLine: 1941, Super: "", }, &bytecode.ISeq{ @@ -6060,8 +6077,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1923}, {PC: 3, Line: 1924}}, - FirstLine: 1922, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1946}, {PC: 3, Line: 1947}}, + FirstLine: 1945, Super: "", }, &bytecode.ISeq{ @@ -6076,8 +6093,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1928}}, - FirstLine: 1927, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1951}}, + FirstLine: 1950, Super: "", }, &bytecode.ISeq{ @@ -6092,8 +6109,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1933}, {PC: 5, Line: 254}, {PC: 10, Line: 1934}}, - FirstLine: 1932, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1956}, {PC: 5, Line: 259}, {PC: 10, Line: 1957}}, + FirstLine: 1955, Super: "", }, &bytecode.ISeq{ @@ -6106,8 +6123,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1938}}, - FirstLine: 1937, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1961}}, + FirstLine: 1960, Super: "", }, &bytecode.ISeq{ @@ -6120,8 +6137,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1948}}, - FirstLine: 1947, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1971}}, + FirstLine: 1970, Super: "", }, &bytecode.ISeq{ @@ -6134,8 +6151,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1952}}, - FirstLine: 1951, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1975}}, + FirstLine: 1974, Super: "", }, &bytecode.ISeq{ @@ -6148,8 +6165,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1956}}, - FirstLine: 1955, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1979}}, + FirstLine: 1978, Super: "", }, &bytecode.ISeq{ @@ -6164,8 +6181,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"other"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1963}, {PC: 12, Line: 1964}}, - FirstLine: 1962, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1986}, {PC: 12, Line: 1987}}, + FirstLine: 1985, Super: "", }, &bytecode.ISeq{ @@ -6180,7 +6197,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 1967, + FirstLine: 1990, Super: "", }, &bytecode.ISeq{ @@ -6195,8 +6212,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "result"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 1973}, {PC: 6, Line: 1974}}, - FirstLine: 1971, + Lines: []bytecode.LineEntry{{PC: 0, Line: 109}, {PC: 3, Line: 1996}, {PC: 6, Line: 1997}}, + FirstLine: 1994, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in join", @@ -6209,8 +6226,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"a"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1973}}, - FirstLine: 1973, + Lines: []bytecode.LineEntry{{PC: 0, Line: 1996}}, + FirstLine: 1996, Super: "", }, }, @@ -6231,8 +6248,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"suffix"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1979}, {PC: 5, Line: 1980}}, - FirstLine: 1979, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2002}, {PC: 5, Line: 2003}}, + FirstLine: 2002, Super: "", }, &bytecode.ISeq{ @@ -6245,8 +6262,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1984}}, - FirstLine: 1983, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2007}}, + FirstLine: 2006, Super: "", }, &bytecode.ISeq{ @@ -6259,8 +6276,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: 2012}}, + FirstLine: 2011, Super: "", }, &bytecode.ISeq{ @@ -6273,8 +6290,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1993}}, - FirstLine: 1992, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2016}}, + FirstLine: 2015, Super: "", }, &bytecode.ISeq{ @@ -6290,8 +6307,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1997}, {PC: 10, Line: 1998}}, - FirstLine: 1996, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2020}, {PC: 10, Line: 2021}}, + FirstLine: 2019, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in each_filename", @@ -6304,8 +6321,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"f"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 1998}}, - FirstLine: 1998, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2021}}, + FirstLine: 2021, Super: "", }, }, @@ -6324,8 +6341,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2004}, {PC: 10, Line: 2005}, {PC: 15, Line: 109}}, - FirstLine: 2003, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2027}, {PC: 10, Line: 2028}, {PC: 15, Line: 109}}, + FirstLine: 2026, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in ascend", @@ -6339,8 +6356,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2005}}, - FirstLine: 2005, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2028}}, + FirstLine: 2028, Super: "", }, }, @@ -6359,8 +6376,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2010}, {PC: 10, Line: 2011}, {PC: 15, Line: 109}}, - FirstLine: 2009, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2033}, {PC: 10, Line: 2034}, {PC: 15, Line: 109}}, + FirstLine: 2032, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in descend", @@ -6374,8 +6391,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"p"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2011}}, - FirstLine: 2011, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2034}}, + FirstLine: 2034, Super: "", }, }, @@ -6391,8 +6408,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2017}}, - FirstLine: 2016, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2040}}, + FirstLine: 2039, Super: "", }, &bytecode.ISeq{ @@ -6407,8 +6424,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"repl"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2021}}, - FirstLine: 2020, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2044}}, + FirstLine: 2043, Super: "", }, &bytecode.ISeq{ @@ -6423,8 +6440,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"base_directory"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2029}, {PC: 12, Line: 2030}}, - FirstLine: 2028, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2052}, {PC: 12, Line: 2053}}, + FirstLine: 2051, Super: "", }, &bytecode.ISeq{ @@ -6439,8 +6456,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2038}}, - FirstLine: 2037, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2061}}, + FirstLine: 2060, Super: "", }, &bytecode.ISeq{ @@ -6455,8 +6472,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"content", "args", "opts"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2042}}, - FirstLine: 2041, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2065}}, + FirstLine: 2064, Super: "", }, &bytecode.ISeq{ @@ -6471,8 +6488,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2046}}, - FirstLine: 2045, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2069}}, + FirstLine: 2068, Super: "", }, &bytecode.ISeq{ @@ -6485,8 +6502,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2050}}, - FirstLine: 2049, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2073}}, + FirstLine: 2072, Super: "", }, &bytecode.ISeq{ @@ -6499,8 +6516,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2054}}, - FirstLine: 2053, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2077}}, + FirstLine: 2076, Super: "", }, &bytecode.ISeq{ @@ -6513,8 +6530,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2058}}, - FirstLine: 2057, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2081}}, + FirstLine: 2080, Super: "", }, &bytecode.ISeq{ @@ -6529,8 +6546,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2062}}, - FirstLine: 2061, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2085}}, + FirstLine: 2084, Super: "", }, }, @@ -6546,8 +6563,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2072}, {PC: 2, Line: 2083}}, - FirstLine: 2070, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2095}, {PC: 2, Line: 2106}}, + FirstLine: 2093, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6559,8 +6576,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2075}}, - FirstLine: 2072, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2098}}, + FirstLine: 2095, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "instance", @@ -6572,8 +6589,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2076}}, - FirstLine: 2075, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2099}}, + FirstLine: 2098, Super: "", }, }, @@ -6595,8 +6612,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"klass"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2084}, {PC: 4, Line: 2085}}, - FirstLine: 2083, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2107}, {PC: 4, Line: 2108}}, + FirstLine: 2106, Super: "", }, }, @@ -6618,8 +6635,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2108}, {PC: 5, Line: 2109}, {PC: 10, Line: 2115}, {PC: 12, Line: 2128}, {PC: 14, Line: 2135}, {PC: 16, Line: 2144}, {PC: 18, Line: 2148}, {PC: 21, Line: 2152}}, - FirstLine: 2106, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2131}, {PC: 5, Line: 2132}, {PC: 10, Line: 2138}, {PC: 12, Line: 2151}, {PC: 14, Line: 2158}, {PC: 16, Line: 2167}, {PC: 18, Line: 2171}, {PC: 21, Line: 2175}}, + FirstLine: 2129, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6640,8 +6657,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"str", "trim_mode", "eoutvar"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2115}, {PC: 2, Line: 254}, {PC: 13, Line: 2117}, {PC: 16, Line: 2118}, {PC: 19, Line: 2122}}, - FirstLine: 2115, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2138}, {PC: 2, Line: 259}, {PC: 13, Line: 2140}, {PC: 16, Line: 2141}, {PC: 19, Line: 2145}}, + FirstLine: 2138, Super: "", }, &bytecode.ISeq{ @@ -6659,8 +6676,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2128}, {PC: 6, Line: 2129}}, - FirstLine: 2128, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2151}, {PC: 6, Line: 2152}}, + FirstLine: 2151, Super: "", }, &bytecode.ISeq{ @@ -6675,8 +6692,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"hash", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2136}, {PC: 4, Line: 2137}, {PC: 7, Line: 2140}}, - FirstLine: 2135, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2159}, {PC: 4, Line: 2160}, {PC: 7, Line: 2163}}, + FirstLine: 2158, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in result_with_hash", @@ -6690,8 +6707,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"key", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2138}}, - FirstLine: 2137, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2161}}, + FirstLine: 2160, Super: "", }, }, @@ -6709,8 +6726,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2144}, {PC: 6, Line: 2145}}, - FirstLine: 2144, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2167}, {PC: 6, Line: 2168}}, + FirstLine: 2167, Super: "", }, &bytecode.ISeq{ @@ -6722,8 +6739,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: 2176}}, + FirstLine: 2175, Super: "", }, }, @@ -6731,16 +6748,16 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 9}, {Op: 33, A: 1}, {Op: 41, A: 2}, {Op: 53}}, - Names: []string{"Helpers", "Template", "Engine"}, + Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 42, A: 1, B: 1}, {Op: 53}}, + Names: []string{"Helpers", "Template"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2171}, {PC: 2, Line: 2240}, {PC: 4, Line: 2261}}, - FirstLine: 2170, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2194}, {PC: 2, Line: 2263}}, + FirstLine: 2193, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6752,8 +6769,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2174}, {PC: 2, Line: 2181}, {PC: 4, Line: 2188}, {PC: 6, Line: 2197}, {PC: 8, Line: 2210}}, - FirstLine: 2171, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2197}, {PC: 2, Line: 2204}, {PC: 4, Line: 2211}, {PC: 6, Line: 2220}, {PC: 8, Line: 2233}}, + FirstLine: 2194, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -6768,8 +6785,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2175}, {PC: 4, Line: 2176}}, - FirstLine: 2174, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2198}, {PC: 4, Line: 2199}}, + FirstLine: 2197, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -6783,8 +6800,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2177}}, - FirstLine: 2176, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2200}}, + FirstLine: 2199, Super: "", }, }, @@ -6802,8 +6819,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2182}}, - FirstLine: 2181, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2205}}, + FirstLine: 2204, Super: "", }, &bytecode.ISeq{ @@ -6830,8 +6847,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2189}}, - FirstLine: 2188, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2212}}, + FirstLine: 2211, Super: "", }, &bytecode.ISeq{ @@ -6860,8 +6877,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "value"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2198}, {PC: 14, Line: 2199}, {PC: 22, Line: 1}, {PC: 32, Line: 2200}, {PC: 40, Line: 1}, {PC: 57, Line: 2202}, {PC: 61, Line: 1}}, - FirstLine: 2197, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2221}, {PC: 14, Line: 2222}, {PC: 22, Line: 1}, {PC: 32, Line: 2223}, {PC: 40, Line: 1}, {PC: 57, Line: 2225}, {PC: 61, Line: 1}}, + FirstLine: 2220, Super: "", }, &bytecode.ISeq{ @@ -6879,8 +6896,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"base", "splats", "merged", "add", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2211}, {PC: 3, Line: 2212}, {PC: 7, Line: 2224}, {PC: 10, Line: 2225}, {PC: 13, Line: 2227}, {PC: 16, Line: 2228}, {PC: 21, Line: 2231}}, - FirstLine: 2210, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2234}, {PC: 3, Line: 2235}, {PC: 7, Line: 2247}, {PC: 10, Line: 2248}, {PC: 13, Line: 2250}, {PC: 16, Line: 2251}, {PC: 21, Line: 2254}}, + FirstLine: 2233, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render_attributes", @@ -6903,8 +6920,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "val", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2213}, {PC: 4, Line: 2214}, {PC: 8, Line: 2215}, {PC: 13, Line: 2216}, {PC: 24, Line: 2217}, {PC: 42, Line: 2219}, {PC: 50, Line: 2221}}, - FirstLine: 2212, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2236}, {PC: 4, Line: 2237}, {PC: 8, Line: 2238}, {PC: 13, Line: 2239}, {PC: 24, Line: 2240}, {PC: 42, Line: 2242}, {PC: 50, Line: 2244}}, + FirstLine: 2235, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6920,8 +6937,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"x"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2217}}, - FirstLine: 2217, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2240}}, + FirstLine: 2240, Super: "", }, }, @@ -6939,8 +6956,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2224}}, - FirstLine: 2224, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2247}}, + FirstLine: 2247, Super: "", }, &bytecode.ISeq{ @@ -6955,8 +6972,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"h"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2225}}, - FirstLine: 2225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2248}}, + FirstLine: 2248, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render_attributes", @@ -6970,8 +6987,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2225}}, - FirstLine: 2225, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2248}}, + FirstLine: 2248, Super: "", }, }, @@ -6989,8 +7006,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"k"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2229}}, - FirstLine: 2228, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2252}}, + FirstLine: 2251, Super: "", }, }, @@ -7012,8 +7029,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2241}, {PC: 4, Line: 2245}, {PC: 6, Line: 2254}}, - FirstLine: 2240, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2264}, {PC: 4, Line: 2268}, {PC: 6, Line: 2277}}, + FirstLine: 2263, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7027,8 +7044,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2245}, {PC: 2, Line: 254}, {PC: 5, Line: 2246}, {PC: 18, Line: 2247}}, - FirstLine: 2245, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2268}, {PC: 2, Line: 259}, {PC: 5, Line: 2269}, {PC: 18, Line: 2270}}, + FirstLine: 2268, Super: "", }, &bytecode.ISeq{ @@ -7047,8 +7064,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2254}, {PC: 11, Line: 2255}, {PC: 14, Line: 2256}, {PC: 17, Line: 2257}}, - FirstLine: 2254, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2277}, {PC: 11, Line: 2278}, {PC: 14, Line: 2279}, {PC: 17, Line: 2280}}, + FirstLine: 2277, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7062,8 +7079,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2256}}, - FirstLine: 2256, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2279}}, + FirstLine: 2279, Super: "", }, }, @@ -7077,16 +7094,16 @@ func embeddedPrelude() *bytecode.ISeq { }, &bytecode.ISeq{ Name: "", - Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 9}, {Op: 33, A: 2}, {Op: 41, A: 3}, {Op: 53}}, - Names: []string{"Util", "HamlAttributes", "Template", "Engine"}, + Insns: []bytecode.Instr{{Op: 43}, {Op: 9}, {Op: 43, A: 1, B: 1}, {Op: 9}, {Op: 42, A: 2, B: 2}, {Op: 53}}, + Names: []string{"Util", "HamlAttributes", "Template"}, NumRequired: 0, SplatIndex: -1, PostCount: 0, KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2274}, {PC: 2, Line: 2287}, {PC: 4, Line: 2327}, {PC: 6, Line: 2347}}, - FirstLine: 2273, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2302}, {PC: 2, Line: 2315}, {PC: 4, Line: 2355}}, + FirstLine: 2301, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7098,8 +7115,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2277}}, - FirstLine: 2274, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2305}}, + FirstLine: 2302, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "escape_html", @@ -7125,8 +7142,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"s"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2278}}, - FirstLine: 2277, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2306}}, + FirstLine: 2305, Super: "", }, }, @@ -7162,8 +7179,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2288}, {PC: 22, Line: 2292}}, - FirstLine: 2287, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2316}, {PC: 22, Line: 2320}}, + FirstLine: 2315, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "render", @@ -7180,8 +7197,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"h", "pairs", "out"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2293}, {PC: 3, Line: 2294}, {PC: 6, Line: 2309}, {PC: 9, Line: 2310}, {PC: 14, Line: 2320}}, - FirstLine: 2292, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2321}, {PC: 3, Line: 2322}, {PC: 6, Line: 2337}, {PC: 9, Line: 2338}, {PC: 14, Line: 2348}}, + FirstLine: 2320, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7207,8 +7224,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 7, Locals: []string{"k", "v", "existing", "merged", "", "", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2295}, {PC: 4, Line: 2296}, {PC: 14, Line: 2297}, {PC: 21, Line: 2299}, {PC: 26, Line: 2300}, {PC: 42, Line: 2301}, {PC: 54, Line: 2303}, {PC: 59, Line: 2304}, {PC: 72, Line: 2306}}, - FirstLine: 2294, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2323}, {PC: 4, Line: 2324}, {PC: 14, Line: 2325}, {PC: 21, Line: 2327}, {PC: 26, Line: 2328}, {PC: 42, Line: 2329}, {PC: 54, Line: 2331}, {PC: 59, Line: 2332}, {PC: 72, Line: 2334}}, + FirstLine: 2322, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block (2 levels) in render", @@ -7227,8 +7244,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"dk", "dv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2297}}, - FirstLine: 2297, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2325}}, + FirstLine: 2325, Super: "", }, }, @@ -7255,8 +7272,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2311}, {PC: 5, Line: 2312}, {PC: 9, Line: 2313}, {PC: 32, Line: 2315}, {PC: 40, Line: 2317}, {PC: 45, Line: 1}}, - FirstLine: 2310, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2339}, {PC: 5, Line: 2340}, {PC: 9, Line: 2341}, {PC: 32, Line: 2343}, {PC: 40, Line: 2345}, {PC: 45, Line: 1}}, + FirstLine: 2338, Super: "", }, }, @@ -7278,8 +7295,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2328}, {PC: 4, Line: 2332}, {PC: 6, Line: 2340}}, - FirstLine: 2327, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2356}, {PC: 4, Line: 2360}, {PC: 6, Line: 2368}}, + FirstLine: 2355, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7293,8 +7310,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"template", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2332}, {PC: 2, Line: 254}, {PC: 5, Line: 2333}, {PC: 18, Line: 2334}}, - FirstLine: 2332, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2360}, {PC: 2, Line: 259}, {PC: 5, Line: 2361}, {PC: 18, Line: 2362}}, + FirstLine: 2360, Super: "", }, &bytecode.ISeq{ @@ -7313,8 +7330,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"_scope", "locals", "b"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2340}, {PC: 11, Line: 2341}, {PC: 14, Line: 2342}, {PC: 17, Line: 2343}}, - FirstLine: 2340, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2368}, {PC: 11, Line: 2369}, {PC: 14, Line: 2370}, {PC: 17, Line: 2371}}, + FirstLine: 2368, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in render", @@ -7328,8 +7345,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"k", "v"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2342}}, - FirstLine: 2342, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2370}}, + FirstLine: 2370, Super: "", }, }, @@ -7362,8 +7379,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2373}, {PC: 2, Line: 2394}, {PC: 4, Line: 2397}, {PC: 6, Line: 2400}, {PC: 8, Line: 2403}, {PC: 10, Line: 2406}, {PC: 12, Line: 2409}, {PC: 14, Line: 2413}}, - FirstLine: 2372, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2402}, {PC: 2, Line: 2423}, {PC: 4, Line: 2426}, {PC: 6, Line: 2429}, {PC: 8, Line: 2432}, {PC: 10, Line: 2435}, {PC: 12, Line: 2438}, {PC: 14, Line: 2442}}, + FirstLine: 2401, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7378,8 +7395,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2374}, {PC: 4, Line: 2375}, {PC: 6, Line: 2382}, {PC: 8, Line: 2383}, {PC: 10, Line: 2384}, {PC: 12, Line: 2387}, {PC: 14, Line: 2388}}, - FirstLine: 2373, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2403}, {PC: 4, Line: 2404}, {PC: 6, Line: 2411}, {PC: 8, Line: 2412}, {PC: 10, Line: 2413}, {PC: 12, Line: 2416}, {PC: 14, Line: 2417}}, + FirstLine: 2402, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "initialize", @@ -7397,8 +7414,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"args"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2376}, {PC: 3, Line: 2380}}, - FirstLine: 2375, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2405}, {PC: 3, Line: 2409}}, + FirstLine: 2404, Super: "", }, &bytecode.ISeq{ @@ -7413,8 +7430,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2382}}, - FirstLine: 2382, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2411}}, + FirstLine: 2411, Super: "", }, &bytecode.ISeq{ @@ -7428,7 +7445,7 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 0, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2383, + FirstLine: 2412, Super: "", }, &bytecode.ISeq{ @@ -7445,8 +7462,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2385}}, - FirstLine: 2384, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2414}}, + FirstLine: 2413, Super: "", }, &bytecode.ISeq{ @@ -7464,8 +7481,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"argv", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2389}, {PC: 9, Line: 2390}}, - FirstLine: 2388, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2418}, {PC: 9, Line: 2419}}, + FirstLine: 2417, Super: "", }, }, @@ -7481,8 +7498,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2395}}, - FirstLine: 2394, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2424}}, + FirstLine: 2423, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7496,8 +7513,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2395}}, - FirstLine: 2395, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2424}}, + FirstLine: 2424, Super: "", }, }, @@ -7513,8 +7530,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2398}}, - FirstLine: 2397, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2427}}, + FirstLine: 2426, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7528,8 +7545,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2398}}, - FirstLine: 2398, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2427}}, + FirstLine: 2427, Super: "", }, }, @@ -7545,8 +7562,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2401}}, - FirstLine: 2400, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}}, + FirstLine: 2429, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7560,8 +7577,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2401}}, - FirstLine: 2401, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2430}}, + FirstLine: 2430, Super: "", }, }, @@ -7577,8 +7594,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2404}}, - FirstLine: 2403, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2433}}, + FirstLine: 2432, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7592,8 +7609,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2404}}, - FirstLine: 2404, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2433}}, + FirstLine: 2433, Super: "", }, }, @@ -7609,8 +7626,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2407}}, - FirstLine: 2406, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2436}}, + FirstLine: 2435, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7624,8 +7641,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2407}}, - FirstLine: 2407, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2436}}, + FirstLine: 2436, Super: "", }, }, @@ -7641,8 +7658,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2410}}, - FirstLine: 2409, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2439}}, + FirstLine: 2438, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "reason", @@ -7656,8 +7673,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2410}}, - FirstLine: 2410, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2439}}, + FirstLine: 2439, Super: "", }, }, @@ -7679,8 +7696,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2428}, {PC: 4, Line: 2430}, {PC: 6, Line: 2451}, {PC: 8, Line: 2482}, {PC: 10, Line: 2488}, {PC: 12, Line: 2497}, {PC: 14, Line: 2512}, {PC: 16, Line: 2519}, {PC: 18, Line: 2523}, {PC: 20, Line: 2530}, {PC: 22, Line: 2532}, {PC: 24, Line: 2536}, {PC: 26, Line: 2540}}, - FirstLine: 2427, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2458}, {PC: 4, Line: 2460}, {PC: 6, Line: 2481}, {PC: 8, Line: 2512}, {PC: 10, Line: 2518}, {PC: 12, Line: 2527}, {PC: 14, Line: 2542}, {PC: 16, Line: 2549}, {PC: 18, Line: 2553}, {PC: 20, Line: 2560}, {PC: 22, Line: 2562}, {PC: 24, Line: 2566}, {PC: 26, Line: 2570}}, + FirstLine: 2457, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "counter", @@ -7696,8 +7713,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2431}}, - FirstLine: 2430, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2461}}, + FirstLine: 2460, Super: "", }, &bytecode.ISeq{ @@ -7723,8 +7740,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: 2451}, {PC: 7, Line: 254}, {PC: 15, Line: 2452}, {PC: 19, Line: 2453}, {PC: 36, Line: 2454}, {PC: 44, Line: 254}, {PC: 47, Line: 2456}, {PC: 50, Line: 2464}, {PC: 62, Line: 2465}, {PC: 65, Line: 2466}, {PC: 68, Line: 2467}, {PC: 76, Line: 2468}, {PC: 92, Line: 2469}, {PC: 94, Line: 2470}, {PC: 95, Line: 109}, {PC: 98, Line: 2473}, {PC: 101, Line: 2474}, {PC: 105, Line: 2473}, {PC: 108, Line: 2474}}, - FirstLine: 2451, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2481}, {PC: 7, Line: 259}, {PC: 15, Line: 2482}, {PC: 19, Line: 2483}, {PC: 36, Line: 2484}, {PC: 44, Line: 259}, {PC: 47, Line: 2486}, {PC: 50, Line: 2494}, {PC: 62, Line: 2495}, {PC: 65, Line: 2496}, {PC: 68, Line: 2497}, {PC: 76, Line: 2498}, {PC: 92, Line: 2499}, {PC: 94, Line: 2500}, {PC: 95, Line: 109}, {PC: 98, Line: 2503}, {PC: 101, Line: 2504}, {PC: 105, Line: 2503}, {PC: 108, Line: 2504}}, + FirstLine: 2481, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in initialize", @@ -7748,8 +7765,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "candidate"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2457}, {PC: 42, Line: 2458}, {PC: 48, Line: 2459}, {PC: 53, Line: 2460}, {PC: 56, Line: 2461}}, - FirstLine: 2456, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2487}, {PC: 42, Line: 2488}, {PC: 48, Line: 2489}, {PC: 53, Line: 2490}, {PC: 56, Line: 2491}}, + FirstLine: 2486, Super: "", }, &bytecode.ISeq{ @@ -7767,8 +7784,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2466}}, - FirstLine: 2466, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2496}}, + FirstLine: 2496, Super: "", }, }, @@ -7787,8 +7804,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2483}, {PC: 16, Line: 2484}, {PC: 19, Line: 2485}}, - FirstLine: 2482, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2513}, {PC: 16, Line: 2514}, {PC: 19, Line: 2515}}, + FirstLine: 2512, Super: "", }, &bytecode.ISeq{ @@ -7803,8 +7820,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 1, NumLocals: 2, Locals: []string{"args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2489}}, - FirstLine: 2488, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2519}}, + FirstLine: 2518, Super: "", }, &bytecode.ISeq{ @@ -7822,8 +7839,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 5, Locals: []string{"basename", "tmpdir", "opts", "fwd", "t"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2497}, {PC: 7, Line: 254}, {PC: 10, Line: 2498}, {PC: 13, Line: 2499}, {PC: 16, Line: 2500}, {PC: 32, Line: 2501}, {PC: 34, Line: 2502}, {PC: 35, Line: 2503}, {PC: 39, Line: 2505}, {PC: 42, Line: 2506}, {PC: 46, Line: 2505}, {PC: 49, Line: 2506}, {PC: 56, Line: 2509}}, - FirstLine: 2497, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2527}, {PC: 7, Line: 259}, {PC: 10, Line: 2528}, {PC: 13, Line: 2529}, {PC: 16, Line: 2530}, {PC: 32, Line: 2531}, {PC: 34, Line: 2532}, {PC: 35, Line: 2533}, {PC: 39, Line: 2535}, {PC: 42, Line: 2536}, {PC: 46, Line: 2535}, {PC: 49, Line: 2536}, {PC: 56, Line: 2539}}, + FirstLine: 2527, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "block in create", @@ -7840,8 +7857,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"k", "v", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2499}}, - FirstLine: 2499, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2529}}, + FirstLine: 2529, Super: "", }, }, @@ -7859,8 +7876,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"unlink_now"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2512}, {PC: 5, Line: 2513}, {PC: 17, Line: 2514}, {PC: 20, Line: 2515}, {PC: 27, Line: 254}}, - FirstLine: 2512, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2542}, {PC: 5, Line: 2543}, {PC: 17, Line: 2544}, {PC: 20, Line: 2545}, {PC: 27, Line: 259}}, + FirstLine: 2542, Super: "", }, &bytecode.ISeq{ @@ -7873,8 +7890,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2520}}, - FirstLine: 2519, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2550}}, + FirstLine: 2549, Super: "", }, &bytecode.ISeq{ @@ -7887,8 +7904,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2524}, {PC: 8, Line: 2525}, {PC: 14, Line: 254}}, - FirstLine: 2523, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2554}, {PC: 8, Line: 2555}, {PC: 14, Line: 259}}, + FirstLine: 2553, Super: "", }, &bytecode.ISeq{ @@ -7906,8 +7923,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"mode"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2533}}, - FirstLine: 2532, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2563}}, + FirstLine: 2562, Super: "", }, &bytecode.ISeq{ @@ -7922,8 +7939,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"name", "include_private"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2536}, {PC: 5, Line: 2537}}, - FirstLine: 2536, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2566}, {PC: 5, Line: 2567}}, + FirstLine: 2566, Super: "", }, &bytecode.ISeq{ @@ -7938,8 +7955,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: 2, NumLocals: 3, Locals: []string{"name", "args", "block"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2541}, {PC: 8, Line: 2542}, {PC: 19, Line: 2544}}, - FirstLine: 2540, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2571}, {PC: 8, Line: 2572}, {PC: 19, Line: 2574}}, + FirstLine: 2570, Super: "", }, }, @@ -7961,8 +7978,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2553}, {PC: 11, Line: 109}, {PC: 14, Line: 2593}, {PC: 16, Line: 2597}, {PC: 17, Line: 109}}, - FirstLine: 2552, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2583}, {PC: 11, Line: 109}, {PC: 14, Line: 2623}, {PC: 16, Line: 2627}, {PC: 17, Line: 109}}, + FirstLine: 2582, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "", @@ -7974,8 +7991,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2563}, {PC: 2, Line: 2575}, {PC: 4, Line: 2586}}, - FirstLine: 2560, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2593}, {PC: 2, Line: 2605}, {PC: 4, Line: 2616}}, + FirstLine: 2590, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "[]", @@ -7997,8 +8014,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 1, Locals: []string{"category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2564}, {PC: 5, Line: 2565}, {PC: 22, Line: 2567}, {PC: 27, Line: 2568}, {PC: 43, Line: 2570}}, - FirstLine: 2563, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2594}, {PC: 5, Line: 2595}, {PC: 22, Line: 2597}, {PC: 27, Line: 2598}, {PC: 43, Line: 2600}}, + FirstLine: 2593, Super: "", }, &bytecode.ISeq{ @@ -8021,8 +8038,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 3, Locals: []string{"category", "flag", ""}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2576}, {PC: 5, Line: 2577}, {PC: 22, Line: 2579}, {PC: 27, Line: 2580}, {PC: 43, Line: 2582}}, - FirstLine: 2575, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2606}, {PC: 5, Line: 2607}, {PC: 22, Line: 2609}, {PC: 27, Line: 2610}, {PC: 43, Line: 2612}}, + FirstLine: 2605, Super: "", }, &bytecode.ISeq{ @@ -8035,8 +8052,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2587}}, - FirstLine: 2586, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2617}}, + FirstLine: 2616, Super: "", }, }, @@ -8056,8 +8073,8 @@ func embeddedPrelude() *bytecode.ISeq { BlockSlot: -1, NumLocals: 2, Locals: []string{"message", "category"}, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2593}, {PC: 2, Line: 254}, {PC: 5, Line: 2594}, {PC: 9, Line: 254}}, - FirstLine: 2593, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2623}, {PC: 2, Line: 259}, {PC: 5, Line: 2624}, {PC: 9, Line: 259}}, + FirstLine: 2623, Super: "", }, }, @@ -8073,8 +8090,8 @@ func embeddedPrelude() *bytecode.ISeq { KwRestSlot: -1, BlockSlot: -1, NumLocals: 0, - Lines: []bytecode.LineEntry{{PC: 0, Line: 2611}}, - FirstLine: 2610, + Lines: []bytecode.LineEntry{{PC: 0, Line: 2641}}, + FirstLine: 2640, Children: []*bytecode.ISeq{ &bytecode.ISeq{ Name: "!~", @@ -8089,7 +8106,7 @@ func embeddedPrelude() *bytecode.ISeq { NumLocals: 1, Locals: []string{"other"}, Lines: []bytecode.LineEntry{{PC: 0, Line: 109}}, - FirstLine: 2611, + FirstLine: 2641, Super: "", }, }, diff --git a/internal/vm/refinement_import.go b/internal/vm/refinement_import.go index 419a8743..ba163ca0 100644 --- a/internal/vm/refinement_import.go +++ b/internal/vm/refinement_import.go @@ -90,7 +90,7 @@ func refinementImportMethods(vm *VM, self object.Value, args []object.Value, _ * } for _, mod := range mods { if len(mod.includes) > 0 || len(mod.prepends) > 0 { - vm.rbWarn("warning: %s has ancestors, but Refinement#import_methods doesn't import their methods", + vm.rbWarnf("%s has ancestors, but Refinement#import_methods doesn't import their methods", vm.moduleToSStr(mod)) } } diff --git a/internal/vm/regexp.go b/internal/vm/regexp.go index 79f89b85..e01a57bb 100644 --- a/internal/vm/regexp.go +++ b/internal/vm/regexp.go @@ -1026,7 +1026,13 @@ func (vm *VM) regexpOptionFlags(v object.Value) string { // Any other object is the legacy form: MRI warns (verbose) "expected true // or false as ignorecase: " without calling #to_int. A non-nil, // non-false object is always truthy, so it selects IGNORECASE. - vm.rbWarn("warning: expected true or false as ignorecase: %s", vm.inspectStr(v)) + // object.c ruby_4_0:3493 rb_bool_expected warns through rb_warning, not + // rb_warn, so a DEFAULT $VERBOSE stays silent. Measured on MRI 4.0.5: + // `ruby -e 'Regexp.new("a", Object.new)'` prints nothing, while + // `ruby -e '$VERBOSE=true; Regexp.new("a", Object.new)'` prints + // "-e:1: warning: expected true or false as ignorecase: #". + // This was rb_warn here, which only looked right while the gate was broken. + vm.rbWarningf("expected true or false as ignorecase: %s", vm.inspectStr(v)) return "i" } } @@ -1237,7 +1243,7 @@ func (vm *VM) checkSubjectEncoding(re *Regexp, v object.Value) { return } if re.noEnc && strEnc != "ASCII-8BIT" && !sevenBit { - vm.rbWarn("warning: historical binary regexp match /.../n against %s string", strEnc) + vm.rbWarnf("historical binary regexp match /.../n against %s string", strEnc) } } diff --git a/internal/vm/require.go b/internal/vm/require.go index 2363531e..3a63c832 100644 --- a/internal/vm/require.go +++ b/internal/vm/require.go @@ -373,13 +373,13 @@ func (vm *VM) requireLoadingKey(abs string) string { // warnCircularRequire emits MRI's circular-require warning. load_lock issues it // through rb_warning, not rb_warn, so it appears only in verbose mode ($VERBOSE // true) -- `require_internal(ec, fname, 1, RTEST(ruby_verbose))` passes the -// verbose flag down as load_lock's `warn` argument. It goes to the current -// $stderr so a reassigned $stderr (mspec's `complain` matcher) captures it. +// verbose flag down as load_lock's `warn` argument. It reaches $stderr the way +// every internal warning does — through Warning.warn, whose default body writes +// there — so mspec's `complain` matcher captures it whether it replaced $stderr or +// Warning.warn. The gate was reading vm.globals["$VERBOSE"] out of the map, which +// is unset until a program assigns it. func (vm *VM) warnCircularRequire(path string) { - if v, ok := vm.globals["$VERBOSE"].(object.Bool); !ok || !bool(v) { - return - } - vm.curStderr().writeStr("warning: loading in progress, circular require considered harmful - " + path + "\n") + vm.rbWarning("loading in progress, circular require considered harmful - " + path) } // setISeqFile stamps path onto iseq and all of its nested children, so a method diff --git a/internal/vm/struct.go b/internal/vm/struct.go index 3dc8770d..15d09afa 100644 --- a/internal/vm/struct.go +++ b/internal/vm/struct.go @@ -132,7 +132,7 @@ func setupStruct(vm *VM) { raise("NameError", "identifier %s needs to be constant", name) } if _, exists := base.consts[name]; exists { - vm.warnRedefineConst(base, name) + vm.warnStructRedefineConst(base, name) } vm.assignConstIn(base, name, sub) } @@ -808,8 +808,18 @@ func validConstName(s string) bool { return true } -// warnRedefineConst emits MRI's "already initialized constant" warning to -// $stderr when Struct.new(name, …) overwrites an existing constant. -func (vm *VM) warnRedefineConst(scope *RClass, name string) { - vm.send(vm.main, "warn", []object.Value{object.NewString("warning: already initialized constant " + scopedNameFor(scope, name))}, nil) +// warnStructRedefineConst is struct.c's new_struct (ruby/ruby v3_4_0 struct.c:273) +// — the ONE place in MRI that warns about a constant being taken over with a +// different message and no companion line: +// +// rb_warn("redefining constant %"PRIsVALUE"::%"PRIsVALUE, super, name); +// +// It is rb_warn, so it carries the file:lineno prefix and obeys $VERBOSE the same +// way; it is NOT const_tbl_update's "already initialized constant …", because +// new_struct removes the old constant itself (rb_mod_remove_const) before defining +// the new one, so rb_const_set never sees a live entry to complain about. Measured +// against MRI 4.0.5: `Struct.new("Dup1", :a); Struct.new("Dup1", :b)` prints +// "-e:1: warning: redefining constant Struct::Dup1". +func (vm *VM) warnStructRedefineConst(scope *RClass, name string) { + vm.rbWarnf("redefining constant %s::%s", vm.moduleToSStr(scope), name) } diff --git a/internal/vm/struct_conformance_test.go b/internal/vm/struct_conformance_test.go index 967cbce4..f4498480 100644 --- a/internal/vm/struct_conformance_test.go +++ b/internal/vm/struct_conformance_test.go @@ -232,11 +232,18 @@ func TestStructConformanceErrors(t *testing.T) { } // TestStructNamedRedefineWarns checks that Struct.new(name, …) overwriting an -// existing constant emits the "already initialized constant" warning (to $stderr, -// which the harness folds into the captured stream) and rebinds the constant. +// existing constant warns and rebinds the constant. The wording is struct.c's own +// (ruby_4_0 struct.c new_struct: rb_warn("redefining constant %s::%s")), NOT +// const_tbl_update's "already initialized constant …", because new_struct removes +// the old constant before defining the new one. Measured on MRI 4.0.5: +// +// $ ruby -e 'Struct.new("Dup1", :a); Struct.new("Dup1", :b)' +// -e:1: warning: redefining constant Struct::Dup1 +// +// This assertion used to name the other message, pinning rbgo's divergence. func TestStructNamedRedefineWarns(t *testing.T) { out := eval(t, `Struct.new("Dup1", :a); Struct.new("Dup1", :b); p Struct::Dup1.members`) - if !strings.Contains(out, "already initialized constant Struct::Dup1") { + if !strings.Contains(out, "warning: redefining constant Struct::Dup1") { t.Errorf("out=%q, want redefine warning", out) } if !strings.Contains(out, "[:b]") { diff --git a/internal/vm/verbose_gate_wave45_test.go b/internal/vm/verbose_gate_wave45_test.go new file mode 100644 index 00000000..f8c77648 --- /dev/null +++ b/internal/vm/verbose_gate_wave45_test.go @@ -0,0 +1,300 @@ +// Copyright (c) the go-embedded-ruby/ruby authors +// +// SPDX-License-Identifier: BSD-3-Clause + +package vm + +import ( + "bytes" + "strings" + "testing" + + "github.com/go-embedded-ruby/ruby/internal/compiler" + "github.com/go-embedded-ruby/ruby/internal/object" + "github.com/go-ruby-parser/parser" +) + +// warnProbeFile is the path runWarn stamps onto its ISeq. It has to be stamped: +// a warning's position comes from the frame's ISeq, and so does the location +// recordConstLoc stores for the "previous definition" line. A path-less ISeq — +// which is what compiling a bare source string gives — records no location at +// all, so the second line is correctly suppressed and the case cannot witness +// it. Stamping a path is what `rbgo script.rb` and `rbgo -e` both do. +const warnProbeFile = "wt45probe.rb" + +// runWarn compiles and runs src in one VM and returns everything it wrote, +// newlines and all — warnings are the SUBJECT here, so nothing is trimmed and +// nothing is filtered. +func runWarn(t *testing.T, src string) string { + t.Helper() + prog, err := parser.Parse(src) + if err != nil { + t.Fatalf("parse: %v", err) + } + iseq, err := compiler.Compile(prog) + if err != nil { + t.Fatalf("compile: %v", err) + } + setISeqFile(iseq, warnProbeFile) + var buf bytes.Buffer + vm := New(&buf) + vm.SetScriptPath(warnProbeFile) + if _, err := vm.Run(iseq); err != nil { + t.Fatalf("run: %v", err) + } + return buf.String() +} + +// $VERBOSE has three states and the two warning families split on them. This is +// a WITNESS for the defect in #641: the UNSET rows. A fresh VM assigns $VERBOSE +// nothing, MRI reads false there, and rb_warn must therefore speak. The gate used +// to read vm.globals["$VERBOSE"] straight out of the map, where an unset slot is a +// Go nil that object.IsNil accepts, so the unset rows were silent while the +// $VERBOSE = false rows were not — one value with two representations, and the +// gate read the one nobody writes. +// +// Verified against MRI 4.0.5: `ruby -e 'X=1; X=2'` warns, `ruby -W0 -e …` does +// not, and `ruby -e 'p [1,2].inject(0, :+) { }'` warns only under -w. +func TestVerboseGateThreeStates(t *testing.T) { + cases := []struct { + name string + prologue string + wantWarn bool // rb_warn family (already initialized constant) + wantWarning bool // rb_warning family (Array.new with a block and no args) + }{ + {"unset — MRI's default, reads false", "", true, false}, + {"$VERBOSE = false", "$VERBOSE = false\n", true, false}, + {"$VERBOSE = nil (-W0)", "$VERBOSE = nil\n", false, false}, + {"$VERBOSE = true (-w)", "$VERBOSE = true\n", true, true}, + {"$VERBOSE = 1 coerces to true", "$VERBOSE = 1\n", true, true}, + } + for _, c := range cases { + gotWarn := strings.Contains(runWarn(t, c.prologue+"X = 1\nX = 2\n"), "already initialized constant X") + if gotWarn != c.wantWarn { + t.Errorf("%s: rb_warn fired=%v, want %v", c.name, gotWarn, c.wantWarn) + } + gotWarning := strings.Contains(runWarn(t, c.prologue+"Array.new { :blk }\n"), "given block not used") + if gotWarning != c.wantWarning { + t.Errorf("%s: rb_warning fired=%v, want %v", c.name, gotWarning, c.wantWarning) + } + } +} + +// A redefined constant emits TWO lines, each with its own source position, and +// the second one names the constant WITHOUT its module qualification. All four +// expectations are MRI 4.0.5's, taken from `ruby -e` runs: +// +// -e:1: warning: already initialized constant MM::K +// -e:1: warning: previous definition of K was here +// +// WITNESS for all three parts of #699 at once: the prefix, the second line, and +// the gate that let neither be seen. Against the old code every row fails. +func TestConstantRedefinitionEmitsBothLinesWithPositions(t *testing.T) { + cases := []struct{ name, src, want string }{ + {"top level", "X = 1\nX = 2\n", + "wt45probe.rb:2: warning: already initialized constant X\n" + + "wt45probe.rb:1: warning: previous definition of X was here\n"}, + {"qualified by the module, second line bare", "module MM\n K = 1\n K = 2\nend\n", + "wt45probe.rb:3: warning: already initialized constant MM::K\n" + + "wt45probe.rb:2: warning: previous definition of K was here\n"}, + {"scoped assignment", "module MM\nend\nMM::K = 1\nMM::K = 2\n", + "wt45probe.rb:4: warning: already initialized constant MM::K\n" + + "wt45probe.rb:3: warning: previous definition of K was here\n"}, + {"Module#const_set takes the same path", "Object.const_set(:Q, 1)\nObject.const_set(:Q, 2)\n", + "wt45probe.rb:2: warning: already initialized constant Q\n" + + "wt45probe.rb:1: warning: previous definition of Q was here\n"}, + {"$VERBOSE = nil silences both", "$VERBOSE = nil\nX = 1\nX = 2\n", ""}, + } + for _, c := range cases { + if got := runWarn(t, c.src); got != c.want { + t.Errorf("%s:\n got %q\nwant %q", c.name, got, c.want) + } + } +} + +// The second line's position is the OLD entry's, so a constant first defined in +// one place and overwritten in another produces two DIFFERENT positions. The +// in-process harness compiles one ISeq, so the two lines share a path here and +// the LINES are what differ; the cross-file case is the same code with a +// different recorded file, which constLocs already stores per constant. +// +// This also pins that the location is read BEFORE the store: recordConstLoc +// stamps the new site during the assignment, so reading it afterwards would +// report line 2 twice. +func TestPreviousDefinitionPointsAtTheOriginalSite(t *testing.T) { + got := runWarn(t, "Z = 1\n\n\n\nZ = 2\n") + want := "wt45probe.rb:5: warning: already initialized constant Z\n" + + "wt45probe.rb:1: warning: previous definition of Z was here\n" + if got != want { + t.Fatalf("got %q, want %q", got, want) + } +} + +// A constant this VM defined natively has no recorded location, and MRI's +// `if (!NIL_P(ce->file) && ce->line)` means the first line goes out ALONE. Object +// is full of such constants; ARGV is one. +func TestNativeConstantRedefinitionHasNoSecondLine(t *testing.T) { + got := runWarn(t, "ARGV = []\n") + if !strings.Contains(got, "already initialized constant ARGV") { + t.Fatalf("got %q, want the already-initialized line", got) + } + if strings.Contains(got, "previous definition") { + t.Fatalf("got %q, want NO second line for a natively defined constant", got) + } +} + +// warningStringAt is err_vcatf's shape (error.c:125). The single caller today — +// warnAlreadyInitialized — filters both degenerate shapes out at the call site, +// exactly as MRI's `if (!NIL_P(ce->file) && ce->line)` does, so these two rows are +// NOT reachable through it. This is a GUARD, not a witness: it pins the shape +// err_vcatf gives the next caller that does not filter, and it is why the branches +// exist at all rather than being asserted away. +func TestWarningStringAtShapes(t *testing.T) { + cases := []struct { + file string + line int + want string + }{ + {"a.rb", 7, "a.rb:7: warning: m\n"}, + {"a.rb", 0, "a.rb: warning: m\n"}, // err_vcatf: `if (line)` guards the ":%d" + {"", 7, "warning: m\n"}, // err_vcatf: `if (file)` guards the whole location + } + for _, c := range cases { + if got := warningStringAt(c.file, c.line, "m"); got != c.want { + t.Errorf("warningStringAt(%q, %d): got %q, want %q", c.file, c.line, got, c.want) + } + } +} + +// Struct.new(name, …) is the ONE place MRI words this differently: struct.c:273 +// warns "redefining constant Struct::Foo", with no companion line, because +// new_struct removes the old constant itself before defining the new one. +// Measured against MRI 4.0.5: +// +// $ ruby -e 'Struct.new("Dup1", :a); Struct.new("Dup1", :b)' +// -e:1: warning: redefining constant Struct::Dup1 +// +// WITNESS: the old code wrote "already initialized constant Struct::Dup1" through +// Kernel#warn, with no prefix and no $VERBOSE gate, and a test asserted that text +// — pinning our own divergence. +func TestStructNamedRedefineUsesStructsOwnWording(t *testing.T) { + got := runWarn(t, "Struct.new(\"Dup1\", :a)\nStruct.new(\"Dup1\", :b)\n") + want := "wt45probe.rb:2: warning: redefining constant Struct::Dup1\n" + if got != want { + t.Fatalf("got %q, want %q", got, want) + } + if out := runWarn(t, "$VERBOSE = nil\nStruct.new(\"Dup2\", :a)\nStruct.new(\"Dup2\", :b)\n"); out != "" { + t.Fatalf("$VERBOSE = nil must silence it too: got %q", out) + } +} + +// "given block not used" reaches every method MRI warns from, and only those. +// enum.c and array.c use rb_warn for the value/pattern forms of count, index, +// find_index, any?, all?, none? and one?, and rb_warning for Array#initialize +// with no arguments and for inject's two-argument arm. Every row was measured on +// MRI 4.0.5. +// +// WITNESS for the helper inconsistency: before this wave six of these were silent +// at the default verbosity because rbgo did not emit them at all, and the one +// helper that required $VERBOSE == true was chosen per call site rather than per +// MRI function. +func TestGivenBlockNotUsedMatchesMRIPerMethod(t *testing.T) { + const enumClass = "class WCE\n include Enumerable\n def each; yield 1; yield 2; end\nend\n" + cases := []struct { + name string + src string + wantWarn bool // at the DEFAULT verbosity + wantUnder bool // under $VERBOSE = true + }{ + {"Array#count(item) with a block", "[1, 2].count(1) { |x| x }\n", true, true}, + {"Array#count with a block alone", "[1, 2].count { |x| x }\n", false, false}, + {"Array#any?(pattern) with a block", "[1, 2].any?(Integer) { |x| x }\n", true, true}, + {"Array#all?(pattern) with a block", "[1, 2].all?(Integer) { |x| x }\n", true, true}, + {"Array#none?(pattern) with a block", "[1, 2].none?(Integer) { |x| x }\n", true, true}, + {"Array#one?(pattern) with a block", "[1, 2].one?(Integer) { |x| x }\n", true, true}, + {"Array#any? with a block alone", "[1, 2].any? { |x| x }\n", false, false}, + {"Array#index(value) with a block", "[1].index(1) { }\n", true, true}, + {"Array#rindex(value) with a block", "[1].rindex(1) { }\n", true, true}, + {"Array#find_index(value) with a block", "[1].find_index(1) { }\n", true, true}, + {"Hash#any?(pattern) with a block", "{ a: 1 }.any?(Array) { |x| x }\n", true, true}, + {"Enumerable#count(item) with a block", enumClass + "WCE.new.count(1) { |x| x }\n", true, true}, + {"Enumerable#find_index(value) with a block", enumClass + "WCE.new.find_index(1) { |x| x }\n", true, true}, + {"Enumerable#one?(pattern) with a block", enumClass + "WCE.new.one?(Integer) { |x| x }\n", true, true}, + // rb_warning, not rb_warn: the default verbosity stays quiet. + {"Array.new with no arguments and a block", "Array.new { :blk }\n", false, true}, + {"Enumerable#inject(init, op) with a block", enumClass + "WCE.new.inject(0, :+) { |a, b| a }\n", false, true}, + {"Enumerable#inject(init) with a block is the ordinary form", enumClass + "WCE.new.inject(0) { |a, b| a + b }\n", false, false}, + } + for _, c := range cases { + got := strings.Contains(runWarn(t, c.src), "given block not used") + if got != c.wantWarn { + t.Errorf("%s at the default $VERBOSE: warned=%v, want %v", c.name, got, c.wantWarn) + } + gotV := strings.Contains(runWarn(t, "$VERBOSE = true\n"+c.src), "given block not used") + if gotV != c.wantUnder { + t.Errorf("%s under $VERBOSE = true: warned=%v, want %v", c.name, gotV, c.wantUnder) + } + } +} + +// Every one of these lines carries the position of the frame that CALLED the +// warning method, not of the prelude or of the native helper — error.c composes +// it from rb_source_location, which is the current Ruby frame. +func TestGivenBlockNotUsedCarriesTheCallersPosition(t *testing.T) { + got := runWarn(t, "\n\n[1, 2].count(1) { |x| x }\n") + want := "wt45probe.rb:3: warning: given block not used\n" + if got != want { + t.Fatalf("got %q, want %q", got, want) + } +} + +// error.c's rb_write_warning_str is `rb_funcallv(Warning, :warn, str)`, so an +// overridden Warning.warn sees every internal warning. #699's own eight-line probe +// counted 3 on MRI 4.0.5 and 0 on rbgo; all three arrive here now — and none of them +// reaches the real stderr. Measured byte-for-byte against MRI 4.0.5 on the same +// file: `ruby /tmp/wt45probe.rb` and `rbgo /tmp/wt45probe.rb` now print the same +// four lines. +func TestOverriddenWarningWarnInterceptsInternalWarnings(t *testing.T) { + got := runWarn(t, `$seen = [] +module Warning + def self.warn(msg, category: nil); $seen << msg; end +end +[1, 2].fetch(5, 1) { |i| i } +BAR = 1 +BAR = 2 +print "intercepted=", $seen.length, "\n" +print $seen.join("") +`) + const want = `intercepted=3 +wt45probe.rb:5: warning: block supersedes default value argument +wt45probe.rb:7: warning: already initialized constant BAR +wt45probe.rb:6: warning: previous definition of BAR was here +` + if got != want { + t.Fatalf("got %q, want %q", got, want) + } +} + +// warnEnabled / warningEnabled are the only two gates, so they are also the only +// two places where an ASSIGNED $VERBOSE and an unset one can disagree. They may +// not: a fresh VM must answer exactly as one that was handed MRI's default. +func TestWarnGatesAgreeBetweenUnsetAndExplicitFalse(t *testing.T) { + var buf bytes.Buffer + unset := New(&buf) + explicit := New(&buf) + explicit.globals["$VERBOSE"] = object.False + if unset.warnEnabled() != explicit.warnEnabled() { + t.Errorf("warnEnabled: unset=%v explicit false=%v — one value, two answers", + unset.warnEnabled(), explicit.warnEnabled()) + } + if unset.warningEnabled() != explicit.warningEnabled() { + t.Errorf("warningEnabled: unset=%v explicit false=%v", + unset.warningEnabled(), explicit.warningEnabled()) + } + if !unset.warnEnabled() { + t.Error("an unset $VERBOSE must enable rb_warn — MRI starts it at false") + } + if unset.warningEnabled() { + t.Error("an unset $VERBOSE must NOT enable rb_warning — that needs true") + } +} diff --git a/internal/vm/vm.go b/internal/vm/vm.go index 04c73b12..04b8af69 100644 --- a/internal/vm/vm.go +++ b/internal/vm/vm.go @@ -2955,16 +2955,33 @@ func (vm *VM) constTable(parent *RClass) map[string]object.Value { return parent.consts } -// warnAlreadyInitialized emits MRI's "already initialized constant" warning when -// a syntactic constant assignment overwrites a value already in scope's own -// table. variable.c's const_tbl_update (ruby/ruby v3_4_0:3658) warns through -// rb_warn — so `$VERBOSE = nil` silences it, which is what ruby/spec's -// suppress_warning relies on — and qualifies the name with the module unless -// that module is Object. (struct.go's warnRedefineConst writes the same text -// through Kernel#warn, which `$VERBOSE = nil` does not silence; the syntactic -// assignment needs rb_warn's behaviour, hence the separate helper. MRI also -// prefixes file:line and follows with "previous definition ... was here"; rbgo -// carries no source map yet, so neither is emitted, as elsewhere in this VM.) +// warnAlreadyInitialized is variable.c's const_tbl_update redefinition arm +// (ruby/ruby v3_4_0 variable.c:3694-3706) in full. It warns when a constant +// assignment overwrites a value already in scope's own table, and MRI emits TWO +// lines there, not one: +// +// -e:1: warning: already initialized constant X +// -e:1: warning: previous definition of X was here +// +// The first goes through rb_warn — so `$VERBOSE = nil` silences it, which is what +// ruby/spec's suppress_warning relies on — and qualifies the name with the module +// unless that module is Object. The second goes through rb_compile_warn with the +// OLD entry's own ce->file / ce->line, so it points at the original definition and +// not at the line doing the overwriting; when the two live in different files the +// two lines carry different paths, which is measurable and is measured. Its name +// is the BARE one (QUOTE_ID(id)), unqualified even when the first line is +// qualified: MRI prints "already initialized constant MM::K" and then "previous +// definition of K was here". +// +// MRI guards the second line with `if (!NIL_P(ce->file) && ce->line)`, so a +// constant this VM defined natively — no Ruby frame, hence no recorded location — +// gets the first line alone, exactly as in MRI. +// +// Both constant-assignment opcodes and Module#const_set come here; they went +// through two helpers with two different behaviours before. Struct.new's named +// form is the one genuine exception — struct.c:273 warns "redefining constant +// Struct::Foo" instead, and with no second line — and it says so at its own call +// site. func (vm *VM) warnAlreadyInitialized(scope *RClass, name string) { if scope == nil { scope = vm.cObject @@ -2976,7 +2993,13 @@ func (vm *VM) warnAlreadyInitialized(scope *RClass, name string) { // rb_class_name(klass) for every scope but Object, and an ANONYMOUS module // renders as its "#" path there rather than dropping out of the // message ("already initialized constant #::TEST"). - vm.rbWarn("warning: already initialized constant %s", vm.constPathUnder(scope, name)) + vm.rbWarnf("already initialized constant %s", vm.constPathUnder(scope, name)) + // The location must be read BEFORE the assignment that follows overwrites it + // (recordConstLoc stamps the new site), which is why this helper runs ahead of + // the store rather than beside it. + if loc, ok := scope.constLocs[name]; ok && loc.file != "" && loc.line != 0 { + vm.rbCompileWarn(loc.file, loc.line, "previous definition of "+name+" was here") + } } // assignConst sets a bare constant assignment (`NAME = value`) into the current diff --git a/internal/vm/wave24_lang_test.go b/internal/vm/wave24_lang_test.go index 762fe2de..f353786a 100644 --- a/internal/vm/wave24_lang_test.go +++ b/internal/vm/wave24_lang_test.go @@ -166,15 +166,28 @@ p ::TOPC // Reassigning an already-initialized constant warns, qualified by the module // unless that module is Object, and `$VERBOSE = nil` silences it — MRI's -// rb_warn behaviour. (rbgo leaves $VERBOSE unset, where MRI starts it at false, -// so these set it explicitly to reach the warning at all.) +// rb_warn behaviour. MRI emits TWO lines, both carrying a position: the +// "already initialized" one at the overwriting site and "previous definition of +// X was here" at the original. Measured on MRI 4.0.5: +// +// $ ruby -e 'A = 1; A = 2' +// -e:1: warning: already initialized constant A +// -e:1: warning: previous definition of A was here +// +// These rows used to assert a bare "warning: …", which was rbgo's own divergence; +// the $VERBOSE = false prologue is kept only so the silenced row below still +// contrasts with them. They show ONE line, not two, because runSrcEnc compiles a +// path-less ISeq: recordConstLoc stores nothing without a file, and MRI's +// `if (!NIL_P(ce->file) && ce->line)` then suppresses the second line — the same +// reason a natively defined constant gets one line. The two-line form is measured +// against MRI in verbose_gate_wave45_test.go, which stamps a path. func TestAlreadyInitializedConstantWarning(t *testing.T) { checkSrc(t, "toplevel constant", "$VERBOSE = false\nX = 1\nX = 2\np X\n", - "warning: already initialized constant X\n2") + "(rbgo):3: warning: already initialized constant X\n2") checkSrc(t, "qualified constant", "$VERBOSE = false\nmodule M; end\nM::Y = 1\nM::Y = 2\np M::Y\n", - "warning: already initialized constant M::Y\n2") + "(rbgo):4: warning: already initialized constant M::Y\n2") checkSrc(t, "inside a class body", "$VERBOSE = false\nclass K; Z = 1; Z = 2; end\np K::Z\n", - "warning: already initialized constant K::Z\n2") + "(rbgo):2: warning: already initialized constant K::Z\n2") checkSrc(t, "silenced by $VERBOSE = nil", "$VERBOSE = nil\nX = 1\nX = 2\np X\n", "2") checkSrc(t, "a first assignment does not warn", "$VERBOSE = false\nmodule M; end\nM::Q = 1\np M::Q\n", "1") } @@ -301,6 +314,9 @@ func TestWarnAlreadyInitializedNilScope(t *testing.T) { vm.globals["$VERBOSE"] = object.False vm.cObject.consts["WAIN_TEST_CONST"] = object.IntValue(1) vm.warnAlreadyInitialized(nil, "WAIN_TEST_CONST") + // No frame is on the stack (the helper is called directly), so warnUplevelPrefix + // falls back to the bare "warning: " — err_vcatf's `if (file)` arm — and there is + // no recorded location either, so no second line. if got := buf.String(); got != "warning: already initialized constant WAIN_TEST_CONST\n" { t.Fatalf("nil scope: got %q", got) } diff --git a/internal/vm/wave28_file_fd_open_test.go b/internal/vm/wave28_file_fd_open_test.go index af61592a..bf5043ef 100644 --- a/internal/vm/wave28_file_fd_open_test.go +++ b/internal/vm/wave28_file_fd_open_test.go @@ -85,7 +85,7 @@ func TestWave28FileNewWarnsOnBlock(t *testing.T) { dir := fdOpenScratch(t) src := "Dir.chdir(" + rubyString(dir) + ")\n$VERBOSE = true\n" + "$stderr = $stdout\nFile.new(\"f.txt\") { |f| 1 }\n" - const want = "warning: File::new() does not take block; use File::open() instead\n" + const want = "(rbgo):4: warning: File::new() does not take block; use File::open() instead\n" if got := eval(t, src); got != want { t.Errorf("got=%q\nwant=%q", got, want) } diff --git a/internal/vm/wave28_modreg_internal_test.go b/internal/vm/wave28_modreg_internal_test.go index 176a67ab..da089143 100644 --- a/internal/vm/wave28_modreg_internal_test.go +++ b/internal/vm/wave28_modreg_internal_test.go @@ -406,7 +406,7 @@ func TestRefinementImportMethods(t *testing.T) { M1 = Module.new M2 = Module.new { include M1 } R = Module.new { refine(String) { import_methods M2 } } - p :done`, "warning: M2 has ancestors, but Refinement#import_methods doesn't import their methods\n:done\n"}, + p :done`, "(rbgo):5: warning: M2 has ancestors, but Refinement#import_methods doesn't import their methods\n:done\n"}, {"undefined_entries_are_skipped", ` su = Module.new do def gone; end @@ -724,7 +724,7 @@ func TestRegexpPrepareEncoding(t *testing.T) { {"historical_binary_warning", ` $VERBOSE = true p(/a/n =~ "\xC3\xA9".dup.force_encoding("UTF-8"))`, - "warning: historical binary regexp match /.../n against UTF-8 string\nnil\n"}, + "(rbgo):3: warning: historical binary regexp match /.../n against UTF-8 string\nnil\n"}, {"no_warning_for_binary_subject", ` $VERBOSE = true p(/a/n =~ "\xC3\xA9".dup.force_encoding("BINARY"))`, "nil\n"}, diff --git a/internal/vm/wave31_consts_internal_test.go b/internal/vm/wave31_consts_internal_test.go index 8fdf75e5..42da62be 100644 --- a/internal/vm/wave31_consts_internal_test.go +++ b/internal/vm/wave31_consts_internal_test.go @@ -33,7 +33,12 @@ p M.const_source_location(:NOPE) // The file is empty because eval() compiles a source string with no path, so // every location records line-only — which is exactly the shape that must // read back as the EMPTY array rather than as ["", n]. - want := "[]\n[]\n[]\n[]\nnil\n" + // + // Line 3's re-assignment of A also warns, which is variable.c's const_tbl_update + // doing its other job on the same code path this test exercises; there is no + // second "previous definition" line because the recorded location has no file, + // which is the very shape being asserted above (MRI's `!NIL_P(ce->file)` guard). + want := "[]\n(rbgo):3: warning: already initialized constant A\n[]\n[]\n[]\nnil\n" if got := eval(t, src); got != want { t.Errorf("got %q want %q", got, want) }