@stevenvo780/st-lang 3.1.2 → 3.1.3

package/dist/runtime/interpreter.js

@@ -19,6 +19,78 @@ const formula_factory_1 = require("./formula-factory");
 const MAX_CALL_DEPTH = 50000;
 const DEFAULT_MAX_RUNTIME_STEPS = 500000;
 const DEFAULT_MAX_RUNTIME_CALLS = 100000;
+/**
+ * Reemplaza el contenido de strings y comentarios con espacios,
+ * preservando newlines y longitudes. Se usa para escaneos léxicos previos
+ * (p.ej. detección de `logic`) sin falsos positivos dentro de literales o
+ * comentarios.
+ */
+function stripStringsAndComments(source) {
+    const out = [];
+    let i = 0;
+    const n = source.length;
+    while (i < n) {
+        const c = source[i];
+        const next = i + 1 < n ? source[i + 1] : '';
+        if (c === '/' && next === '/') {
+            out.push('  ');
+            i += 2;
+            while (i < n && source[i] !== '\n') {
+                out.push(' ');
+                i++;
+            }
+            continue;
+        }
+        if (c === '/' && next === '*') {
+            out.push('  ');
+            i += 2;
+            while (i < n && !(source[i] === '*' && source[i + 1] === '/')) {
+                out.push(source[i] === '\n' ? '\n' : ' ');
+                i++;
+            }
+            if (i < n) {
+                out.push('  ');
+                i += 2;
+            }
+            continue;
+        }
+        if (c === '"' || c === "'") {
+            const quote = c;
+            out.push(' ');
+            i++;
+            while (i < n && source[i] !== quote) {
+                if (source[i] === '\\' && i + 1 < n) {
+                    out.push(source[i + 1] === '\n' ? ' \n' : '  ');
+                    i += 2;
+                    continue;
+                }
+                out.push(source[i] === '\n' ? '\n' : ' ');
+                i++;
+            }
+            if (i < n) {
+                out.push(' ');
+                i++;
+            }
+            continue;
+        }
+        if (c === '[' && next === '[') {
+            out.push('  ');
+            i += 2;
+            while (i < n && !(source[i] === ']' && source[i + 1] === ']')) {
+                out.push(source[i] === '\n' ? '\n' : ' ');
+                i++;
+            }
+            if (i < n) {
+                out.push('  ');
+                i += 2;
+            }
+            continue;
+        }
+        out.push(c);
+        i++;
+    }
+    return out.join('');
+}
 class Interpreter {
     theory;
     profile = null;
@@ -98,7 +170,8 @@ class Interpreter {
             judgments: [],
         };
     }
