added debug notes to MIR

DigitalCodeCrafter · DigitalCodeCrafter · commit aea06a85272e · 2026-01-05T00:24:21.000+01:00
fixed some span problems in parser
diff --git a/out.ks b/out.ks
diff --git a/src/backend/kerboscript.rs b/src/backend/kerboscript.rs
@@ -71,6 +71,7 @@ impl KosEmitter {
                 self.emit_rval(rval);
                 self.emit(".\n");
             }
+            Instr::Debug(_) => {},
         }
     }
 
diff --git a/src/main.rs b/src/main.rs
@@ -1,4 +1,4 @@
-use ksi::{backend, common::diagnostics::sinks::Diagnostics, mir, semantics, syntax};
+use ksi::{backend, common::diagnostics::sinks::Diagnostics, mir::{self, pretty}, semantics, syntax};
 
 
 fn main() -> Result<(), ()> {
@@ -24,7 +24,12 @@ fn main() -> Result<(), ()> {
         eprintln!("{:#?}", diagnostics.diagnostics);
     }
 
-    println!("{}", out);
+    let pretty_ir = pretty::format_body(&prog_ir, "main");
+    for line in pretty_ir.lines() {
+        println!("// {}", line);
+    }
+
+    println!("\n\n{}", out);
     Ok(()) 
 }
 
diff --git a/src/mir/lowerer.rs b/src/mir/lowerer.rs
@@ -66,8 +66,10 @@ impl MirBuilder<'_> {
     fn lower_stmt(&mut self, stmt: t::Stmt) {
         match stmt.kind {
             t::StmtKind::Let { sym, value } => {
-                let local = self.new_local(self.symbols.get(sym).ty.clone().expect("[Lowerer] Internal Error: local var symbol has no type annotation"));
+                let symbol = self.symbols.get(sym);
+                let local = self.new_local(symbol.ty.clone().expect("[Lowerer] Internal Error: local var symbol has no type annotation"));
                 self.env.insert(sym, local);
+                self.emit(Instr::Debug(DebugInfo { span: stmt.span, kind: DebugKind::DeclareLocal { local, name: symbol.name.clone() } }));
                 self.lower_expr(Place { local, projection: Vec::new() }, value);
             }
             t::StmtKind::Expr(expr) => {
@@ -80,6 +82,7 @@ impl MirBuilder<'_> {
     }
 
     fn lower_expr(&mut self, dest: Place, expr: t::Expr) {
+        self.emit(Instr::Debug(DebugInfo { span: expr.span, kind: DebugKind::EnterExpr }));
         let rval = match expr.kind {
             t::ExprKind::Number { value, .. } => RValue::Use(Operand::Const(Const::Number(value))),
 
@@ -112,6 +115,7 @@ impl MirBuilder<'_> {
         };
 
         self.emit(Instr::Assign(dest, rval));
+        self.emit(Instr::Debug(DebugInfo { span: expr.span, kind: DebugKind::ExitExpr }));
     }
 }
 
diff --git a/src/mir/mir.rs b/src/mir/mir.rs
@@ -1,4 +1,4 @@
-use crate::{mir::{BlockId, LocalId}, semantics::Type};
+use crate::{common::Span, mir::{BlockId, LocalId}, semantics::Type};
 pub use crate::semantics::typed_ast::BinaryOp;
 
 #[derive(Debug, PartialEq)]
@@ -28,6 +28,7 @@ pub enum Terminator {
 #[derive(Debug, PartialEq)]
 pub enum Instr {
     Assign(Place, RValue),
+    Debug(DebugInfo),
 }
 
 #[derive(Debug, PartialEq)]
@@ -61,3 +62,18 @@ pub enum Const {
     Unit,
 }
 
+#[derive(Debug, PartialEq)]
+pub struct DebugInfo {
+    pub span: Span,
+    pub kind: DebugKind,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum DebugKind {
+    EnterExpr,
+    ExitExpr,
+    DeclareLocal {
+        local: LocalId,
+        name: String,
+    }
+}
diff --git a/src/mir/pretty.rs b/src/mir/pretty.rs
@@ -41,9 +41,19 @@ pub fn format_rval(rv: &RValue) -> String {
     }
 }
 
+pub fn format_debug_info(info: &DebugInfo) -> String {
+    let note = match &info.kind {
+        DebugKind::EnterExpr => "enter expression".to_string(),
+        DebugKind::ExitExpr => "exit expression".to_string(),
+        DebugKind::DeclareLocal { local, name } => format!("{} := l{}", name, local.index()),
+    };
+    format!("[{}..{}] debug: {}", info.span.start, info.span.end, note)
+}
+
 pub fn format_instr(i: &Instr) -> String {
     match i {
         Instr::Assign(place, rvalue) => format!("{} = {}", format_place(place), format_rval(rvalue)),
+        Instr::Debug(info) => format_debug_info(info),
     }
 }
 
diff --git a/src/mir/verifier.rs b/src/mir/verifier.rs
@@ -72,6 +72,11 @@ impl FunctionIRVerifier<'_> {
                 self.verify_place(place);
                 self.verify_rval(rval);
             }
+            Instr::Debug(info) => {
+                if let DebugKind::DeclareLocal { local, .. } = info.kind {
+                    self.verify_local(local);
+                }
+            }
         }
     }
 
