more import preparation

src/ir/lower/program.rs

@@ -31,7 +31,7 @@ impl LProgram {
                 fbuilder.instrs.push(LInstruction::Ret { src: None });
             }
             let res = fbuilder.finish(f);
-            ssbuilder.write_fn(sym, res, Some(p.names.name(i).to_string()));
+            ssbuilder.write_fn(sym, res, Some(p.names.path(i).to_string()));
         }
         let sym_space = ssbuilder.finish().expect("we failed the mission");
         Ok(Self { sym_space, entry })
@@ -142,7 +142,7 @@ impl<'a> LFunctionBuilder<'a> {
                 let sym = self.data.builder.ro_data(
                     src,
                     &data.content,
-                    Some(self.program.names.name(dest.id).to_string()),
+                    Some(self.program.names.path(dest.id).to_string()),
                 );
                 self.instrs.push(LInstruction::LoadData {
                     dest: dest.id,
@@ -163,7 +163,7 @@ impl<'a> LFunctionBuilder<'a> {
                 let sym = self.data.builder.ro_data(
                     src,
                     &data.content,
-                    Some(self.program.names.name(dest.id).to_string()),
+                    Some(self.program.names.path(dest.id).to_string()),
                 );
                 self.instrs.push(LInstruction::LoadAddr {
                     dest: dest.id,

src/ir/upper/assoc.rs

@@ -32,9 +32,16 @@ impl NameMap {
             inv_names: core::array::from_fn(|_| HashMap::new()),
         }
     }
-    pub fn name<K: Kind>(&self, id: ID<K>) -> &str {
+    pub fn path<K: Kind>(&self, id: ID<K>) -> &str {
         &self.names[K::INDEX][id.0]
     }
+    pub fn name<K: Kind>(&self, id: ID<K>) -> &str {
+        let mut path = self.path(id);
+        while let Some(i) = path.find("::") {
+            path = &path[i + 2..];
+        }
+        path
+    }
     pub fn id<K: Kind>(&self, name: &str) -> Option<ID<K>> {
         Some(ID::new(*self.inv_names[K::INDEX].get(name)?))
     }

src/ir/upper/ty.rs

@@ -36,6 +36,11 @@ impl UProgram {
     pub fn resolve_types(&mut self) {
         // I LOVE RUST
         let mut vars = self.vars.clone();
+        // set type of vars referring to functions
+        for (i, f) in self.iter_fns() {
+            let vi = self.fn_var.var(i);
+            vars[vi.0].as_mut().expect("bruh").ty = f.ty(self);
+        }
         for (i, f) in self.iter_fns() {
             let mut redo_iter = Vec::new();
             let mut ph_vars = Vec::new();

src/ir/upper/validate.rs

@@ -89,7 +89,11 @@ impl UProgram {
                     let destty = &self.expect(dest.id).ty;
                     let f = self.expect(f.id);
                     let Type::Fn { args: argtys, ret } = &f.ty else {
-                        todo!()
+                        output.err(CompilerMsg {
+                            msg: format!("Type {} is not callable", self.type_name(&f.ty)),
+                            spans: vec![dest.span],
+                        });
+                        continue;
                     };
                     output.check_assign(self, ret, destty, dest.span);
                     if args.len() != argtys.len() {