@stevenvo780/st-lang 1.5.7 → 2.0.0

package/dist/parser/parser.js

@@ -11,6 +11,8 @@ class Parser {
     pos = 0;
     file;
     diagnostics = [];
+    knownFunctionNames = new Set(['typeof', 'is_valid', 'is_satisfiable', 'get_atoms', 'input']);
+    knownTheoryNames = new Set();
     constructor(file = '<stdin>') {
         this.file = file;
     }
@@ -47,6 +49,15 @@ class Parser {
     // --- Parsing de statements ---
     parseStatement() {
         const tok = this.current();
+        // 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();
+        }
+        // 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();
@@ -87,6 +98,24 @@ class Parser {
                 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.IDENTIFIER:
+                throw new Error(`Statement inesperado: '${tok.value}' (${tok.type})`);
             case tokens_1.TokenType.NEWLINE:
                 this.advance();
                 return null;
@@ -403,11 +432,24 @@ class Parser {
         this.expect(tokens_1.TokenType.QED);
         return { kind: 'proof_block', assumptions, goal, body, source: src };
     }
-    // theory Name { ... } | theory Name extends Parent { ... }
+    // theory Name(params) { ... } | theory Name extends Parent { ... }
     parseTheoryDecl() {
         const src = this.loc();
         this.expect(tokens_1.TokenType.THEORY);
         const name = this.expectName();
+        this.knownTheoryNames.add(name);
+        // Parámetros opcionales (constructor): theory Math(n)
+        let params;
+        if (this.match(tokens_1.TokenType.LPAREN)) {
+            params = [];
+            if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+                params.push(this.expectName());
+                while (this.match(tokens_1.TokenType.COMMA)) {
+                    params.push(this.expectName());
+                }
+            }
+            this.expect(tokens_1.TokenType.RPAREN);
+        }
         // Herencia opcional: extends Parent
         let parent;
         if (this.match(tokens_1.TokenType.EXTENDS)) {
@@ -444,7 +486,220 @@ class Parser {
             }
         }
         this.expect(tokens_1.TokenType.RBRACE);
-        return { kind: 'theory_decl', name, parent, members, source: src };
+        return { kind: 'theory_decl', name, params, parent, members, source: src };
+    }
+    // --- print "texto" | print formula ---
+    parsePrintCmd() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.PRINT);
+        if (this.checkType(tokens_1.TokenType.STRING)) {
+            const value = this.current().value;
+            this.advance();
+            return { kind: 'print_cmd', value, source: src };
+        }
+        // Imprimir resultado de fórmula
+        const formula = this.parseFormula();
+        return { kind: 'print_cmd', value: null, formula, source: src };
+    }
+    // --- set x = formula ---
+    parseSetCmd() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.SET);
+        const name = this.expectName();
+        this.expectOneOf(tokens_1.TokenType.EQUALS, tokens_1.TokenType.COLON);
+        const formula = this.parseFormula();
+        return { kind: 'set_cmd', name, formula, source: src };
+    }
+    // --- if valid FORMULA { } else if satisfiable FORMULA { } else { } ---
+    parseIfStmt() {
+        const src = this.loc();
+        const branches = [];
+        let elseBranch;
+        // Primera rama: if
+        this.expect(tokens_1.TokenType.IF);
+        branches.push(this.parseConditionBranch());
+        // Ramas else if
+        while (this.checkElseIf()) {
+            this.expect(tokens_1.TokenType.ELSE);
+            this.expect(tokens_1.TokenType.IF);
+            branches.push(this.parseConditionBranch());
+        }
+        // Rama else
+        if (this.match(tokens_1.TokenType.ELSE)) {
+            elseBranch = this.parseBlock();
+        }
+        return { kind: 'if_stmt', branches, elseBranch, source: src };
+    }
+    checkElseIf() {
+        // Mira si hay else seguido de if (con posibles newlines entre medio)
+        if (!this.checkType(tokens_1.TokenType.ELSE))
+            return false;
+        // Buscar if después de else (puede haber newlines)
+        let lookahead = 1;
+        while (this.peek(lookahead) === tokens_1.TokenType.NEWLINE)
+            lookahead++;
+        return this.peek(lookahead) === tokens_1.TokenType.IF;
+    }
+    parseConditionBranch() {
+        const condition = this.parseConditionKeyword();
+        const formula = this.parseFormula();
+        const body = this.parseBlock();
+        return { condition, formula, body };
+    }
+    parseConditionKeyword() {
+        if (this.match(tokens_1.TokenType.VALID))
+            return 'valid';
+        if (this.match(tokens_1.TokenType.SATISFIABLE))
+            return 'satisfiable';
+        // Aceptar "invalid" / "unsatisfiable" como identifiers
+        if (this.checkType(tokens_1.TokenType.IDENTIFIER)) {
+            const v = this.current().value.toLowerCase();
+            if (v === 'invalid' || v === 'invalido') {
+                this.advance();
+                return 'invalid';
+            }
+            if (v === 'unsatisfiable' || v === 'insatisfacible') {
+                this.advance();
+                return 'unsatisfiable';
+            }
+        }
+        // Default: valid
+        return 'valid';
+    }
+    // --- for x in {A, B, C} { body } ---
+    parseForStmt() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.FOR);
+        const variable = this.expectName();
+        this.expect(tokens_1.TokenType.IN);
+        this.expect(tokens_1.TokenType.LBRACE);
+        const items = [];
+        if (!this.checkType(tokens_1.TokenType.RBRACE)) {
+            items.push(this.parseFormula());
+            while (this.match(tokens_1.TokenType.COMMA)) {
+                items.push(this.parseFormula());
+            }
+        }
+        this.expect(tokens_1.TokenType.RBRACE);
+        const body = this.parseBlock();
+        return { kind: 'for_stmt', variable, items, body, source: src };
+    }
+    // --- while valid FORMULA { body } ---
+    parseWhileStmt() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.WHILE);
+        const condition = this.parseConditionKeyword();
+        const formula = this.parseFormula();
+        const body = this.parseBlock();
+        return { kind: 'while_stmt', condition, formula, body, maxIterations: 1000, source: src };
+    }
+    // --- fn nombre(param1, param2) { body } ---
+    parseFnDecl() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.FN);
+        const name = this.expectName();
+        this.knownFunctionNames.add(name);
+        this.expect(tokens_1.TokenType.LPAREN);
+        const params = [];
+        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+            params.push(this.expectName());
+            while (this.match(tokens_1.TokenType.COMMA)) {
+                params.push(this.expectName());
+            }
+        }
+        this.expect(tokens_1.TokenType.RPAREN);
+        const body = this.parseBlock();
+        return { kind: 'fn_decl', name, params, body, source: src };
+    }
+    // --- return formula ---
+    parseReturnStmt() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.RETURN);
+        let formula;
+        // Si hay algo después del return que no sea newline/EOF/}
+        if (!this.checkType(tokens_1.TokenType.NEWLINE) && !this.checkType(tokens_1.TokenType.EOF) &&
+            !this.checkType(tokens_1.TokenType.RBRACE)) {
+            formula = this.parseFormula();
+        }
+        return { kind: 'return_stmt', formula, source: src };
+    }
+    // --- export STATEMENT ---
+    parseExportDecl() {
+        const src = this.loc();
+        this.expect(tokens_1.TokenType.EXPORT);
+        const stmt = this.parseStatement();
+        if (!stmt) {
+            throw new Error('Se esperaba un statement después de "export"');
+        }
+        // Solo permitimos exportar declaraciones
+        const exportable = ['let_decl', 'axiom_decl', 'theorem_decl', 'fn_decl', 'theory_decl'];
+        if (!exportable.includes(stmt.kind)) {
+            throw new Error(`No se puede exportar un statement de tipo: ${stmt.kind}`);
+        }
+        return { kind: 'export_decl', statement: stmt, source: src };
+    }
+    // --- nombre(arg1, arg2) — llamada a función ---
+    parseFnCall() {
+        const src = this.loc();
+        const name = this.expectName();
+        this.expect(tokens_1.TokenType.LPAREN);
+        const args = [];
+        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+            args.push(this.parseFormula());
+            while (this.match(tokens_1.TokenType.COMMA)) {
+                args.push(this.parseFormula());
+            }
+        }
+        this.expect(tokens_1.TokenType.RPAREN);
+        return { kind: 'fn_call', name, args, source: src };
+    }
+    // --- obj.method(arg1, arg2) ---
+    parseMemberFnCall() {
+        const src = this.loc();
+        const obj = this.expectIdent();
+        this.expect(tokens_1.TokenType.DOT);
+        const method = this.expectIdent();
+        const fullName = `${obj}.${method}`;
+        this.expect(tokens_1.TokenType.LPAREN);
+        const args = [];
+        if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+            args.push(this.parseFormula());
+            while (this.match(tokens_1.TokenType.COMMA)) {
+                args.push(this.parseFormula());
+            }
+        }
+        this.expect(tokens_1.TokenType.RPAREN);
+        return { kind: 'fn_call', name: fullName, args, source: src };
+    }
+    // --- Helper: parsear un bloque { statements } ---
+    parseBlock() {
+        this.skipNewlines();
+        this.expect(tokens_1.TokenType.LBRACE);
+        this.skipNewlines();
+        const body = [];
+        while (!this.checkType(tokens_1.TokenType.RBRACE) && !this.isAtEnd()) {
+            this.skipNewlines();
+            if (this.checkType(tokens_1.TokenType.RBRACE))
+                break;
+            try {
+                const stmt = this.parseStatement();
+                if (stmt)
+                    body.push(stmt);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : 'Error de parseo en bloque';
+                this.diagnostics.push({
+                    severity: 'error',
+                    message,
+                    file: this.file,
+                    line: this.current().line,
+                    column: this.current().column,
+                });
+                this.advanceToNextStatement();
+            }
+        }
+        this.expect(tokens_1.TokenType.RBRACE);
+        return body;
     }
     // --- Parsing de fórmulas (precedencia) ---
     // Precedencia (de menor a mayor):
