@designliquido/delegua 1.27.2 → 1.28.0

package/interpretador/interpretador.js

@@ -9,6 +9,7 @@ const estruturas_1 = require("./estruturas");
 const interpretador_base_1 = require("./interpretador-base");
 const inferenciador_1 = require("../inferenciador");
 const excecoes_1 = require("../excecoes");
+const encadear_1 = require("./encadear");
 const declaracoes_1 = require("../declaracoes");
 const quebras_1 = require("../quebras");
 const montao_1 = require("./montao");
@@ -215,16 +216,16 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         }
         return objeto.toString();
     }
-    async avaliacaoDeclaracaoVarOuConst(declaracao) {
-        let valorOuOutraVariavel = null;
-        if (declaracao.inicializador != null) {
-            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
-        }
-        let valorFinal = null;
-        if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
-            valorFinal = this.resolverValor(valorOuOutraVariavel);
+    avaliacaoDeclaracaoVarOuConst(declaracao) {
+        if (declaracao.inicializador == null) {
+            return null;
         }
-        return valorFinal;
+        return (0, encadear_1.encadear)(this.avaliar(declaracao.inicializador), (valorOuOutraVariavel) => {
+            if (valorOuOutraVariavel !== null && valorOuOutraVariavel !== undefined) {
+                return this.resolverValor(valorOuOutraVariavel);
+            }
+            return null;
+        });
     }
     /**
      * Declaração de ajuda.
@@ -298,7 +299,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         return this.resolverValor(await this.avaliar(expressaoDecoradora), true);
     }
     async visitarDeclaracaoDefinicaoFuncao(declaracao) {
-        let funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+        let funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao).capturarEscopo(this.pilhaEscoposExecucao);
         funcao.documentacao = declaracao.documentacao;
         if (declaracao.decoradores && declaracao.decoradores.length > 0) {
             for (const decorador of [...declaracao.decoradores].reverse()) {
@@ -338,53 +339,76 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             declaracao: funcao,
         });
     }
-    async logicaComumExecucaoEnquanto(enquanto, acumularRetornos) {
+    logicaComumExecucaoEnquanto(enquanto, acumularRetornos) {
         const retornos = [];
         let retornoExecucao = undefined;
         let iteracoes = 0;
-        while ((acumularRetornos ||
-            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
-            this.eVerdadeiro(await this.avaliar(enquanto.condicao))) {
-            try {
-                if (this.funcaoVerificarIteracao) {
-                    await this.funcaoVerificarIteracao();
+        const finalizarNormal = () => {
+            if (acumularRetornos) {
+                return {
+                    valorRetornado: retornos,
+                    tipo: 'vetor',
+                };
+            }
+            return retornoExecucao;
+        };
+        const tratarErro = (erro) => {
+            this.erros.push({
+                erroInterno: erro,
+                linha: enquanto.linha,
+                hashArquivo: enquanto.hashArquivo,
+            });
+            return Promise.reject(erro);
+        };
+        const proximaIteracao = () => {
+            // Curto-circuito: espelha `(acumularRetornos || !(...Quebra)) && eVerdadeiro(...)` —
+            // se a primeira parte já é falsa, nem avalia a condição do laço.
+            if (!acumularRetornos &&
+                retornoExecucao &&
+                retornoExecucao.valorRetornado instanceof quebras_1.Quebra) {
+                return finalizarNormal();
+            }
+            return (0, encadear_1.encadear)(this.avaliar(enquanto.condicao), (condicaoBruta) => {
+                if (!this.eVerdadeiro(condicaoBruta)) {
+                    return finalizarNormal();
                 }
-                await this.cederControle(++iteracoes);
-                retornoExecucao = await this.executar(enquanto.corpo);
-                if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
+                const corpoIteracao = () => (0, encadear_1.encadear)(this.cederControle(++iteracoes), () => (0, encadear_1.encadear)(this.executar(enquanto.corpo), (resultado) => {
+                    retornoExecucao = resultado;
+                    if (retornoExecucao &&
+                        retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
+                        if (acumularRetornos) {
+                            return {
+                                valorRetornado: retornos,
+                                tipo: 'vetor',
+                            };
+                        }
+                        return null;
+                    }
+                    if (retornoExecucao &&
+                        retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
+                        retornoExecucao = undefined;
+                    }
                     if (acumularRetornos) {
-                        return {
-                            valorRetornado: retornos,
-                            tipo: 'vetor',
-                        };
+                        retornos.push(this.resolverValor(retornoExecucao));
                     }
-                    return null;
-                }
-                if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = undefined;
+                    return proximaIteracao();
+                }));
+                try {
+                    const resultadoOuPromise = this.funcaoVerificarIteracao
+                        ? (0, encadear_1.encadear)(this.funcaoVerificarIteracao(), () => corpoIteracao())
+                        : corpoIteracao();
+                    return resultadoOuPromise instanceof Promise
+                        ? resultadoOuPromise.catch(tratarErro)
+                        : resultadoOuPromise;
                 }
-                if (acumularRetornos) {
-                    retornos.push(this.resolverValor(retornoExecucao));
+                catch (erro) {
+                    return tratarErro(erro);
                 }
-            }
-            catch (erro) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: enquanto.linha,
-                    hashArquivo: enquanto.hashArquivo,
-                });
-                return Promise.reject(erro);
-            }
-        }
-        if (acumularRetornos) {
-            return {
-                valorRetornado: retornos,
-                tipo: 'vetor',
-            };
-        }
-        return retornoExecucao;
+            });
+        };
+        return proximaIteracao();
     }
-    async visitarDeclaracaoEnquanto(declaracao) {
+    visitarDeclaracaoEnquanto(declaracao) {
         return this.logicaComumExecucaoEnquanto(declaracao, false);
     }
     async logicaComumExecucaoFazer(fazer, acumularRetornos) {
@@ -435,54 +459,63 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarDeclaracaoFazer(declaracao) {
         return this.logicaComumExecucaoFazer(declaracao, false);
     }
-    async logicaComumExecucaoPara(para, acumularRetornos) {
+    logicaComumExecucaoPara(para, acumularRetornos) {
         const declaracaoInicializador = Array.isArray(para.inicializador)
             ? para.inicializador[0]
             : para.inicializador;
-        if (declaracaoInicializador !== null && declaracaoInicializador !== undefined) {
-            await this.avaliar(declaracaoInicializador);
-        }
         const retornos = [];
         let retornoExecucao = undefined;
         let iteracoes = 0;
-        while (acumularRetornos ||
-            !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
-            if (para.condicao !== null && !this.eVerdadeiro(await this.avaliar(para.condicao))) {
-                break;
-            }
-            if (this.funcaoVerificarIteracao) {
-                await this.funcaoVerificarIteracao();
-            }
-            await this.cederControle(++iteracoes);
-            retornoExecucao = await this.executar(para.corpo);
-            if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
-                if (acumularRetornos) {
-                    return {
-                        valorRetornado: retornos,
-                        tipo: 'vetor',
-                    };
-                }
-                return undefined;
-            }
-            if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                retornoExecucao = undefined;
-            }
-            if (acumularRetornos) {
-                retornos.push(this.resolverValor(retornoExecucao));
-            }
-            if (para.incrementar !== null) {
-                await this.avaliar(para.incrementar);
-            }
-        }
-        if (acumularRetornos) {
-            return {
-                valorRetornado: retornos,
-                tipo: 'vetor',
+        const finalizarAcumulado = () => ({
+            valorRetornado: retornos,
+            tipo: 'vetor',
+        });
+        const proximaIteracao = () => {
+            if (!(acumularRetornos ||
+                !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra))) {
+                return acumularRetornos ? finalizarAcumulado() : retornoExecucao;
+            }
+            const continuarAposCondicao = () => {
+                const corpoIteracao = () => (0, encadear_1.encadear)(this.cederControle(++iteracoes), () => (0, encadear_1.encadear)(this.executar(para.corpo), (resultado) => {
+                    retornoExecucao = resultado;
+                    if (retornoExecucao &&
+                        retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
+                        if (acumularRetornos)
+                            return finalizarAcumulado();
+                        return undefined;
+                    }
+                    if (retornoExecucao &&
+                        retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
+                        retornoExecucao = undefined;
+                    }
+                    if (acumularRetornos) {
+                        retornos.push(this.resolverValor(retornoExecucao));
+                    }
+                    if (para.incrementar !== null) {
+                        return (0, encadear_1.encadear)(this.avaliar(para.incrementar), () => proximaIteracao());
+                    }
+                    return proximaIteracao();
+                }));
+                return this.funcaoVerificarIteracao
+                    ? (0, encadear_1.encadear)(this.funcaoVerificarIteracao(), () => corpoIteracao())
+                    : corpoIteracao();
             };
+            if (para.condicao !== null) {
+                return (0, encadear_1.encadear)(this.avaliar(para.condicao), (condicaoBruta) => {
+                    if (!this.eVerdadeiro(condicaoBruta)) {
+                        return acumularRetornos ? finalizarAcumulado() : retornoExecucao;
+                    }
+                    return continuarAposCondicao();
+                });
+            }
+            return continuarAposCondicao();
+        };
+        if (declaracaoInicializador !== null && declaracaoInicializador !== undefined) {
+            return (0, encadear_1.encadear)(this.avaliar(declaracaoInicializador), () => proximaIteracao());
         }
-        return retornoExecucao;
+        return proximaIteracao();
     }
-    async visitarDeclaracaoPara(declaracao) {
+    visitarDeclaracaoPara(declaracao) {
         return this.logicaComumExecucaoPara(declaracao, false);
     }
     /**
@@ -672,7 +705,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 continue;
             }
             const eInicializador = nomeMetodo === 'construtor';
-            const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoAtual.funcao, undefined, eInicializador);
+            const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoAtual.funcao, undefined, eInicializador).capturarEscopo(this.pilhaEscoposExecucao);
             funcao.documentacao = metodoAtual.documentacao;
             // Numa classe estática, todos os métodos (exceto construtor) são estáticos.
             const ehEstatico = declaracao.classeEstatica ? !eInicializador : metodoAtual.estatico;
@@ -1477,7 +1510,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 return (0, inferenciador_1.inferirTipoVariavel)(valorTipoDe);
         }
     }
-    async visitarExpressaoUnaria(expressao) {
+    visitarExpressaoUnaria(expressao) {
         // Tratamento especial para expressões unárias aplicadas a chamadas de método em literais numéricos.
         // Por exemplo: -5.absoluto() deve ser avaliado como (-5).absoluto(), não como -(5.absoluto())
         // Isso garante que o operador unário seja aplicado ao literal antes de chamar o método.
@@ -1506,12 +1539,12 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                     // Cria uma nova Chamada com o acesso modificado
                     const novaChamada = new construtos_1.Chamada(expressao.operando.hashArquivo, novoAcesso, expressao.operando.argumentos);
                     // Avalia a nova chamada
-                    return await this.avaliar(novaChamada);
+                    return this.avaliar(novaChamada);
                 }
             }
         }
         // Para outros casos, usa o comportamento padrão
-        return await super.visitarExpressaoUnaria(expressao);
+        return super.visitarExpressaoUnaria(expressao);
     }
     async visitarExpressaoVetor(expressao) {
         // Delega ao interpretador base para processar o vetor
@@ -1531,33 +1564,13 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
      * @param manterAmbiente Se verdadeiro, ambiente do topo da pilha de escopo é copiado para o ambiente imediatamente abaixo.
      * @returns O resultado da execução do escopo, se houver.
      */
-    async executarUltimoEscopo(manterAmbiente = false) {
+    executarUltimoEscopo(manterAmbiente = false) {
         const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
         let retornoExecucao = undefined;
-        try {
-            for (; !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) &&
-                ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
-                const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
-                this.linhaDeclaracaoAtual = declaracaoAtual.linha;
-                this.hashArquivoDeclaracaoAtual = declaracaoAtual.hashArquivo;
-                retornoExecucao = await this.executar(declaracaoAtual);
-            }
-            return retornoExecucao;
-        }
-        catch (erro) {
-            const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
-            if (!this.emDeclaracaoTente) {
-                this.erros.push({
-                    erroInterno: erro,
-                    linha: declaracaoAtual.linha,
-                    hashArquivo: declaracaoAtual.hashArquivo,
-                });
-            }
-            else {
-                return Promise.reject(erro);
-            }
-        }
-        finally {
+        // Substitui o `finally` original: precisa rodar em toda saída (sucesso, erro síncrono
+        // ou rejeição assíncrona), então é chamado explicitamente em cada um desses três casos
+        // abaixo, nunca implicitamente — não há `finally` de verdade quando não se usa `await`.
+        const finalizar = () => {
             const escopoFinalizado = this.pilhaEscoposExecucao.removerUltimo();
             const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
             if (manterAmbiente ||
@@ -1571,6 +1584,47 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             else {
                 this.montao.excluirReferencias(...escopoFinalizado.espacoMemoria.enderecosMontao);
             }
+        };
+        const tratarErro = (erro) => {
+            try {
+                const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
+                if (!this.emDeclaracaoTente) {
+                    this.erros.push({
+                        erroInterno: erro,
+                        linha: declaracaoAtual.linha,
+                        hashArquivo: declaracaoAtual.hashArquivo,
+                    });
+                    return undefined;
+                }
+                return Promise.reject(erro);
+            }
+            finally {
+                finalizar();
+            }
+        };
+        const proximaDeclaracao = () => {
+            if ((retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) ||
+                ultimoEscopo.declaracaoAtual >= ultimoEscopo.declaracoes.length) {
+                finalizar();
+                return retornoExecucao;
+            }
+            const declaracaoAtual = ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual];
+            this.linhaDeclaracaoAtual = declaracaoAtual.linha;
+            this.hashArquivoDeclaracaoAtual = declaracaoAtual.hashArquivo;
+            return (0, encadear_1.encadear)(this.executar(declaracaoAtual), (resultado) => {
+                retornoExecucao = resultado;
+                ultimoEscopo.declaracaoAtual++;
+                return proximaDeclaracao();
+            });
+        };
+        try {
+            const resultadoOuPromise = proximaDeclaracao();
+            return resultadoOuPromise instanceof Promise
+                ? resultadoOuPromise.catch(tratarErro)
+                : resultadoOuPromise;
+        }
+        catch (erro) {
+            return tratarErro(erro);
         }
     }
     async visitarExpressaoTuplaN(expressao) {