Method resolve_attr

compiler/src/modules/vm/handlers/methods.rs:107–224

`obj. ` resolution shared by `handle_load_attr` and `exec_call_method`.

(&self, obj: Val, name: &str)

    // `obj.<name>` resolution shared by `handle_load_attr` and `exec_call_method`.
    pub(crate) fn resolve_attr(&self, obj: Val, name: &str) -> Result<AttrLookup, VmErr> {
        let bare = crate::modules::parser::ssa_strip(name);

        // Module attr: linear scan; the table is sized for around 30 entries.
        if obj.is_heap()
            && let HeapObj::Module(mod_name, attrs) = self.heap.get(obj) {
                if let Some((_, v)) = attrs.iter().find(|(n, _)| n == bare) {
                    return Ok(AttrLookup::ModuleAttr(*v));
                }
                return Err(VmErr::Attribute(s!("module '", str mod_name, "' has no attribute '", str bare, "'")));
            }

        // ExcInstance attr: only `e.args` is defined.
        if obj.is_heap()
            && let HeapObj::ExcInstance(_, args) = self.heap.get(obj) {
                if bare == "args" { return Ok(AttrLookup::ExcArgs(args.clone())); }
                let ty = self.type_name(obj);
                return Err(VmErr::Attribute(s!("'", str ty, "' object has no attribute '", str bare, "'")));
            }

        // `__name__` on callables and types resolves to their declared name.
        if obj.is_heap() && bare == "__name__" {
            let resolved = match self.heap.get(obj) {
                HeapObj::Func(fi, _, _) => self.function_names.get(*fi).cloned(),
                HeapObj::Type(n) => Some(n.clone()),
                HeapObj::Class(n, _, _) => Some(n.clone()),
                _ => None,
            };
            if let Some(n) = resolved { return Ok(AttrLookup::Name(n)); }
        }

        // Class attr: `MyClass.method` returns the unbound function (no `self` prepended).
        if obj.is_heap()
            && let HeapObj::Class(cls_name, _, _) = self.heap.get(obj) {
                if let Some((v, _)) = self.lookup_class_member(obj, bare) {
                    // `staticmethod` accessed on the class itself unwraps to the plain function.
                    if v.is_heap() && let HeapObj::StaticMethod(func) = self.heap.get(v) {
                        return Ok(AttrLookup::ClassMember(*func));
                    }
                    return Ok(AttrLookup::ClassMember(v));
                }
                let cls_name = cls_name.clone();
                return Err(VmErr::Attribute(s!("type object '", str &cls_name, "' has no attribute '", str bare, "'")));
            }

        // Instance attribute lookup: check `__dict__` first, then the class chain (direct + bases).
        if obj.is_heap()
            && let HeapObj::Instance(cls_val, attrs) = self.heap.get(obj) {
                let cls_val = *cls_val;
                let found = attrs.borrow().entries.iter()
                    .find(|(k, _)| k.is_heap() && matches!(self.heap.get(*k), HeapObj::Str(s) if s == name))
                    .map(|(_, v)| *v);
                if let Some(v) = found { return Ok(AttrLookup::InstanceField(v)); }
                if let Some((mv, defining)) = self.lookup_class_member(cls_val, bare) {
                    // Guard on is_heap before heap.get: a non-heap data member (e.g. a wide int) would otherwise be read as a heap pointer and index a garbage slot.
                    if mv.is_heap() {
                        match self.heap.get(mv) {
                            // A Property member triggers getter invocation in `handle_load_attr`.