From 1f9cbea83257952b7b753fe35105434af538a16a Mon Sep 17 00:00:00 2001
From: SimonFJ20 <simonfromjakobsen@gmail.com>
Date: Mon, 3 Feb 2025 08:52:40 +0100
Subject: [PATCH] give up

---
 compiler/ctx.ts              |  2 +-
 compiler/main.ts             |  6 ++++-
 compiler/program.slg         | 10 ++++++--
 compiler/resolve/cx.ts       |  3 +++
 compiler/resolve/resolver.ts | 47 +++++++++++++++++++++++++++++++++++-
 5 files changed, 63 insertions(+), 5 deletions(-)

diff --git a/compiler/ctx.ts b/compiler/ctx.ts
index 814c07b..3c1ac01 100644
--- a/compiler/ctx.ts
+++ b/compiler/ctx.ts
@@ -53,7 +53,7 @@ export class Ctx {
         return keyId(0);
     }
 
-    public iterFiles(): Iterator<File> {
+    public iterFiles(): IteratorObject<File> {
         return this.files.keys()
             .map((key) => keyId(key));
     }
diff --git a/compiler/main.ts b/compiler/main.ts
index c8ed4af..0a370f1 100644
--- a/compiler/main.ts
+++ b/compiler/main.ts
@@ -3,6 +3,7 @@ import { Parser } from "./parse/parser.ts";
 import * as ast from "./ast/mod.ts";
 import { Ctx } from "./ctx.ts";
 import { File } from "./ctx.ts";
+import { Resolver } from "./resolve/resolver.ts";
 
 async function main() {
     const filePath = Deno.args[0];
@@ -39,7 +40,10 @@ export class PackCompiler {
         await FileTreeAstCollector
             .fromEntryFile(this.ctx, this.astCx, this.entryFilePath)
             .collect();
-        this.ctx.printAsts();
+        // this.ctx.printAsts();
+        const entryFile = this.ctx.entryFile();
+        const entryFileAst = this.ctx.fileInfo(entryFile).ast!;
+        new Resolver(this.ctx, entryFileAst).resolve();
     }
 
     public enableDebug() {
diff --git a/compiler/program.slg b/compiler/program.slg
index ccad4ac..dc5b68f 100644
--- a/compiler/program.slg
+++ b/compiler/program.slg
@@ -1,5 +1,11 @@
 
-fn main() -> int {
-    let a = 5;
+fn add(lhs: int, rhs: int) -> int {
+    lhs + rhs
+}
+
+fn main() {
+    let a = 5;
+    let b = 7;
+    let c = add(a, b);
 }
 
diff --git a/compiler/resolve/cx.ts b/compiler/resolve/cx.ts
index 3bb2da5..4d0115a 100644
--- a/compiler/resolve/cx.ts
+++ b/compiler/resolve/cx.ts
@@ -31,6 +31,9 @@ export class Ribs {
         return this.valRibs.at(-1)!.bindings.has(idKey(ident));
     }
 
+    public val(ident: IdentId) {
+    }
+
     public defVal(ident: IdentId, res: Res) {
         this.valRibs.at(-1)!.bindings.set(idKey(ident), res);
     }
diff --git a/compiler/resolve/resolver.ts b/compiler/resolve/resolver.ts
index 31d5bbf..5a87d17 100644
--- a/compiler/resolve/resolver.ts
+++ b/compiler/resolve/resolver.ts
@@ -10,13 +10,16 @@ export class Resolver implements ast.Visitor {
     public constructor(
         private ctx: Ctx,
         private entryFileAst: ast.File,
-    ) {
+    ) {}
+
+    public resolve() {
         ast.visitFile(this, this.entryFileAst);
     }
 
     visitFile(file: ast.File): ast.VisitRes {
         this.currentFile = this.entryFileAst.file;
         ast.visitStmts(this, file.stmts);
+        this.resolveFnBlocks();
     }
 
     visitLetStmt(stmt: ast.Stmt, kind: ast.LetStmt): ast.VisitRes {
@@ -62,7 +65,28 @@ export class Resolver implements ast.Visitor {
         todo();
     }
 
+    private fnBlocksToResolve: [ast.Item, ast.FnItem][] = [];
+
     visitFnItem(item: ast.Item, kind: ast.FnItem): ast.VisitRes {
+        this.defineVal(item.ident, this.defFn(item.ident.id, item, kind));
+        this.fnBlocksToResolve.push([item, kind]);
+        return "stop";
+    }
+
+    private resolveFnBlocks() {
+        for (const [item, kind] of this.fnBlocksToResolve) {
+            const ribPoint = this.ribs.checkpoint();
+            this.ribs.pushRib({ tag: "fn" });
+            for (const param of kind.params) {
+                ast.visitParam(this, param);
+            }
+            ast.visitBlock(this, kind.body!);
+            this.ribs.returnToCheckpoint(ribPoint);
+        }
+        this.fnBlocksToResolve = [];
+    }
+
+    visitPathExpr(expr: ast.Expr, kind: ast.PathExpr): ast.VisitRes {
         todo();
     }
 
@@ -80,6 +104,14 @@ export class Resolver implements ast.Visitor {
     }
 
     visitPathPat(pat: ast.Pat, kind: ast.PathPat): ast.VisitRes {
+        todo();
+        return "stop";
+    }
+
+    visitBlock(block: ast.Block): ast.VisitRes {
+        ast.visitStmts(this, block.stmts);
+        block.expr && ast.visitExpr(this, block.expr);
+        this.resolveFnBlocks();
         return "stop";
     }
 
@@ -95,6 +127,16 @@ export class Resolver implements ast.Visitor {
         return { tag: "def", def: { id, type: "mod" } };
     }
 
+    private fnDefs = new Map<number, [ast.Item, ast.FnItem]>();
+    private fnDef(id: number): [ast.Item, ast.FnItem] {
+        return this.fnDefs.get(id)!;
+    }
+    private defFn(_ident: IdentId, item: ast.Item, kind: ast.FnItem): Res {
+        const id = this.defIdCounter++;
+        this.fnDefs.set(id, [item, kind]);
+        return { tag: "def", def: { id, type: "fn" } };
+    }
+
     private defineTy(ident: ast.Ident, res: Res) {
         if (this.ribs.hasTy(ident.id)) {
             const text = this.ctx.identText(ident.id);
@@ -104,12 +146,14 @@ export class Resolver implements ast.Visitor {
                 span: ident.span,
                 msg: `redefinition of type '${text}'`,
             });
+            return;
         }
         this.ribs.defTy(ident.id, res);
     }
 
     private defineVal(ident: ast.Ident, res: Res) {
         if (this.ribs.hasVal(ident.id)) {
+            console.log(this.ribs);
             const text = this.ctx.identText(ident.id);
             this.ctx.report({
                 severity: "error",
@@ -117,6 +161,7 @@ export class Resolver implements ast.Visitor {
                 span: ident.span,
                 msg: `redefinition of value '${text}'`,
             });
+            return;
         }
         this.ribs.defVal(ident.id, res);
     }