Projektmodule und vollständiges TBC-Kompilat umsetzen und Change archivieren

crates/tb-frontend/src/parser.rs

@@ -106,6 +106,7 @@ impl<'a> P<'a> {
     fn err(&mut self, msg: impl Into<String>) {
         let pos = self.pos();
         self.diags.push(Diagnostic {
+            file: None,
             pos,
             message: msg.into(),
         });
@@ -199,13 +200,13 @@ impl<'a> P<'a> {
             if let TokenKind::Num(NumValue::Int(n)) = self.k() {
                 if n >= 0 {
                     self.advance();
-                    return Some(Stmt::LineNumber(n as u32));
+                    return Some(Stmt::LineNumber(n as u32, pos));
                 }
             }
             if let TokenKind::Num(NumValue::Long(n)) = self.k() {
                 if n >= 0 {
                     self.advance();
-                    return Some(Stmt::LineNumber(n as u32));
+                    return Some(Stmt::LineNumber(n as u32, pos));
                 }
             }
             if let TokenKind::Ident { name, suffix: None } = self.k() {
@@ -816,7 +817,7 @@ impl<'a> P<'a> {
             {
                 if w == "ALL" {
                     self.advance();
-                    let args = vec![Expr::LongLit(ROLLBACK_ALL)];
+                    let args = vec![Expr::LongLit(ROLLBACK_ALL, pos)];
                     return Some(Stmt::Call {
                         name,
                         suffix: None,
@@ -1210,11 +1211,13 @@ impl<'a> P<'a> {
             let stop = |p: &P| p.is_kw(Kw::ElseIf) || p.is_kw(Kw::Else) || p.at_end_pair(Kw::If);
             let then_body = self.parse_stmt_list(stop);
             let mut elseifs = Vec::new();
-            while self.eat_kw(Kw::ElseIf) {
+            while self.is_kw(Kw::ElseIf) {
+                let elseif_pos = self.pos();
+                self.advance();
                 let c = self.parse_expr()?;
                 self.expect_kw(Kw::Then, "THEN");
                 let b = self.parse_stmt_list(stop);
-                elseifs.push((c, b));
+                elseifs.push((c, b, elseif_pos));
             }
             let else_body = if self.eat_kw(Kw::Else) {
                 Some(self.parse_stmt_list(|p: &P| p.at_end_pair(Kw::If)))
@@ -1349,6 +1352,7 @@ impl<'a> P<'a> {
             None
         };
         let body = self.parse_stmt_list(|p: &P| p.is_kw(Kw::Next));
+        let end_pos = self.pos();
         if self.eat_kw(Kw::Next) {
             // Optional: Zählvariable(n) hinter NEXT
             while matches!(self.k(), TokenKind::Ident { .. }) {
@@ -1367,6 +1371,7 @@ impl<'a> P<'a> {
             step,
             body,
             pos,
+            end_pos,
         })
     }
 
@@ -1380,6 +1385,7 @@ impl<'a> P<'a> {
             None
         };
         let body = self.parse_stmt_list(|p: &P| p.is_kw(Kw::Loop));
+        let end_pos = self.pos();
         let mut post = None;
         if self.eat_kw(Kw::Loop) {
             if self.eat_kw(Kw::While) {
@@ -1395,6 +1401,7 @@ impl<'a> P<'a> {
             post,
             body,
             pos,
+            end_pos,
         })
     }
 
@@ -1402,10 +1409,16 @@ impl<'a> P<'a> {
         self.advance(); // WHILE
         let cond = self.parse_expr()?;
         let body = self.parse_stmt_list(|p: &P| p.is_kw(Kw::Wend));
+        let end_pos = self.pos();
         if !self.eat_kw(Kw::Wend) {
             self.err("WHILE without WEND");
         }
-        Some(Stmt::While { cond, body, pos })
+        Some(Stmt::While {
+            cond,
+            body,
+            pos,
+            end_pos,
+        })
     }
 
     /// `ON <quelle>[(n)] GOSUB ziel`. Liefert `None` und lässt den Cursor
@@ -2214,18 +2227,20 @@ impl<'a> P<'a> {
         }
         match self.k() {
             TokenKind::Num(n) => {
+                let pos = self.pos();
                 self.advance();
                 Some(match n {
-                    NumValue::Int(v) => Expr::IntLit(v),
-                    NumValue::Long(v) => Expr::LongLit(v),
-                    NumValue::Single(v) => Expr::SingleLit(v),
-                    NumValue::Double(v) => Expr::DoubleLit(v),
-                    NumValue::Currency(v) => Expr::CurrencyLit(v),
+                    NumValue::Int(v) => Expr::IntLit(v, pos),
+                    NumValue::Long(v) => Expr::LongLit(v, pos),
+                    NumValue::Single(v) => Expr::SingleLit(v, pos),
+                    NumValue::Double(v) => Expr::DoubleLit(v, pos),
+                    NumValue::Currency(v) => Expr::CurrencyLit(v, pos),
                 })
             }
             TokenKind::Str(s) => {
+                let pos = self.pos();
                 self.advance();
-                Some(Expr::StrLit(s))
+                Some(Expr::StrLit(s, pos))
             }
             TokenKind::LParen => {
                 self.advance();