feat(qbasic): support archaic line numbers and implicit GOTO

Enables parsing legacy 80s sources that use numeric line labels
and the IF...THEN <line> shorthand.

- statements.js: reusable labelTarget combinator accepting identifiers
  and signed integers for GOTO/GOSUB/RESUME/RESTORE
- controlFlow.js: implicitGotoLine combinator + lazy singleLineClause
  enabling recursive nested ELSE IF blocks (Antoni Gual's ball.bas)
- tests: AST recursion test + Truth Vector compliance tests

Co-authored-by: Gemini <218195315+gemini-cli@users.noreply.github.com>

Author: jfrelat-lab

src/parser/qbasic/controlFlow.js

@@ -1,7 +1,7 @@
 // src/parser/controlFlow.js
 import { choice, many, regex, optional, capture, sequenceObj, lazy, sequenceOf } from '../monad.js';
 import { Tokens } from './tokens.js';
-import { identifier, keyword, optWs, ws, eos } from './lexers.js';
+import { identifier, keyword, optWs, ws, eos, signedNumberLiteral } from './lexers.js';
 import { expression } from './expressions.js';
 import { 
     labelDef, clsStmt, viewPrintStmt, playStmt, beepStmt, soundStmt, sleepStmt, printStmt, locateStmt, colorStmt, 
@@ -197,15 +197,33 @@ const multiLineIfStmt = sequenceObj([
     elseBlock: obj.elseBlockOpt || []
 }));
 
+/**
+ * Parses an implicit GOTO when a line number is provided directly after THEN or ELSE.
+ * Wraps the result in an array to perfectly mimic a standard statementList.
+ */
+const implicitGotoLine = signedNumberLiteral.map(node => [{ type: 'GOTO', label: String(node.value) }]);
+
+/**
+ * Defines the valid payload for a THEN or ELSE clause on a single line.
+ * Evaluated lazily to allow mutual recursion with singleLineIfStmt.
+ */
+const singleLineClause = lazy(() => choice([
+    implicitGotoLine,
+    singleLineIfStmt.map(ast => [ast]), // Clean recursion for nested IFs (e.g., ELSE IF)
+    statementList
+]));
+
 /**
  * Single-line IF. Statements follow immediately on the same line.
+ * Supports archaic implicit GOTO jumps (e.g., IF X THEN 10) 
+ * and recursive nested IFs (e.g., IF A THEN B ELSE IF C THEN D).
  */
 const singleLineIfStmt = sequenceObj([
     keyword(Tokens.IF), ws, capture('condition', expression), ws, keyword(Tokens.THEN), optWs,
-    capture('thenBlock', statementList),
+    capture('thenBlock', singleLineClause),
     capture('elseBlockOpt', optional(sequenceObj([
         optWs, keyword(Tokens.ELSE), optWs,
-        capture('elseBlock', statementList)
+        capture('elseBlock', singleLineClause)
     ]).map(obj => obj.elseBlock)))
 ]).map(obj => ({
     type: 'IF',

src/parser/qbasic/controlFlow.test.js

@@ -87,6 +87,30 @@ registerSuite('QBasic Control Flow (AST)', () => {
         assertEqual(success.result.elseBlock[0].values[0].value, 'Alive');
     });
 
+    test('singleLineIfStmt() should recursively parse nested ELSE IF blocks (ball.bas quirk)', () => {
+        // The legendary line from Antoni Gual's ball.bas
+        const code = `IF p >= 16 THEN 3 ELSE IF p = 0 THEN SCREEN 12 ELSE PALETTE p, b`;
+        const success = ifStmt.run(code);
+        
+        assertEqual(success.isError, false);
+        assertEqual(success.result.type, 'IF');
+        
+        // THEN block is an implicit GOTO 3
+        assertEqual(success.result.thenBlock[0].type, 'GOTO');
+        assertEqual(success.result.thenBlock[0].label, '3');
+        
+        // ELSE block contains the nested IF
+        const nestedIf = success.result.elseBlock[0];
+        assertEqual(nestedIf.type, 'IF');
+        
+        // Nested THEN is SCREEN 12
+        assertEqual(nestedIf.thenBlock[0].type, 'SCREEN_STMT');
+        assertEqual(nestedIf.thenBlock[0].mode.value, 12);
+        
+        // Nested ELSE is PALETTE
+        assertEqual(nestedIf.elseBlock[0].type, 'PALETTE');
+    });
+
     test('selectCaseStmt() should parse SELECT CASE while ignoring empty lines', () => {
         const code = `SELECT CASE level
             

src/parser/qbasic/statements.js

@@ -163,17 +163,35 @@ export const callStmt = sequenceObj([
     ]).map(obj => obj.args || [])))
 ]).map(obj => ({ type: 'CALL', callee: obj.callee, args: obj.argsOpt || [] }));
 
-export const labelDef = sequenceObj([
-    capture('name', identifier), optWs, str(':')
-]).map(obj => ({ type: 'LABEL', name: obj.name.value }));
+/**
+ * Reusable parser for jump targets.
+ * Supports modern text labels ("MainLoop") and archaic line numbers ("10").
+ */
+const labelTarget = choice([
+    identifier.map(id => id.value),
+    signedNumberLiteral.map(num => String(num.value))
+]);
+
+/**
+ * Parses either a modern text label (MyLabel:) or an archaic line number (10).
+ * Archaic line numbers do NOT have a trailing colon.
+ */
+export const labelDef = choice([
+    sequenceObj([
+        capture('name', identifier), optWs, str(':')
+    ]).map(obj => ({ type: 'LABEL', name: obj.name.value })),
+    
+    // Convert numeric line numbers to string labels for the GOTO resolver
+    signedNumberLiteral.map(node => ({ type: 'LABEL', name: String(node.value) }))
+]);
 
 export const gotoStmt = sequenceObj([
-    keyword(Tokens.GOTO), ws, capture('label', identifier)
-]).map(obj => ({ type: 'GOTO', label: obj.label.value }));
+    keyword(Tokens.GOTO), ws, capture('label', labelTarget)
+]).map(obj => ({ type: 'GOTO', label: obj.label }));
 
 export const gosubStmt = sequenceObj([
-    keyword(Tokens.GOSUB), ws, capture('label', identifier)
-]).map(obj => ({ type: 'GOSUB', label: obj.label.value }));
+    keyword(Tokens.GOSUB), ws, capture('label', labelTarget)
+]).map(obj => ({ type: 'GOSUB', label: obj.label }));
 
 export const returnStmt = keyword(Tokens.RETURN).map(() => ({ type: 'RETURN' }));
 
@@ -255,7 +273,7 @@ export const readStmt = sequenceObj([
 
 export const restoreStmt = sequenceObj([
     keyword(Tokens.RESTORE), 
-    capture('label', optional(sequenceOf([ws, identifier]).map(arr => arr[1].value)))
+    capture('label', optional(sequenceOf([ws, labelTarget]).map(arr => arr[1])))
 ]).map(obj => ({ 
     type: 'RESTORE', 
     label: obj.label || null 
@@ -425,21 +443,14 @@ export const onErrorStmt = sequenceObj([
  */
 export const resumeStmt = sequenceObj([
     keyword(Tokens.RESUME),
-    // The target is optional. It can be the keyword NEXT, or a label identifier.
+    // Target can be the keyword NEXT, a text label, or a line number
     capture('targetOpt', optional(sequenceOf([
-        ws, choice([keyword(Tokens.NEXT), identifier])
+        ws, choice([keyword(Tokens.NEXT), labelTarget])
     ]).map(arr => arr[1])))
-]).map(obj => {
-    let target = null;
-    if (obj.targetOpt) {
-        // If it's an identifier (label), extract its value. Otherwise, it's the string 'NEXT'
-        target = obj.targetOpt.type === 'IDENTIFIER' ? obj.targetOpt.value : 'NEXT';
-    }
-    return {
-        type: 'RESUME',
-        target: target // Will be null, 'NEXT', or a string (label name)
-    };
-});
+]).map(obj => ({
+    type: 'RESUME',
+    target: obj.targetOpt || null // Already extracts 'NEXT', 'MainLabel', or '10'
+}));
 
 /**
  * Parses the 'PALETTE' statement.

src/runtime/qbasic/compatibility.test.js

@@ -549,6 +549,39 @@ registerSuite('Truth Vector: CORE: Control Flow & Jumps', () => {
         assertEqual(env.lookup('Runs'), 2, "Runs assertion failed");
         assertEqual(env.lookup('FalseRuns'), 0, "FalseRuns assertion failed");
     });
+
+    test('Line Numbers (Archaic Labels)', () => {
+        const code = `
+            LineVal = 0
+            10 LineVal = 10
+            GOTO 30
+            20 LineVal = 20
+            30 FinalLine = LineVal
+        `;
+        const env = executeToEnv(code);
+
+        assertEqual(env.lookup('FinalLine'), 10, "FinalLine assertion failed");
+    });
+
+    test('Implicit GOTO (IF THEN Line Number)', () => {
+        const code = `
+            Flag = 1
+            IF Flag = 1 THEN 100 ELSE 200
+            100 ThenPath = 1
+            GOTO 300
+            200 ThenPath = 2
+            300 Flag = 0
+            IF Flag = 1 THEN 400 ELSE 500
+            400 ElsePath = 1
+            GOTO 600
+            500 ElsePath = 2
+            600 FinalEnd = 1
+        `;
+        const env = executeToEnv(code);
+
+        assertEqual(env.lookup('ThenPath'), 1, "ThenPath assertion failed");
+        assertEqual(env.lookup('ElsePath'), 2, "ElsePath assertion failed");
+    });
 });
 
 registerSuite('Truth Vector: CORE: Memory, Types & Structures', () => {

tests/truth_vectors/qbasic/control_flow.json

@@ -308,6 +308,67 @@
           { "var": "FalseRuns", "val": 0, "type": "number", "message": "WHILE must completely skip execution if the initial condition is 0" }
         ]
       }
+    },
+    {
+      "name": "Line Numbers (Archaic Labels)",
+      "syntax": "linenumber statement",
+      "description": "In older BASIC dialects, every line required a number. QBasic supports these numbers as archaic labels for control flow statements like GOTO, GOSUB, and RESTORE. They do not require a trailing colon.",
+      "example": {
+        "code": [
+          "10 PRINT \"START\"",
+          "GOTO 30",
+          "20 PRINT \"SKIPPED\"",
+          "30 PRINT \"END\""
+        ],
+        "output": "START\nEND"
+      },
+      "quirks_and_tests": {
+        "description": "Validates that a raw integer at the start of a statement acts as a valid jump target without requiring a trailing colon.",
+        "setup": [
+          "LineVal = 0",
+          "10 LineVal = 10",
+          "GOTO 30",
+          "20 LineVal = 20",
+          "30 FinalLine = LineVal"
+        ],
+        "assertions": [
+          { "var": "FinalLine", "val": 10, "type": "number", "message": "GOTO must successfully bypass line 20 and land on line 30 using numeric labels." }
+        ]
+      }
+    },
+    {
+      "name": "Implicit GOTO (IF THEN Line Number)",
+      "syntax": "IF condition THEN linenumber [ELSE linenumber]",
+      "description": "A legacy shorthand where providing a line number directly after THEN or ELSE implicitly executes a GOTO instruction.",
+      "example": {
+        "code": [
+          "IF 1 = 1 THEN 100 ELSE 200",
+          "100 PRINT \"TRUE\"",
+          "END",
+          "200 PRINT \"FALSE\""
+        ],
+        "output": "TRUE"
+      },
+      "quirks_and_tests": {
+        "description": "CRITICAL QUIRK: This implicit jump ONLY works with numeric line numbers, not text labels. It is heavily used in code golf and demoscene programs.",
+        "setup": [
+          "Flag = 1",
+          "IF Flag = 1 THEN 100 ELSE 200",
+          "100 ThenPath = 1",
+          "GOTO 300",
+          "200 ThenPath = 2",
+          "300 Flag = 0",
+          "IF Flag = 1 THEN 400 ELSE 500",
+          "400 ElsePath = 1",
+          "GOTO 600",
+          "500 ElsePath = 2",
+          "600 FinalEnd = 1"
+        ],
+        "assertions": [
+          { "var": "ThenPath", "val": 1, "type": "number", "message": "Implicit THEN jump must successfully land on line 100." },
+          { "var": "ElsePath", "val": 2, "type": "number", "message": "Implicit ELSE jump must successfully land on line 500." }
+        ]
+      }
     }
   ]
 }