-    importedFiles = new Set();
+    importedFiles = new Map();
+    activeImports = new Set();
     reset() {
         this.theory = this.createEmptyTheory();
         this.textLayer = (0, compiler_1.createTextLayerState)();
@@ -107,6 +180,7 @@ class Interpreter {
         this.stdoutLines = [];
         this.profile = null;
         this.importedFiles.clear();
+        this.activeImports.clear();
         this.letBindings.clear();
         this.letDescriptions.clear();
         this.theories.clear();
@@ -326,7 +400,8 @@ class Interpreter {
         // Pre-scan for profile declarations to enable profile-aware lexing.
         // Only restrict keywords when there's exactly one profile in the source.
         // Multi-profile files use all keywords for safety.
-        const profileMatches = source.match(/(?:^|\n)\s*(?:logic|logica)\s+([\w.]+)/g);
+        const scanSource = stripStringsAndComments(source);
+        const profileMatches = scanSource.match(/(?:^|\n)\s*(?:logic|logica)\s+([\w.]+)/g);
         let detectedProfile;
         if (profileMatches && profileMatches.length === 1) {
             const m = profileMatches[0].match(/(?:logic|logica)\s+([\w.]+)/);
@@ -818,6 +893,27 @@ class Interpreter {
         }
         return p;
     }
+    /**
+     * Construye una teoría efímera que combina axiomas + teoremas + letBindings
+     * SIN mutar la teoría persistente. Los letBindings quedan accesibles por nombre
+     * como si fueran axiomas, pero solo para esta llamada a derive/prove.
+     * Axiomas/teoremas reales tienen prioridad sobre letBindings con el mismo nombre.
+     */
+    buildEphemeralTheory() {
+        const axioms = new Map(this.theory.axioms);
+        for (const [name, formula] of this.letBindings) {
+            if (!axioms.has(name) && !this.theory.theorems.has(name)) {
+                axioms.set(name, formula);
+            }
+        }
+        return {
+            profile: this.theory.profile,
+            axioms,
+            theorems: this.theory.theorems,
+            claims: this.theory.claims,
+            judgments: this.theory.judgments,
+        };
+    }
     /**
      * Sustituye recursivamente los átomos que coincidan con variables `let`
      * por sus fórmulas definidas. Detecta ciclos para evitar recursión infinita.
@@ -826,6 +922,7 @@ class Interpreter {
     invalidateResolveCache() {
         this.resolveCache = new WeakMap();
         this.resolveCacheGeneration++;
+        this.fnMemoCache.clear();
     }
     resolveFormula(f, visited = new Set()) {
         // Check resolution cache first
@@ -977,6 +1074,7 @@ class Interpreter {
         const diags = profile.checkWellFormed(resolved);
         this.diagnostics.push(...diags);
         this.theory.axioms.set(stmt.name, resolved);
+        this.invalidateResolveCache();
         this.emit(`Axioma ${stmt.name} = ${(0, propositional_1.formulaToString)(resolved)}`);
     }
     execTheoremDecl(stmt) {
@@ -985,6 +1083,7 @@ class Interpreter {
         const diags = profile.checkWellFormed(resolved);
         this.diagnostics.push(...diags);
         this.theory.theorems.set(stmt.name, resolved);
+        this.invalidateResolveCache();
         this.emit(`Teorema ${stmt.name} = ${(0, propositional_1.formulaToString)(resolved)}`);
     }
     execDeriveCmd(stmt) {
@@ -1023,7 +1122,7 @@ class Interpreter {
                 });
             }
         }
-        const result = profile.derive(resolved, stmt.premises, this.theory);
+        const result = profile.derive(resolved, stmt.premises, this.buildEphemeralTheory());
         this.results.push(result);
         this.emitResult('derive', result);
         // Auto-register successful derivations as theorems so they can be reused.
@@ -1033,8 +1132,6 @@ class Interpreter {
             result.proof?.method !== 'semantic') {
             const theoremName = `derived_${this.theory.theorems.size + 1}`;
             this.theory.theorems.set(theoremName, resolved);
-            // Also register as axiom so it can be used as premise in subsequent derives
-            this.theory.axioms.set(theoremName, resolved);
         }
     }
     execCheckValidCmd(stmt) {
@@ -1065,7 +1162,7 @@ class Interpreter {
     execProveCmd(stmt) {
         const profile = this.requireProfile();
         const resolved = this.resolveFormula(stmt.goal);
-        const result = profile.prove(resolved, this.theory, stmt.premises);
+        const result = profile.prove(resolved, this.buildEphemeralTheory(), stmt.premises);
         this.results.push(result);
         this.emitResult('prove', result);
     }
@@ -1081,6 +1178,10 @@ class Interpreter {
         const formula = this.resolveFormula(stmt.formula);
         if (profile.name === 'classical.propositional') {
             const atoms = Array.from((0, propositional_1.collectAtoms)(formula)).sort();
+            const MAX_STREAMING_TRUTH_TABLE_ATOMS = 20;
+            if (atoms.length > MAX_STREAMING_TRUTH_TABLE_ATOMS) {
+                throw new Error(`truth_table soporta hasta ${MAX_STREAMING_TRUTH_TABLE_ATOMS} variables en lógica clásica proposicional`);
+            }
             // Streaming de tabla de verdad para evitar OOM
             this.emit(`Tabla de verdad para ${(0, propositional_1.formulaToString)(formula)}:`);
             this.emit(`  ${atoms.join(' | ')} | Resultado`);
@@ -1184,8 +1285,8 @@ class Interpreter {
             // Resolve bindings but preserve symbolic structure (no constant-folding)
             const resolved = this.resolveFormulaRecursive(stmt.formula, new Set());
             this.defineBinding(stmt.name, resolved, 'description' in stmt ? stmt.description : undefined);
-            if (!this.currentBindingFrame)
-                this.theory.axioms.set(stmt.name, resolved);
+            // Note: `let` es un alias semántico, no un axioma.
+            // Se mantiene accesible como premisa por nombre vía letBindings (ver execDeriveCmd).
             if ('description' in stmt && stmt.description) {
                 if (!this.currentBindingFrame)
                     this.letDescriptions.set(stmt.name, stmt.description);
@@ -1422,6 +1523,7 @@ class Interpreter {
     execProofBlock(stmt) {
         const profile = this.requireProfile();
         const savedAxioms = new Map(this.theory.axioms);
+        const savedTheorems = new Map(this.theory.theorems);
         const savedLetBindings = new Map(this.letBindings);
         const savedLetDescriptions = new Map(this.letDescriptions);
         this.emit('── Proof Block ──');
@@ -1440,21 +1542,31 @@ class Interpreter {
         ]));
         const result = profile.derive(resolvedGoal, premiseNames, this.theory);
         this.results.push(result);
-        if (result.status === 'valid' || result.status === 'provable') {
+        const succeeded = result.status === 'valid' || result.status === 'provable';
+        let theoremPayload;
+        if (succeeded) {
             this.emit(`  ✓ QED — ${(0, format_1.formulaToUnicode)(resolvedGoal)} demostrado`);
-            const theoremName = `proof_${this.theory.theorems.size + 1}`;
+            // Build implication from resolved assumption formulas so bindings are captured
             let implication = resolvedGoal;
             for (let i = stmt.assumptions.length - 1; i >= 0; i--) {
-                implication = { kind: 'implies', args: [stmt.assumptions[i].formula, implication] };
+                const assumedResolved = this.resolveFormula(stmt.assumptions[i].formula);
+                implication = { kind: 'implies', args: [assumedResolved, implication] };
             }
-            this.theory.theorems.set(theoremName, implication);
+            const theoremName = `proof_${savedTheorems.size + 1}`;
+            theoremPayload = { name: theoremName, formula: implication };
         }
         else {
             this.emit(`  ✗ QED fallido — no se pudo demostrar ${(0, format_1.formulaToUnicode)(resolvedGoal)}`);
         }
+        // Restore full theory state — proof blocks must be hypothetical
         this.theory.axioms = savedAxioms;
+        this.theory.theorems = savedTheorems;
         this.letBindings = savedLetBindings;
         this.letDescriptions = savedLetDescriptions;
+        // Only the resulting implication (if any) survives the block
+        if (theoremPayload) {
+            this.theory.theorems.set(theoremPayload.name, theoremPayload.formula);
+        }
         this.invalidateResolveCache();
         this.emit('── End Proof Block ──');
     }
@@ -2491,30 +2603,34 @@ class Interpreter {
         return Array.from(seen);
     }
     execImportDecl(stmt) {
-        let filePath = stmt.path;
-        if (!filePath.endsWith('.st'))
-            filePath += '.st';
-        if (this.importedFiles.has(filePath))
-            return;
-        this.importedFiles.add(filePath);
+        let requestedPath = stmt.path;
+        if (!requestedPath.endsWith('.st'))
+            requestedPath += '.st';
         let source;
+        let resolved;
         try {
             // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const fs = require('fs');
             // eslint-disable-next-line @typescript-eslint/no-require-imports, @typescript-eslint/no-unsafe-assignment
             const path = require('path');
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-            const resolved = path.isAbsolute(filePath)
-                ? filePath
+            resolved = path.isAbsolute(requestedPath)
+                ? requestedPath
                 : // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-                    path.resolve(path.dirname(stmt.source.file || '.'), filePath);
+                    path.resolve(path.dirname(stmt.source.file || '.'), requestedPath);
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
             source = fs.readFileSync(resolved, 'utf-8');
         }
         catch {
-            throw new Error(`No se pudo importar '${filePath}'`);
+            throw new Error(`No se pudo importar '${requestedPath}'`);
         }
-        const parser = new parser_1.Parser(filePath);
+        if (this.activeImports.has(resolved))
+            return;
+        if (this.importedFiles.get(resolved) === source)
+            return;
+        this.activeImports.add(resolved);
+        this.importedFiles.set(resolved, source);
+        const parser = new parser_1.Parser(resolved);
         const program = parser.parse(source);
         this.diagnostics.push(...parser.diagnostics);
         const prevIsImporting = this.isImporting;
@@ -2523,37 +2639,60 @@ class Interpreter {
         const prevTheorems = new Map(this.theory.theorems);
         const prevFunctions = new Map(this.functions);
         const prevTheories = new Map(this.theories);
-        this.isImporting = true;
-        this.letBindings.clear();
-        this.theory.axioms.clear();
-        this.theory.theorems.clear();
-        this.functions.clear();
-        this.theories.clear();
-        for (const importedStmt of program.statements)
-            this.executeStatement(importedStmt);
-        const newExports = {
-            bindings: new Map(this.exportedBindings),
-            axioms: new Map(this.exportedAxioms),
-            theorems: new Map(this.exportedTheorems),
-            functions: new Map(this.exportedFunctions),
-            theories: new Map(this.exportedTheories),
-        };
-        this.isImporting = prevIsImporting;
-        this.letBindings = prevLetBindings;
-        this.theory.axioms = prevAxioms;
-        this.theory.theorems = prevTheorems;
-        this.functions = prevFunctions;
-        this.theories = prevTheories;
-        for (const [k, v] of newExports.bindings)
+        const prevExportedBindings = new Map(this.exportedBindings);
+        const prevExportedAxioms = new Map(this.exportedAxioms);
+        const prevExportedTheorems = new Map(this.exportedTheorems);
+        const prevExportedFunctions = new Map(this.exportedFunctions);
+        const prevExportedTheories = new Map(this.exportedTheories);
+        // eslint-disable-next-line no-useless-assignment -- needed as fallback if try block throws
+        let newExports = null;
+        try {
+            this.isImporting = true;
+            this.letBindings.clear();
+            this.theory.axioms.clear();
+            this.theory.theorems.clear();
+            this.functions.clear();
+            this.theories.clear();
+            this.exportedBindings.clear();
+            this.exportedAxioms.clear();
+            this.exportedTheorems.clear();
+            this.exportedFunctions.clear();
+            this.exportedTheories.clear();
+            for (const importedStmt of program.statements)
+                this.executeStatement(importedStmt);
+            newExports = {
+                bindings: new Map(this.exportedBindings),
+                axioms: new Map(this.exportedAxioms),
+                theorems: new Map(this.exportedTheorems),
+                functions: new Map(this.exportedFunctions),
+                theories: new Map(this.exportedTheories),
+            };
+        }
+        finally {
+            this.isImporting = prevIsImporting;
+            this.letBindings = prevLetBindings;
+            this.theory.axioms = prevAxioms;
+            this.theory.theorems = prevTheorems;
+            this.functions = prevFunctions;
+            this.theories = prevTheories;
+            this.exportedBindings = prevExportedBindings;
+            this.exportedAxioms = prevExportedAxioms;
+            this.exportedTheorems = prevExportedTheorems;
+            this.exportedFunctions = prevExportedFunctions;
+            this.exportedTheories = prevExportedTheories;
+            this.activeImports.delete(resolved);
+        }
+        for (const [k, v] of newExports?.bindings ?? [])
             this.letBindings.set(k, v);
-        for (const [k, v] of newExports.axioms)
+        for (const [k, v] of newExports?.axioms ?? [])
             this.theory.axioms.set(k, v);
-        for (const [k, v] of newExports.theorems)
+        for (const [k, v] of newExports?.theorems ?? [])
             this.theory.theorems.set(k, v);
-        for (const [k, v] of newExports.functions)
+        for (const [k, v] of newExports?.functions ?? [])
             this.functions.set(k, v);
-        for (const [k, v] of newExports.theories)
+        for (const [k, v] of newExports?.theories ?? [])
             this.theories.set(k, v);
+        this.invalidateResolveCache();
     }
     execExplainCmd(stmt) {
         const profile = this.requireProfile();