diff --git a/src/semantics/resolver.rs b/src/semantics/resolver.rs
@@ -25,6 +25,7 @@ struct ScopeId(u32);
 // Symbols
 
 pub struct Symbol {
+    pub name: String,
     kind: SymbolKind,
     scope: ScopeId,
     def_span: Span,
@@ -138,6 +139,7 @@ impl<'d, D: DiagnosticSink> Resolver<'d, D> {
         match &stmt.kind {
             p::StmtKind::Let { name, .. } => {
                 let symbol = self.symbols.insert(Symbol {
+                    name: name.to_string(),
                     kind: SymbolKind::Local,
                     scope: self.current_scope,
                     def_span: stmt.span,
diff --git a/src/syntax/parser.rs b/src/syntax/parser.rs
@@ -141,7 +141,7 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
 
         let terminator = self.expect_terminator();
 
-        let span = terminator.map(|t| t.span.concat(&let_kw.span)).unwrap_or(let_kw.span);
+        let span = let_kw.span.concat(&terminator.map(|t| t.span).unwrap_or(value.span));
 
         Stmt { kind: StmtKind::Let { name, value }, span }
     }
@@ -150,7 +150,7 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
         let expr = self.parse_expression(0);
         let terminator = self.expect_terminator();
 
-        let span = terminator.map(|t| t.span.concat(&expr.span)).unwrap_or(expr.span);
+        let span = expr.span.concat(&terminator.map(|t| t.span).unwrap_or(expr.span));
 
         Stmt { kind: StmtKind::Expr(expr), span }
     }
@@ -160,14 +160,13 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
         self.skip_newlines();
         match self.peek_token() {
             Token { kind: TokenKind::Semicolon, .. } => self.stream.next(),
-            Token { kind: TokenKind::RBrace | TokenKind::EOF, .. } => None,
+            Token { kind: TokenKind::RBrace, .. } => None,
+            _ if save != self.stream.get_position() => {
+                self.stream.set_position(save);
+                self.stream.next()
+            }
+            Token { kind: TokenKind::EOF, .. } => self.stream.next(),
             other => {
-                // skipped at least one newline
-                if save != self.stream.get_position() {
-                    self.stream.set_position(save);
-                    return self.stream.next();
-                }
-
                 self.diags.emit(
                     Diagnostic::error("missing statement terminator")
                     .with_span(other.span)
@@ -178,7 +177,6 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
         }
     }
 
-    // FIXME: This might recover beyond a scope termination.
     fn recover_to_stmt_start(&mut self) {
         let mut save = self.stream.get_position();
         while let Some(tok) = self.stream.next() {
@@ -319,7 +317,7 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
             }
         };
 
-        let span = closing_tok.map(|t| t.span.concat(&tok.span)).unwrap_or(tok.span);
+        let span = tok.span.concat(&closing_tok.map(|t| t.span).unwrap_or(expr.span));
 
         Expr { span, ..expr }
     }
@@ -348,14 +346,21 @@ impl<'a, 'd, D: DiagnosticSink> Parser<'a, 'd, D> {
             }
         };
 
-        let span = closing_tok.map(|t| t.span.concat(&tok.span)).unwrap_or(tok.span);
-
-        let tail_expr = match stmts.pop() {
-            Some(Stmt { kind: StmtKind::Expr(expr), span }) if expr.span == span => Some(Box::new(expr)),
-            Some(other) => { stmts.push(other); None }
+        let tail_expr = match stmts.last() {
+            Some(Stmt { kind: StmtKind::Expr(expr), span }) if expr.span == *span => {
+                let Stmt { kind: StmtKind::Expr(expr), .. } = stmts.pop().unwrap() else { unreachable!() };
+                Some(Box::new(expr))
+            }
             _ => None,
         };
 
+        // yes, I know this is a lot but it makes sense. ( "{" -> last stmt -> tail expr -> "}" )
+        let span = tok.span.concat(&closing_tok.map(|t| t.span)
+            .or(tail_expr.as_ref().map(|e| e.span))
+            .or(stmts.last().map(|s| s.span))
+            .unwrap_or(tok.span)
+        );
+
         Expr {
             kind: ExprKind::Block { stmts, tail_expr },
             span,
@@ -467,10 +472,10 @@ let a = x + 2\r
                         },
                         span: Span::new(40, 46)
                     }),
-                    span: Span::new(40, 46)
+                    span: Span::new(40, 48)
                 }
             ],
