Method display_d

compiler/src/modules/vm/ops.rs:268–342

Cycle-aware display: `seen` tracks containers on the current path, so self-referential structures emit "..." instead of recursing forever (and its length bounds raw nesting depth). */

(&self, v: Val, seen: &mut Vec<u32>)

    /* Cycle-aware display: `seen` tracks containers on the current path, so self-referential structures emit "..." instead of recursing forever (and its length bounds raw nesting depth). */
    fn display_d(&self, v: Val, seen: &mut Vec<u32>) -> String {
        if seen.len() > RENDER_DEPTH_MAX { return "...".into(); }
        if v.is_int() { let mut b = itoa::Buffer::new(); return b.format(v.as_int()).into(); }
        if v.is_float() {
            // Single source of truth for float text (CPython repr rules, scientific + .0).
            return crate::util::fstr::format_f64(v.as_float());
        }
        if v.is_true() { return "True".into(); }
        if v.is_false() { return "False".into(); }
        if v.is_none() { return "None".into(); }
        match self.heap.get(v) {
            HeapObj::Str(s) => s.clone(),
            HeapObj::Bytes(b) => format_bytes(b),
            HeapObj::LongInt(i) => i128_to_dec(*i),
            HeapObj::Type(name) => s!("<class '", str name, "'>"),
            HeapObj::Func(i,_,_) => s!("<function ", int *i),
            HeapObj::Slice(s,e,st) => s!("slice(", str &self.display_d(*s, seen), ", ", str &self.display_d(*e, seen), ", ", str &self.display_d(*st, seen), ")"),
            HeapObj::Range(s,e,st) => if *st == 1 { s!("range(", int *s, ", ", int *e, ")") } else { s!("range(", int *s, ", ", int *e, ", ", int *st, ")") },
            HeapObj::List(l) => { let id = v.as_heap(); if seen.contains(&id) { return "[...]".into(); } seen.push(id); let mut o = s!(cap: 32; "["); self.append_reprs(&mut o, l.borrow().iter(), seen); o.push(']'); seen.pop(); o },
            HeapObj::Tuple(t) => { let id = v.as_heap(); if seen.contains(&id) { return "(...)".into(); } seen.push(id); let o = if t.len() == 1 { s!("(", str &self.repr_d(t[0], seen), ",)") } else { let mut o = s!(cap: 32; "("); self.append_reprs(&mut o, t.iter(), seen); o.push(')'); o }; seen.pop(); o },
            HeapObj::Dict(d) => { let id = v.as_heap(); if seen.contains(&id) { return "{...}".into(); } seen.push(id); let mut o = s!(cap: 32; "{"); for (i,(k,val)) in d.borrow().iter().enumerate() { if i>0 { if o.len() > MAX_REPR_LEN { o.push_str(", ..."); break; } o.push_str(", "); } o.push_str(&self.repr_d(k, seen)); o.push_str(": "); o.push_str(&self.repr_d(val, seen)); } o.push('}'); seen.pop(); o },
            HeapObj::BoundMethod(_, id) => s!("<built-in method ", str id.name(), ">"),
            HeapObj::NativeFn(id) => s!("<built-in function ", str id.name(), ">"),
            // User classes live in `__main__`; CPython qualifies the repr with the module.
            HeapObj::Class(name, _, _) => crate::s!("<class '__main__.", str name, "'>"),
            HeapObj::Instance(cls, _) => {
                if cls.is_heap() && let HeapObj::Class(name, _, _) = self.heap.get(*cls) { return crate::s!("<", str name, " instance>"); }
                "<instance>".into()
            }
            HeapObj::BoundUserMethod(..) => "<bound method>".into(),
            HeapObj::Super(..) => "<super object>".into(),
            HeapObj::Property(..) => "<property object>".into(),
            HeapObj::PropertySetter(..) => "<property.setter>".into(),
            HeapObj::StaticMethod(..) => "<staticmethod object>".into(),
            HeapObj::Coroutine(..) => "<coroutine>".into(),
            HeapObj::Module(name, _) => s!("<module '", str name, "'>"),
            HeapObj::Extern(f) => s!("<extern function ", str &f.name, ">"),
            HeapObj::ExcInstance(name, args) => {
                // `str(E("x"))` -> "x"; KeyError is special, stringifying as the key's repr.
                if args.len() == 1 {
                    if name == "KeyError" { self.repr_d(args[0], seen) } else { self.display_d(args[0], seen) }
                } else if args.is_empty() {
                    name.clone()
                } else {
                    let mut o = s!(cap: 32; str name, "(");
                    self.append_reprs(&mut o, args.iter(), seen);
                    o.push(')');
                    o
                }
            }
            HeapObj::Set(s) => {
                let items: Vec<Val> = s.borrow().iter().cloned().collect();
                if items.is_empty() { return "set()".into(); }
                let id = v.as_heap(); if seen.contains(&id) { return "{...}".into(); } seen.push(id);
                let mut out = String::new();
                out.push('{');
                self.append_reprs(&mut out, items.iter(), seen);
                out.push('}');