Method init_modules

compiler/src/modules/vm/init.rs:191–242

Init each unique import once; code modules run their top-level, native ones just bind. `in_progress` catches cycles cleanly. */

(&mut self, chunk: &SSAChunk, in_progress: &mut crate::util::fx::FxHashSet<String>)

    /* Init each unique import once; code modules run their top-level, native ones just bind. `in_progress` catches cycles cleanly. */
    fn init_modules(&mut self, chunk: &SSAChunk, in_progress: &mut crate::util::fx::FxHashSet<String>) -> Result<(), VmErr> {
        for entry in &chunk.imports {
            if self.module_table.contains_key(&entry.spec) { continue; }
            if !in_progress.insert(entry.spec.clone()) {
                return Err(VmErr::Runtime("circular import"));
            }
            match &entry.kind {
                ImportKind::Native { funcs, classes, consts } => {
                    let mut attrs: Vec<(String, Val)> = Vec::with_capacity(funcs.len() + classes.len() + consts.len());
                    for b in funcs {
                        let val = self.heap.alloc(HeapObj::Extern(b.clone()))?;
                        attrs.push((b.name.clone(), val));
                    }
                    // Materialise each constant by invoking its export once and binding the result as an attr.
                    for c in consts {
                        let func = c.func.clone();
                        let val = func(&mut self.heap, &[], None)?;
                        attrs.push((c.name.clone(), val));
                    }
                    // Synthesise a HeapObj::Class per native class; each method becomes an Extern Val on the class.
                    for c in classes {
                        let mut methods: Vec<(String, Val)> = Vec::with_capacity(c.methods.len());
                        for m in &c.methods {
                            let mval = self.heap.alloc(HeapObj::Extern(m.clone()))?;
                            methods.push((m.name.clone(), mval));
                        }
                        let cls_val = self.heap.alloc(HeapObj::Class(c.name.clone(), Vec::new(), alloc::rc::Rc::new(core::cell::RefCell::new(methods))))?;
                        attrs.push((c.name.clone(), cls_val));
                    }
                    let val = self.heap.alloc(HeapObj::Module(entry.spec.clone(), attrs))?;
                    self.module_table.insert(entry.spec.clone(), val);
                }
                ImportKind::Code(sub_chunk) => {
                    self.init_modules(sub_chunk, in_progress)?;
                    let mut sub_slots = self.fill_builtins(&sub_chunk.names);
                    // Set `__name__` to the module spec so `if __name__ == "__main__":` works.
                    let spec_val = self.heap.alloc(HeapObj::Str(entry.spec.clone()))?;
                    for (i, name) in sub_chunk.names.iter().enumerate() {
                        if ssa_strip(name) == "__name__" {
                            sub_slots[i] = spec_val;
                        }
                    }
                    self.exec(sub_chunk, &mut sub_slots)?;
                    let attrs = collect_module_attrs(sub_chunk, &sub_slots);
                    let val = self.heap.alloc(HeapObj::Module(entry.spec.clone(), attrs))?;
                    self.module_table.insert(entry.spec.clone(), val);
                }
            }
            in_progress.remove(&entry.spec);
        }
        Ok(())
    }
}