-            span: Span::new(2, 46),
+            span: Span::new(2, 48),
         };
 
         assert_eq!(parser.parse_program(), expected);

Original file line number	Diff line number	Diff line change
`@@ -71,6 +71,7 @@ impl KosEmitter {`
`71`	`71`	`self.emit_rval(rval);`
`72`	`72`	`self.emit(".\n");`
`73`	`73`	`}`
	`74`	`+ Instr::Debug(_) => {},`
`74`	`75`	`}`
`75`	`76`	`}`
`76`	`77`
Original file line number	Diff line number	Diff line change
`@@ -66,8 +66,10 @@ impl MirBuilder<'_> {`
`66`	`66`	`fn lower_stmt(&mut self, stmt: t::Stmt) {`
`67`	`67`	`match stmt.kind {`
`68`	`68`	`t::StmtKind::Let { sym, value } => {`
`69`		`- let local = self.new_local(self.symbols.get(sym).ty.clone().expect("[Lowerer] Internal Error: local var symbol has no type annotation"));`
	`69`	`+ let symbol = self.symbols.get(sym);`
	`70`	`+ let local = self.new_local(symbol.ty.clone().expect("[Lowerer] Internal Error: local var symbol has no type annotation"));`
`70`	`71`	`self.env.insert(sym, local);`
	`72`	`+ self.emit(Instr::Debug(DebugInfo { span: stmt.span, kind: DebugKind::DeclareLocal { local, name: symbol.name.clone() } }));`
`71`	`73`	`self.lower_expr(Place { local, projection: Vec::new() }, value);`
`72`	`74`	`}`
`73`	`75`	`t::StmtKind::Expr(expr) => {`
`@@ -80,6 +82,7 @@ impl MirBuilder<'_> {`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`fn lower_expr(&mut self, dest: Place, expr: t::Expr) {`
	`85`	`+ self.emit(Instr::Debug(DebugInfo { span: expr.span, kind: DebugKind::EnterExpr }));`
`83`	`86`	`let rval = match expr.kind {`
`84`	`87`	`t::ExprKind::Number { value, .. } => RValue::Use(Operand::Const(Const::Number(value))),`
`85`	`88`
`@@ -112,6 +115,7 @@ impl MirBuilder<'_> {`
`112`	`115`	`};`
`113`	`116`
`114`	`117`	`self.emit(Instr::Assign(dest, rval));`
	`118`	`+ self.emit(Instr::Debug(DebugInfo { span: expr.span, kind: DebugKind::ExitExpr }));`
`115`	`119`	`}`
`116`	`120`	`}`
`117`	`121`
Original file line number	Diff line number	Diff line change
`@@ -41,9 +41,19 @@ pub fn format_rval(rv: &RValue) -> String {`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
	`44`	`+pub fn format_debug_info(info: &DebugInfo) -> String {`
	`45`	`+ let note = match &info.kind {`
	`46`	`+ DebugKind::EnterExpr => "enter expression".to_string(),`
	`47`	`+ DebugKind::ExitExpr => "exit expression".to_string(),`
	`48`	`+ DebugKind::DeclareLocal { local, name } => format!("{} := l{}", name, local.index()),`
	`49`	`+ };`
	`50`	`+ format!("[{}..{}] debug: {}", info.span.start, info.span.end, note)`
	`51`	`+}`
	`52`	`+`
`44`	`53`	`pub fn format_instr(i: &Instr) -> String {`
`45`	`54`	`match i {`
`46`	`55`	`Instr::Assign(place, rvalue) => format!("{} = {}", format_place(place), format_rval(rvalue)),`
	`56`	`+ Instr::Debug(info) => format_debug_info(info),`
`47`	`57`	`}`
`48`	`58`	`}`
`49`	`59`
Original file line number	Diff line number	Diff line change
`@@ -72,6 +72,11 @@ impl FunctionIRVerifier<'_> {`
`72`	`72`	`self.verify_place(place);`
`73`	`73`	`self.verify_rval(rval);`
`74`	`74`	`}`
	`75`	`+ Instr::Debug(info) => {`
	`76`	`+ if let DebugKind::DeclareLocal { local, .. } = info.kind {`
	`77`	`+ self.verify_local(local);`
	`78`	`+ }`
	`79`	`+ }`
`75`	`80`	`}`
`76`	`81`	`}`
`77`	`82`