more import preparation

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() {