@@ -475,9 +730,11 @@ class Parser {
     }
     parseDisjunction() {
         let left = this.parseUntil();
-        while (this.match(tokens_1.TokenType.OR)) {
+        while (this.match(tokens_1.TokenType.OR) || this.match(tokens_1.TokenType.XOR) || this.match(tokens_1.TokenType.NOR)) {
+            const type = this.previous().type;
             const right = this.parseUntil();
-            left = { kind: 'or', args: [left, right], source: this.loc() };
+            const kind = type === tokens_1.TokenType.OR ? 'or' : (type === tokens_1.TokenType.XOR ? 'xor' : 'nor');
+            left = { kind, args: [left, right], source: this.loc() };
         }
         return left;
     }
@@ -490,14 +747,81 @@ class Parser {
         return left;
     }
     parseConjunction() {
+        let left = this.parseComparison();
+        while (this.match(tokens_1.TokenType.AND) || this.match(tokens_1.TokenType.NAND)) {
+            const type = this.previous().type;
+            const right = this.parseComparison();
+            const kind = type === tokens_1.TokenType.AND ? 'and' : 'nand';
+            left = { kind, args: [left, right], source: this.loc() };
+        }
+        return left;
+    }
+    // --- Arithmetic precedence ---
+    parseComparison() {
+        let left = this.parseAdditive();
+        while (this.checkType(tokens_1.TokenType.LT) ||
+            this.checkType(tokens_1.TokenType.GT) ||
+            this.checkType(tokens_1.TokenType.LTE) ||
+            this.checkType(tokens_1.TokenType.GTE)) {
+            if (this.match(tokens_1.TokenType.LT)) {
+                const right = this.parseAdditive();
+                left = { kind: 'less', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.GT)) {
+                const right = this.parseAdditive();
+                left = { kind: 'greater', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.LTE)) {
+                const right = this.parseAdditive();
+                left = { kind: 'less_eq', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.GTE)) {
+                const right = this.parseAdditive();
+                left = { kind: 'greater_eq', args: [left, right], source: this.loc() };
+            }
+        }
+        return left;
+    }
+    parseAdditive() {
+        let left = this.parseMultiplicative();
+        while (this.checkType(tokens_1.TokenType.PLUS) || this.checkType(tokens_1.TokenType.MINUS)) {
+            if (this.match(tokens_1.TokenType.PLUS)) {
+                const right = this.parseMultiplicative();
+                left = { kind: 'add', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.MINUS)) {
+                const right = this.parseMultiplicative();
+                left = { kind: 'subtract', args: [left, right], source: this.loc() };
+            }
+        }
+        return left;
+    }
+    parseMultiplicative() {
         let left = this.parseUnary();
-        while (this.match(tokens_1.TokenType.AND)) {
-            const right = this.parseUnary();
-            left = { kind: 'and', args: [left, right], source: this.loc() };
+        while (this.checkType(tokens_1.TokenType.STAR) ||
+            this.checkType(tokens_1.TokenType.SLASH) ||
+            this.checkType(tokens_1.TokenType.PERCENT)) {
+            if (this.match(tokens_1.TokenType.STAR)) {
+                const right = this.parseUnary();
+                left = { kind: 'multiply', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.SLASH)) {
+                const right = this.parseUnary();
+                left = { kind: 'divide', args: [left, right], source: this.loc() };
+            }
+            else if (this.match(tokens_1.TokenType.PERCENT)) {
+                const right = this.parseUnary();
+                left = { kind: 'modulo', args: [left, right], source: this.loc() };
+            }
         }
         return left;
     }
     parseUnary() {
+        // Unary minus: -expr → subtract(0, expr)
+        if (this.match(tokens_1.TokenType.MINUS)) {
+            const operand = this.parseUnary();
+            return { kind: 'subtract', args: [{ kind: 'number', value: 0, source: this.loc() }, operand], source: this.loc() };
+        }
         if (this.match(tokens_1.TokenType.NOT)) {
             const operand = this.parseUnary();
             return { kind: 'not', args: [operand], source: this.loc() };
@@ -527,6 +851,20 @@ class Parser {
         return this.parseAtom();
     }
     parseAtom() {
+        // Literal numérico
+        if (this.checkType(tokens_1.TokenType.NUMBER)) {
+            const tok = this.current();
+            this.advance();
+            return { kind: 'number', value: parseFloat(tok.value), source: { line: tok.line, column: tok.column } };
+        }
+        // Literal de texto (String)
+        if (this.checkType(tokens_1.TokenType.STRING)) {
+            const tok = this.current();
+            this.advance();
+            // Lo representamos como un átomo especial o un nuevo kind. 
+            // Por simplicidad para el motor lógico, lo tratamos como un átomo cuyo nombre es el valor del string entre comillas.
+            return { kind: 'atom', name: `"${tok.value}"`, source: { line: tok.line, column: tok.column } };
+        }
         // Paréntesis
         if (this.match(tokens_1.TokenType.LPAREN)) {
             const inner = this.parseFormula();
@@ -561,19 +899,37 @@ class Parser {
                 return { kind: 'atom', name: `${tok.value}.${memberTok.value}`, source: { line: tok.line, column: tok.column } };
             }
             if (this.match(tokens_1.TokenType.LPAREN)) {
+                // Podría ser un predicado P(x, y) o una llamada a función fn(arg1, arg2)
+                if (this.knownFunctionNames.has(tok.value) || this.knownTheoryNames.has(tok.value)) {
+                    const args = [];
+                    if (!this.checkType(tokens_1.TokenType.RPAREN)) {
+                        args.push(this.parseFormula());
+                        while (this.match(tokens_1.TokenType.COMMA)) {
+                            args.push(this.parseFormula());
+                        }
+                    }
+                    this.expect(tokens_1.TokenType.RPAREN);
+                    return {
+                        kind: 'fn_call',
+                        name: tok.value,
+                        args,
+                        source: { line: tok.line, column: tok.column },
+                    };
+                }
                 // Predicado: P(x, y, ...)
                 const args = [];
                 if (!this.checkType(tokens_1.TokenType.RPAREN)) {
-                    args.push(this.expectIdent());
+                    args.push(this.parseFormula());
                     while (this.match(tokens_1.TokenType.COMMA)) {
-                        args.push(this.expectIdent());
+                        args.push(this.parseFormula());
                     }
                 }
                 this.expect(tokens_1.TokenType.RPAREN);
+                const paramStrings = args.map((a) => this.formulaToString(a));
                 const predFormula = {
                     kind: 'predicate',
                     name: tok.value,
-                    params: args,
+                    params: paramStrings,
                     source: { line: tok.line, column: tok.column },
                 };
                 // FOL igualdad: P(x) = Q(y) (raro pero posible)
@@ -674,6 +1030,18 @@ class Parser {
                 return arg0 && arg1
                     ? `(${this.collectAssociativeArgs(f, 'or').map(a => this.formulaToString(a)).join(' | ')})`
                     : '(? | ?)';
+            case 'nand':
+                return arg0 && arg1
+                    ? `(${this.formulaToString(arg0)} ↑ ${this.formulaToString(arg1)})`
+                    : '(? ↑ ?)';
+            case 'nor':
+                return arg0 && arg1
+                    ? `(${this.formulaToString(arg0)} ↓ ${this.formulaToString(arg1)})`
+                    : '(? ↓ ?)';
+            case 'xor':
+                return arg0 && arg1
+                    ? `(${this.collectAssociativeArgs(f, 'xor').map(a => this.formulaToString(a)).join(' ⊕ ')})`
+                    : '(? ⊕ ?)';
             case 'implies':
                 return arg0 && arg1
                     ? `(${this.formulaToString(arg0)} -> ${this.formulaToString(arg1)})`
@@ -702,6 +1070,11 @@ class Parser {
         }
         return this.tokens[this.pos];
     }
+    previous() {
+        if (this.pos === 0)
+            return this.tokens[0];
+        return this.tokens[this.pos - 1];
+    }
     peek(offset) {
         const idx = this.pos + offset;
         if (idx >= this.tokens.length)
@@ -807,6 +1180,13 @@ class Parser {
             tokens_1.TokenType.SHOW,
             tokens_1.TokenType.QED,
             tokens_1.TokenType.THEORY,
+            tokens_1.TokenType.PRINT,
+            tokens_1.TokenType.SET,
+            tokens_1.TokenType.IF,
+            tokens_1.TokenType.FOR,
+            tokens_1.TokenType.WHILE,
+            tokens_1.TokenType.FN,
+            tokens_1.TokenType.RETURN,
         ]);
         while (!this.isAtEnd()) {
             if (this.checkType(tokens_1.TokenType.NEWLINE)) {