@stevenvo780/st-lang 3.1.0 → 3.1.2

package/dist/parser/parser.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const tokens_1 = require("../lexer/tokens");
 const lexer_1 = require("../lexer/lexer");
+const compat_1 = require("../runtime/compat");
 // Modal aliases per profile: maps identifier names to modal formula types
 const MODAL_ALIASES = {
     'deontic.standard': { O: 'box', P: 'diamond', F: 'box_not' },
@@ -21,6 +22,7 @@ class Parser {
     pos = 0;
     file;
     diagnostics = [];
+    contextStack = [];
     knownFunctionNames = new Set([
         'typeof',
         'is_valid',
@@ -40,10 +42,12 @@ class Parser {
         this.initialProfile = profile;
     }
     parse(source) {
-        const lexer = new lexer_1.Lexer(source, this.file, this.initialProfile);
+        const normalizedSource = (0, compat_1.normalizeSTSource)(source);
+        const lexer = new lexer_1.Lexer(normalizedSource, this.file, this.initialProfile);
         this.tokens = lexer.tokenize();
         this.diagnostics.push(...lexer.diagnostics);
         this.pos = 0;
+        this.contextStack = [];
         const statements = [];
         while (!this.isAtEnd()) {
             this.skipNewlines();
@@ -75,93 +79,95 @@ class Parser {
         // Detección de llamada a función: nombre(...)
         if (this.peek(1) === tokens_1.TokenType.LPAREN &&
             (tok.type === tokens_1.TokenType.IDENTIFIER || this.knownFunctionNames.has(tok.value))) {
-            return this.parseFnCall();
+            return this.withContext(`llamada a funcion '${tok.value}'`, () => this.parseFnCall());
         }
         // Detección de llamada a método: objeto.metodo(...)
         if (tok.type === tokens_1.TokenType.IDENTIFIER &&
             this.peek(1) === tokens_1.TokenType.DOT &&
             this.peek(2) === tokens_1.TokenType.IDENTIFIER &&
             this.peek(3) === tokens_1.TokenType.LPAREN) {
-            return this.parseMemberFnCall();
-        }
-        switch (tok.type) {
-            case tokens_1.TokenType.LOGIC:
-                return this.parseLogicDecl();
-            case tokens_1.TokenType.AXIOM:
-                return this.parseAxiomDecl();
-            case tokens_1.TokenType.THEOREM:
-                return this.parseTheoremDecl();
-            case tokens_1.TokenType.DERIVE:
-                return this.parseDeriveCmd();
-            case tokens_1.TokenType.CHECK:
-                return this.parseCheckCmd();
-            case tokens_1.TokenType.PROVE:
-                return this.parseProveCmd();
-            case tokens_1.TokenType.COUNTERMODEL:
-            case tokens_1.TokenType.REFUTE:
-                return this.parseCountermodelCmd();
-            case tokens_1.TokenType.TRUTH_TABLE:
-                return this.parseTruthTableCmd();
-            case tokens_1.TokenType.LET:
-                return this.parseLetDecl();
-            case tokens_1.TokenType.CLAIM:
-                return this.parseClaimDecl();
-            case tokens_1.TokenType.SUPPORT:
-                return this.parseSupportDecl();
-            case tokens_1.TokenType.CONFIDENCE:
-                return this.parseConfidenceDecl();
-            case tokens_1.TokenType.CONTEXT:
-                return this.parseContextDecl();
-            case tokens_1.TokenType.RENDER:
-                return this.parseRenderCmd();
-            case tokens_1.TokenType.ANALYZE:
-                return this.parseAnalyzeCmd();
-            case tokens_1.TokenType.EXPLAIN:
-                return this.parseExplainCmd();
-            case tokens_1.TokenType.IMPORT:
-                return this.parseImportDecl();
-            case tokens_1.TokenType.ASSUME:
-                return this.parseProofBlock();
-            case tokens_1.TokenType.THEORY:
-                return this.parseTheoryDecl();
-            case tokens_1.TokenType.PRINT:
-                return this.parsePrintCmd();
-            case tokens_1.TokenType.SET:
-                return this.parseSetCmd();
-            case tokens_1.TokenType.IF:
-                return this.parseIfStmt();
-            case tokens_1.TokenType.FOR:
-                return this.parseForStmt();
-            case tokens_1.TokenType.WHILE:
-                return this.parseWhileStmt();
-            case tokens_1.TokenType.FN:
-                return this.parseFnDecl();
-            case tokens_1.TokenType.RETURN:
-                return this.parseReturnStmt();
-            case tokens_1.TokenType.EXPORT:
-                return this.parseExportDecl();
-            case tokens_1.TokenType.DEFINE:
-                return this.parseDefineDecl();
-            case tokens_1.TokenType.UNFOLD:
-                return this.parseUnfoldCmd();
-            case tokens_1.TokenType.FOLD:
-                return this.parseFoldCmd();
-            case tokens_1.TokenType.SOURCE_KW:
-                return this.parseSourceDecl();
-            case tokens_1.TokenType.INTERPRET:
-                return this.parseInterpretCmd();
-            case tokens_1.TokenType.GLOSSARY:
-                return this.parseGlossaryCmd();
-            case tokens_1.TokenType.IDENTIFIER:
-                throw new Error(`Statement inesperado: '${tok.value}' (${tok.type})`);
-            case tokens_1.TokenType.NEWLINE:
-                this.advance();
-                return null;
-            case tokens_1.TokenType.EOF:
-                return null;
-            default:
-                throw new Error(`Statement inesperado: '${tok.value}' (${tok.type})`);
-        }
+            return this.withContext(`llamada a metodo '${tok.value}'`, () => this.parseMemberFnCall());
+        }
+        return this.withContext(this.describeStatementContext(tok), () => {
+            switch (tok.type) {
+                case tokens_1.TokenType.LOGIC:
+                    return this.parseLogicDecl();
+                case tokens_1.TokenType.AXIOM:
+                    return this.parseAxiomDecl();
+                case tokens_1.TokenType.THEOREM:
+                    return this.parseTheoremDecl();
+                case tokens_1.TokenType.DERIVE:
+                    return this.parseDeriveCmd();
+                case tokens_1.TokenType.CHECK:
+                    return this.parseCheckCmd();
+                case tokens_1.TokenType.PROVE:
+                    return this.parseProveCmd();
+                case tokens_1.TokenType.COUNTERMODEL:
+                case tokens_1.TokenType.REFUTE:
+                    return this.parseCountermodelCmd();
+                case tokens_1.TokenType.TRUTH_TABLE:
+                    return this.parseTruthTableCmd();
+                case tokens_1.TokenType.LET:
+                    return this.parseLetDecl();
+                case tokens_1.TokenType.CLAIM:
+                    return this.parseClaimDecl();
+                case tokens_1.TokenType.SUPPORT:
+                    return this.parseSupportDecl();
+                case tokens_1.TokenType.CONFIDENCE:
+                    return this.parseConfidenceDecl();
+                case tokens_1.TokenType.CONTEXT:
+                    return this.parseContextDecl();
+                case tokens_1.TokenType.RENDER:
+                    return this.parseRenderCmd();
+                case tokens_1.TokenType.ANALYZE:
+                    return this.parseAnalyzeCmd();
+                case tokens_1.TokenType.EXPLAIN:
+                    return this.parseExplainCmd();
+                case tokens_1.TokenType.IMPORT:
+                    return this.parseImportDecl();
+                case tokens_1.TokenType.ASSUME:
+                    return this.parseProofBlock();
+                case tokens_1.TokenType.THEORY:
+                    return this.parseTheoryDecl();
+                case tokens_1.TokenType.PRINT:
+                    return this.parsePrintCmd();
+                case tokens_1.TokenType.SET:
+                    return this.parseSetCmd();
+                case tokens_1.TokenType.IF:
+                    return this.parseIfStmt();
+                case tokens_1.TokenType.FOR:
+                    return this.parseForStmt();
+                case tokens_1.TokenType.WHILE:
+                    return this.parseWhileStmt();
+                case tokens_1.TokenType.FN:
+                    return this.parseFnDecl();
+                case tokens_1.TokenType.RETURN:
+                    return this.parseReturnStmt();
+                case tokens_1.TokenType.EXPORT:
+                    return this.parseExportDecl();
+                case tokens_1.TokenType.DEFINE:
+                    return this.parseDefineDecl();
+                case tokens_1.TokenType.UNFOLD:
+                    return this.parseUnfoldCmd();
+                case tokens_1.TokenType.FOLD:
+                    return this.parseFoldCmd();
+                case tokens_1.TokenType.SOURCE_KW:
+                    return this.parseSourceDecl();
+                case tokens_1.TokenType.INTERPRET:
+                    return this.parseInterpretCmd();
+                case tokens_1.TokenType.GLOSSARY:
+                    return this.parseGlossaryCmd();
+                case tokens_1.TokenType.IDENTIFIER:
+                    throw new Error(this.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
+                case tokens_1.TokenType.NEWLINE:
+                    this.advance();
+                    return null;
+                case tokens_1.TokenType.EOF:
+                    return null;
+                default:
+                    throw new Error(this.contextualize(`Statement inesperado: '${tok.value}' (${tok.type})`));
+            }
+        });
     }
     // logic classical.propositional
     parseLogicDecl() {
@@ -547,12 +553,14 @@ class Parser {
             if (this.checkType(tokens_1.TokenType.QED))
                 break;
             try {
-                const stmt = this.parseStatement();
+                const stmt = this.checkType(tokens_1.TokenType.ASSUME)
+                    ? this.parseProofBlock()
+                    : this.parseStatement();
                 if (stmt)
                     body.push(stmt);
             }
             catch (e) {
-                const message = e instanceof Error ? e.message : 'Error de parseo';
+                const message = e instanceof Error ? e.message : 'Error de parseo en bloque de prueba';
                 this.diagnostics.push({
                     severity: 'error',
                     message,
@@ -563,6 +571,9 @@ class Parser {
                 this.advanceToNextStatement();
             }
         }
+        if (this.isAtEnd()) {
+            throw new Error(`Se esperaba 'qed' para cerrar el bloque de prueba abierto en linea ${src.line}, columna ${src.column}`);
+        }
         this.expect(tokens_1.TokenType.QED);
         return { kind: 'proof_block', assumptions, goal, body, source: src };
     }
@@ -1108,6 +1119,17 @@ class Parser {
         return this.parseAtom();
     }
     parseAtom() {
+        // Constantes lógicas ⊤/⊥ (true/false/verdadero/falso)
+        if (this.checkType(tokens_1.TokenType.TRUE_CONST)) {
+            const tok = this.current();
+            this.advance();
+            return { kind: 'true', source: { line: tok.line, column: tok.column } };
+        }
+        if (this.checkType(tokens_1.TokenType.FALSE_CONST)) {
+            const tok = this.current();
+            this.advance();
+            return { kind: 'false', source: { line: tok.line, column: tok.column } };
+        }
         // Literal numérico
         if (this.checkType(tokens_1.TokenType.NUMBER)) {
             const tok = this.current();
@@ -1428,8 +1450,8 @@ class Parser {
         if (this.checkType(type)) {
             return this.advance();
         }
-        throw new Error(`Se esperaba ${type}, encontrado '${this.current().value}' (${this.current().type}) ` +
-            `en linea ${this.current().line}, columna ${this.current().column}`);
+        throw new Error(this.contextualize(`Se esperaba ${type}, encontrado '${this.current().value}' (${this.current().type}) ` +
+            `en linea ${this.current().line}, columna ${this.current().column}`));
     }
     expectOneOf(...types) {
         for (const type of types) {
@@ -1437,8 +1459,8 @@ class Parser {
                 return this.advance();
             }
         }
-        throw new Error(`Se esperaba ${types.join(' o ')}, encontrado '${this.current().value}' (${this.current().type}) ` +
-            `en linea ${this.current().line}, columna ${this.current().column}`);
+        throw new Error(this.contextualize(`Se esperaba ${types.join(' o ')}, encontrado '${this.current().value}' (${this.current().type}) ` +
+            `en linea ${this.current().line}, columna ${this.current().column}`));
     }
     expectIdent() {
         const tok = this.expect(tokens_1.TokenType.IDENTIFIER);
@@ -1474,8 +1496,95 @@ class Parser {
             this.advance();
             return tok.value;
         }
-        throw new Error(`Se esperaba nombre/identificador, encontrado '${tok.value}' (${tok.type}) ` +
-            `en linea ${tok.line}, columna ${tok.column}`);
+        throw new Error(this.contextualize(`Se esperaba nombre/identificador, encontrado '${tok.value}' (${tok.type}) ` +
+            `en linea ${tok.line}, columna ${tok.column}`));
+    }
+    contextualize(message) {
+        if (this.contextStack.length === 0)
+            return message;
+        return `${message} mientras se parseaba ${this.contextStack.join(' > ')}`;
+    }
+    withContext(context, fn) {
+        this.contextStack.push(context);
+        try {
+            return fn();
+        }
+        finally {
+            this.contextStack.pop();
+        }
+    }
+    describeStatementContext(tok) {
+        switch (tok.type) {
+            case tokens_1.TokenType.LOGIC:
+                return 'declaracion logic';
+            case tokens_1.TokenType.AXIOM:
+                return 'declaracion de axioma';
+            case tokens_1.TokenType.THEOREM:
+                return 'declaracion de teorema';
+            case tokens_1.TokenType.DERIVE:
+                return 'comando derive';
+            case tokens_1.TokenType.CHECK:
+                return 'comando check';
+            case tokens_1.TokenType.PROVE:
+                return 'comando prove';
+            case tokens_1.TokenType.COUNTERMODEL:
+            case tokens_1.TokenType.REFUTE:
+                return 'comando countermodel';
+            case tokens_1.TokenType.TRUTH_TABLE:
+                return 'comando truth_table';
+            case tokens_1.TokenType.LET:
+                return 'declaracion let';
+            case tokens_1.TokenType.CLAIM:
+                return 'declaracion claim';
+            case tokens_1.TokenType.SUPPORT:
+                return 'declaracion support';
+            case tokens_1.TokenType.CONFIDENCE:
+                return 'declaracion confidence';
+            case tokens_1.TokenType.CONTEXT:
+                return 'declaracion context';
+            case tokens_1.TokenType.RENDER:
+                return 'comando render';
+            case tokens_1.TokenType.ANALYZE:
+                return 'comando analyze';
+            case tokens_1.TokenType.EXPLAIN:
+                return 'comando explain';
+            case tokens_1.TokenType.IMPORT:
+                return 'declaracion import';
+            case tokens_1.TokenType.ASSUME:
+                return 'bloque de prueba';
+            case tokens_1.TokenType.THEORY:
+                return 'declaracion theory';
+            case tokens_1.TokenType.PRINT:
+                return 'comando print';
+            case tokens_1.TokenType.SET:
+                return 'comando set';
+            case tokens_1.TokenType.IF:
+                return 'sentencia if';
+            case tokens_1.TokenType.FOR:
+                return 'sentencia for';
+            case tokens_1.TokenType.WHILE:
+                return 'sentencia while';
+            case tokens_1.TokenType.FN:
+                return 'declaracion fn';
+            case tokens_1.TokenType.RETURN:
+                return 'sentencia return';
+            case tokens_1.TokenType.EXPORT:
+                return 'declaracion export';
+            case tokens_1.TokenType.DEFINE:
+                return 'declaracion define';
+            case tokens_1.TokenType.UNFOLD:
+                return 'comando unfold';
+            case tokens_1.TokenType.FOLD:
+                return 'comando fold';
+            case tokens_1.TokenType.SOURCE_KW:
+                return 'declaracion source';
+            case tokens_1.TokenType.INTERPRET:
+                return 'comando interpret';
+            case tokens_1.TokenType.GLOSSARY:
+                return 'comando glossary';
+            default:
+                return `statement '${tok.value}'`;
+        }
     }
     loc() {
         const tok = this.current();
@@ -1527,14 +1636,37 @@ class Parser {
             tokens_1.TokenType.INTERPRET,
             tokens_1.TokenType.GLOSSARY,
         ]);
+        let parenDepth = 0;
+        let braceDepth = 0;
+        let bracketDepth = 0;
         while (!this.isAtEnd()) {
-            if (this.checkType(tokens_1.TokenType.NEWLINE)) {
+            if (this.checkType(tokens_1.TokenType.NEWLINE) &&
+                parenDepth === 0 &&
+                braceDepth === 0 &&
+                bracketDepth === 0) {
                 this.skipNewlines();
                 return;
             }
-            if (statementStarters.has(this.current().type)) {
+            if (parenDepth === 0 &&
+                braceDepth === 0 &&
+                bracketDepth === 0 &&
+                statementStarters.has(this.current().type)) {
                 return; // Encontramos el inicio del siguiente statement
             }
+            if (this.checkType(tokens_1.TokenType.LPAREN))
+                parenDepth += 1;
+            else if (this.checkType(tokens_1.TokenType.RPAREN))
+                parenDepth = Math.max(0, parenDepth - 1);
+            else if (this.checkType(tokens_1.TokenType.LBRACE))
+                braceDepth += 1;
+            else if (this.checkType(tokens_1.TokenType.RBRACE))
+                braceDepth = Math.max(0, braceDepth - 1);
+            else if (this.checkType(tokens_1.TokenType.LBRACKET) || this.checkType(tokens_1.TokenType.LBRACKET_DOUBLE)) {
+                bracketDepth += 1;
+            }
+            else if (this.checkType(tokens_1.TokenType.RBRACKET) || this.checkType(tokens_1.TokenType.RBRACKET_DOUBLE)) {
+                bracketDepth = Math.max(0, bracketDepth - 1);
+            }
             this.advance();
         }
     }