@designliquido/delegua 1.27.2 → 1.28.0

package/interpretador/interpretador-base.js

@@ -15,6 +15,7 @@ const lexador_1 = require("../lexador");
 const avaliador_sintatico_1 = require("../avaliador-sintatico");
 const espaco_memoria_1 = require("./espaco-memoria");
 const excecoes_1 = require("../excecoes");
+const encadear_1 = require("./encadear");
 const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
 const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const primitivos_1 = __importDefault(require("../tipos-de-dados/primitivos"));
@@ -92,13 +93,14 @@ class InterpretadorBase {
         this.pilhaEscoposExecucao.definirVariavel('Excecao', estruturas_1.EXCECAO_BASE);
     }
     /**
-     * Cede o controle ao loop de eventos do JavaScript.
-     * Usado em laços de repetição para evitar bloqueio do loop de eventos
-     * em iterações longas ou infinitas.
+     * Cede o controle ao loop de eventos do JavaScript, mas só de fato a cada
+     * `iteracoesParaCederControle` chamadas — nos outros casos retorna `undefined` diretamente,
+     * sem alocar Promise nem agendar microtarefa, já que isto é chamado em toda iteração de todo
+     * laço (`enquanto`, `para`) e o custo de um `await` "inútil" 999 em 1000 vezes se acumula.
      */
-    async cederControle(iteracoes) {
+    cederControle(iteracoes) {
         if (iteracoes % this.iteracoesParaCederControle === 0) {
-            await new Promise((resolve) => {
+            return new Promise((resolve) => {
                 const _setImmediate = globalThis.setImmediate;
                 if (_setImmediate) {
                     _setImmediate(resolve);
@@ -108,6 +110,7 @@ class InterpretadorBase {
                 }
             });
         }
+        return undefined;
     }
     visitarDeclaracaoTextoDocumentacao(declaracao) {
         throw new Error('Método não implementado.');
@@ -331,7 +334,7 @@ class InterpretadorBase {
      * @param expressao A expressão, que pode ser um construto ou declaração.
      * @returns O retorno da execução do método de visita chamado.
      */
-    async avaliar(expressao) {
+    avaliar(expressao) {
         // Descomente o código abaixo quando precisar detectar expressões undefined ou nulas.
         // Por algum motivo o depurador do VSCode não funciona direito aqui
         // com breakpoint condicional.
@@ -341,7 +344,7 @@ class InterpretadorBase {
         if (expressao.hashArquivo >= 0 && expressao.linha >= 0) {
             this.registrarExpressao?.(expressao.hashArquivo, expressao.linha);
         }
-        return await expressao.aceitar(this);
+        return expressao.aceitar(this);
     }
     /**
      * Execução da leitura de valores da entrada configurada no
@@ -427,11 +430,10 @@ class InterpretadorBase {
             return { expressaoInterpolacao, valor };
         }));
     }
-    async visitarExpressaoLiteral(expressao) {
+    visitarExpressaoLiteral(expressao) {
         if (this.regexInterpolacao.test(String(expressao.valor))) {
             const valorComoTexto = String(expressao.valor);
-            const interpolacoes = await this.resolverInterpolacoes(valorComoTexto, expressao.linha);
-            return this.retirarInterpolacao(valorComoTexto, interpolacoes);
+            return (0, encadear_1.encadear)(this.resolverInterpolacoes(valorComoTexto, expressao.linha), (interpolacoes) => this.retirarInterpolacao(valorComoTexto, interpolacoes));
         }
         return expressao.valor;
     }
@@ -443,12 +445,13 @@ class InterpretadorBase {
      * @returns O resultado da avaliação.
      * @see this.visitarExpressaoDeChamada
      */
-    async visitarExpressaoAgrupamento(expressao) {
-        const avaliacaoAgrupamento = await this.avaliar(expressao.expressao);
-        if (avaliacaoAgrupamento !== null && avaliacaoAgrupamento.declaracao) {
-            return avaliacaoAgrupamento.declaracao;
-        }
-        return avaliacaoAgrupamento;
+    visitarExpressaoAgrupamento(expressao) {
+        return (0, encadear_1.encadear)(this.avaliar(expressao.expressao), (avaliacaoAgrupamento) => {
+            if (avaliacaoAgrupamento !== null && avaliacaoAgrupamento.declaracao) {
+                return avaliacaoAgrupamento.declaracao;
+            }
+            return avaliacaoAgrupamento;
+        });
     }
     eVerdadeiro(objeto) {
         if (objeto === null || objeto === undefined)
@@ -469,63 +472,87 @@ class InterpretadorBase {
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operando precisa ser um número.', Number(operador.linha));
     }
-    async visitarExpressaoUnaria(expressao) {
-        const operando = await this.avaliar(expressao.operando);
-        let valor = this.resolverValor(operando);
-        switch (expressao.operador.tipo) {
-            case delegua_1.default.ADICAO:
-                this.verificarOperandoNumero(expressao.operador, valor);
-                return +valor;
-            case delegua_1.default.SUBTRACAO:
-                this.verificarOperandoNumero(expressao.operador, valor);
-                return -valor;
-            case delegua_1.default.NEGACAO:
-            case delegua_1.default.NAO:
-                return !this.eVerdadeiro(valor);
-            case delegua_1.default.BIT_NOT:
-                if (typeof valor === 'bigint') {
-                    return ~valor;
-                }
-                this.verificarOperandoNumero(expressao.operador, valor);
-                return ~Number(valor);
-            // Para incrementar e decrementar, primeiro precisamos saber se o operador
-            // veio antes do literal ou variável.
-            // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
-            // armazenar o valor da variável pra só então devolver o valor.
-            case delegua_1.default.INCREMENTAR:
-                if (typeof valor === 'string') {
-                    throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, `Operador '${expressao.operador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
-                }
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor++;
-                    if (expressao.operando instanceof construtos_1.Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+    /**
+     * Atribui `valor` de volta ao operando de um unário de incremento/decremento
+     * (`++operando` / `operando++` / `--operando` / `operando--`).
+     * Suporta variáveis simples e elementos de vetor/dicionário acessados por índice
+     * (ex.: `x[0]++`). Outros tipos de operando (literais, chamadas, etc.) apenas
+     * devolvem o valor, sem persistir a mudança em lugar nenhum.
+     * @param operando O construto à esquerda/direita do operador de incremento/decremento.
+     * @param valor O novo valor a ser armazenado.
+     * @returns {any} O próprio `valor`, possivelmente encadeado numa `Promise`.
+     */
+    atribuirValorAoOperandoUnario(operando, valor) {
+        if (operando instanceof construtos_1.Variavel) {
+            this.pilhaEscoposExecucao.atribuirVariavel(operando.simbolo, valor);
+            return valor;
+        }
+        if (operando instanceof construtos_1.AcessoIndiceVariavel) {
+            return (0, encadear_1.encadear)(this.avaliar(operando.entidadeChamada), (entidadeBruta) => {
+                const entidade = this.resolverValor(entidadeBruta);
+                return (0, encadear_1.encadear)(this.avaliar(operando.indice), (indiceBruto) => {
+                    let indice = this.resolverValor(indiceBruto);
+                    if (Array.isArray(entidade)) {
+                        if (indice < 0 && entidade.length !== 0) {
+                            while (indice < 0) {
+                                indice += entidade.length;
+                            }
+                        }
+                        entidade[indice] = valor;
                     }
-                    return valor;
-                }
-                const valorAnteriorIncremento = valor;
-                if (expressao.operando instanceof construtos_1.Variavel) {
-                    this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, ++valor);
-                }
-                return valorAnteriorIncremento;
-            case delegua_1.default.DECREMENTAR:
-                if (typeof valor === 'string') {
-                    throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, `Operador '${expressao.operador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
-                }
-                if (expressao.incidenciaOperador === 'ANTES') {
-                    valor--;
-                    if (expressao.operando instanceof construtos_1.Variavel) {
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, valor);
+                    else if (entidade && typeof entidade === 'object') {
+                        entidade[indice] = valor;
                     }
                     return valor;
-                }
-                const valorAnteriorDecremento = valor;
-                if (expressao.operando instanceof construtos_1.Variavel) {
-                    this.pilhaEscoposExecucao.atribuirVariavel(expressao.operando.simbolo, --valor);
-                }
-                return valorAnteriorDecremento;
+                });
+            });
         }
-        return null;
+        return valor;
+    }
+    visitarExpressaoUnaria(expressao) {
+        return (0, encadear_1.encadear)(this.avaliar(expressao.operando), (operando) => {
+            let valor = this.resolverValor(operando);
+            switch (expressao.operador.tipo) {
+                case delegua_1.default.ADICAO:
+                    this.verificarOperandoNumero(expressao.operador, valor);
+                    return +valor;
+                case delegua_1.default.SUBTRACAO:
+                    this.verificarOperandoNumero(expressao.operador, valor);
+                    return -valor;
+                case delegua_1.default.NEGACAO:
+                case delegua_1.default.NAO:
+                    return !this.eVerdadeiro(valor);
+                case delegua_1.default.BIT_NOT:
+                    if (typeof valor === 'bigint') {
+                        return ~valor;
+                    }
+                    this.verificarOperandoNumero(expressao.operador, valor);
+                    return ~Number(valor);
+                // Para incrementar e decrementar, primeiro precisamos saber se o operador
+                // veio antes do literal ou variável.
+                // Se veio antes e o operando é uma variável, precisamos incrementar/decrementar,
+                // armazenar o valor da variável pra só então devolver o valor.
+                case delegua_1.default.INCREMENTAR:
+                    if (typeof valor === 'string') {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, `Operador '${expressao.operador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
+                    }
+                    if (expressao.incidenciaOperador === 'ANTES') {
+                        return this.atribuirValorAoOperandoUnario(expressao.operando, valor + 1);
+                    }
+                    const valorAnteriorIncremento = valor;
+                    return (0, encadear_1.encadear)(this.atribuirValorAoOperandoUnario(expressao.operando, valor + 1), () => valorAnteriorIncremento);
+                case delegua_1.default.DECREMENTAR:
+                    if (typeof valor === 'string') {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, `Operador '${expressao.operador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
+                    }
+                    if (expressao.incidenciaOperador === 'ANTES') {
+                        return this.atribuirValorAoOperandoUnario(expressao.operando, valor - 1);
+                    }
+                    const valorAnteriorDecremento = valor;
+                    return (0, encadear_1.encadear)(this.atribuirValorAoOperandoUnario(expressao.operando, valor - 1), () => valorAnteriorDecremento);
+            }
+            return null;
+        });
     }
     /**
      * Formata uma saída de acordo com o número e espaços e casas decimais solicitados.
@@ -604,270 +631,276 @@ class InterpretadorBase {
             return;
         if (this.tiposNumericos.includes(tipoDireita) && tipoEsquerda === 'nulo')
             return;
-        // Se operador é subtração, os dois tipos são `qualquer`, mas ambos podem ser convertidos
-        // para número, a operação é válida.
-        if (operador.tipo === delegua_1.default.SUBTRACAO) {
-            if (typeof esquerda.valor === 'number' && typeof direita.valor === 'number') {
-                return;
-            }
+        // A inferência estática de tipos (feita em tempo de análise sintática) é otimista e pode
+        // marcar variáveis como `qualquer` quando não consegue deduzir o tipo real (por exemplo,
+        // resultado de operação bit a bit ou acesso a índice de vetor com parâmetro sem tipo
+        // explícito). Se os dois operandos não bateram nas checagens de tipo acima, mas os
+        // valores em tempo de execução são efetivamente números, a operação é válida.
+        const valorEsquerda = esquerda && esquerda.hasOwnProperty('valor') ? esquerda.valor : esquerda;
+        const valorDireita = direita && direita.hasOwnProperty('valor') ? direita.valor : direita;
+        if ((typeof valorEsquerda === 'number' || typeof valorEsquerda === 'bigint') &&
+            (typeof valorDireita === 'number' || typeof valorDireita === 'bigint')) {
+            return;
         }
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     }
     converterParaBigInt(valor) {
         return typeof valor === 'bigint' ? valor : BigInt(Math.floor(Number(valor)));
     }
-    async visitarExpressaoBinaria(expressao) {
-        const esquerda = await this.avaliar(expressao.esquerda);
-        const direita = await this.avaliar(expressao.direita);
-        const valorEsquerdo = this.resolverValor(esquerda);
-        const valorDireito = this.resolverValor(direita);
-        // Verificar sobrecarga de operador: se o operando esquerdo é uma instância de classe,
-        // procurar método `operador<símbolo>` (ex: `operador+`, `operador==`).
-        if (valorEsquerdo instanceof estruturas_1.ObjetoDeleguaClasse) {
-            const nomeOperador = 'operador' + expressao.operador.lexema;
-            const metodoOperador = valorEsquerdo.classe.encontrarMetodo(nomeOperador);
-            if (metodoOperador) {
-                const metodoASerChamado = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
-                const argumentoOperador = direita && Object.prototype.hasOwnProperty.call(direita, 'tipo')
-                    ? direita
-                    : {
-                        tipo: (0, inferenciador_1.inferirTipoVariavel)(valorDireito),
-                        valor: valorDireito,
-                        imutavel: false,
-                    };
-                return await metodoASerChamado.chamar(this, [
-                    { nome: null, valor: argumentoOperador },
-                ]);
-            }
-        }
-        const tipoEsquerdo = esquerda?.hasOwnProperty('tipo')
-            ? esquerda.tipo
-            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-        const tipoDireito = direita?.hasOwnProperty('tipo')
-            ? direita.tipo
-            : (0, inferenciador_1.inferirTipoVariavel)(direita);
-        switch (expressao.operador.tipo) {
-            case delegua_1.default.EXPONENCIACAO:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return (this.converterParaBigInt(valorEsquerdo) **
-                        this.converterParaBigInt(valorDireito));
-                }
-                const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
-                return resultadoExponenciacao;
-            case delegua_1.default.MAIOR:
-                if (typeof valorEsquerdo === 'string' &&
-                    typeof valorDireito === 'string') {
-                    return valorEsquerdo > valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) > Number(valorDireito);
-            case delegua_1.default.MAIOR_IGUAL:
-                if (typeof valorEsquerdo === 'string' &&
-                    typeof valorDireito === 'string') {
-                    return valorEsquerdo >= valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) >= Number(valorDireito);
-            case delegua_1.default.MENOR:
-                if (typeof valorEsquerdo === 'string' &&
-                    typeof valorDireito === 'string') {
-                    return valorEsquerdo < valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) < Number(valorDireito);
-            case delegua_1.default.MENOR_IGUAL:
-                if (typeof valorEsquerdo === 'string' &&
-                    typeof valorDireito === 'string') {
-                    return valorEsquerdo <= valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) <= Number(valorDireito);
-            case delegua_1.default.SUBTRACAO:
-            case delegua_1.default.MENOS_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return (this.converterParaBigInt(valorEsquerdo) -
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) - Number(valorDireito);
-            case delegua_1.default.ADICAO:
-            case delegua_1.default.MAIS_IGUAL:
-                // Se ambos os operandos são vetores, concatená-los
-                if (Array.isArray(valorEsquerdo) && Array.isArray(valorDireito)) {
-                    return valorEsquerdo.concat(valorDireito);
-                }
-                // Se ambos os operandos são dicionários, mescla-os.
-                // Em caso de chaves duplicadas, valores à direita sobrescrevem os da esquerda.
-                if (valorEsquerdo &&
-                    valorDireito &&
-                    !Array.isArray(valorEsquerdo) &&
-                    !Array.isArray(valorDireito) &&
-                    valorEsquerdo.constructor === Object &&
-                    valorDireito.constructor === Object) {
-                    return Object.assign({}, valorEsquerdo, valorDireito);
-                }
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
-                        ? valorEsquerdo
-                        : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
-                        ? valorDireito
-                        : BigInt(Math.floor(Number(valorDireito)));
-                    return valorResolvidoEsquerdo + valorResolvidoDireito;
-                }
-                if (this.tiposNumericos.includes(tipoEsquerdo) &&
-                    this.tiposNumericos.includes(tipoDireito)) {
-                    return Number(valorEsquerdo) + Number(valorDireito);
-                }
-                if (valorEsquerdo === null || valorDireito === null) {
+    // Corpo original mantido com a indentação de antes da conversão (só o cabeçalho e o
+    // fechamento mudaram) para manter este diff revisável — ver `encadear` para o porquê.
+    visitarExpressaoBinaria(expressao) {
+        return (0, encadear_1.encadear)(this.avaliar(expressao.esquerda), (esquerda) => (0, encadear_1.encadear)(this.avaliar(expressao.direita), (direita) => {
+            const valorEsquerdo = this.resolverValor(esquerda);
+            const valorDireito = this.resolverValor(direita);
+            // Verificar sobrecarga de operador: se o operando esquerdo é uma instância de classe,
+            // procurar método `operador<símbolo>` (ex: `operador+`, `operador==`).
+            if (valorEsquerdo instanceof estruturas_1.ObjetoDeleguaClasse) {
+                const nomeOperador = 'operador' + expressao.operador.lexema;
+                const metodoOperador = valorEsquerdo.classe.encontrarMetodo(nomeOperador);
+                if (metodoOperador) {
+                    const metodoASerChamado = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
+                    const argumentoOperador = direita && Object.prototype.hasOwnProperty.call(direita, 'tipo')
+                        ? direita
+                        : {
+                            tipo: (0, inferenciador_1.inferirTipoVariavel)(valorDireito),
+                            valor: valorDireito,
+                            imutavel: false,
+                        };
+                    return metodoASerChamado.chamar(this, [
+                        { nome: null, valor: argumentoOperador },
+                    ]);
+                }
+            }
+            const tipoEsquerdo = esquerda?.hasOwnProperty('tipo')
+                ? esquerda.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
+            const tipoDireito = direita?.hasOwnProperty('tipo')
+                ? direita.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(direita);
+            switch (expressao.operador.tipo) {
+                case delegua_1.default.EXPONENCIACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        return (this.converterParaBigInt(valorEsquerdo) **
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
+                    return resultadoExponenciacao;
+                case delegua_1.default.MAIOR:
+                    if (typeof valorEsquerdo === 'string' &&
+                        typeof valorDireito === 'string') {
+                        return valorEsquerdo > valorDireito;
+                    }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) > Number(valorDireito);
+                case delegua_1.default.MAIOR_IGUAL:
+                    if (typeof valorEsquerdo === 'string' &&
+                        typeof valorDireito === 'string') {
+                        return valorEsquerdo >= valorDireito;
+                    }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >= Number(valorDireito);
+                case delegua_1.default.MENOR:
+                    if (typeof valorEsquerdo === 'string' &&
+                        typeof valorDireito === 'string') {
+                        return valorEsquerdo < valorDireito;
+                    }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) < Number(valorDireito);
+                case delegua_1.default.MENOR_IGUAL:
+                    if (typeof valorEsquerdo === 'string' &&
+                        typeof valorDireito === 'string') {
+                        return valorEsquerdo <= valorDireito;
+                    }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) <= Number(valorDireito);
+                case delegua_1.default.SUBTRACAO:
+                case delegua_1.default.MENOS_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        return (this.converterParaBigInt(valorEsquerdo) -
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    return Number(valorEsquerdo) - Number(valorDireito);
+                case delegua_1.default.ADICAO:
+                case delegua_1.default.MAIS_IGUAL:
+                    // Se ambos os operandos são vetores, concatená-los
+                    if (Array.isArray(valorEsquerdo) && Array.isArray(valorDireito)) {
+                        return valorEsquerdo.concat(valorDireito);
+                    }
+                    // Se ambos os operandos são dicionários, mescla-os.
+                    // Em caso de chaves duplicadas, valores à direita sobrescrevem os da esquerda.
+                    if (valorEsquerdo &&
+                        valorDireito &&
+                        !Array.isArray(valorEsquerdo) &&
+                        !Array.isArray(valorDireito) &&
+                        valorEsquerdo.constructor === Object &&
+                        valorDireito.constructor === Object) {
+                        return Object.assign({}, valorEsquerdo, valorDireito);
+                    }
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
+                            ? valorEsquerdo
+                            : BigInt(Math.floor(Number(valorEsquerdo)));
+                        const valorResolvidoDireito = typeof valorDireito === 'bigint'
+                            ? valorDireito
+                            : BigInt(Math.floor(Number(valorDireito)));
+                        return valorResolvidoEsquerdo + valorResolvidoDireito;
+                    }
+                    if (this.tiposNumericos.includes(tipoEsquerdo) &&
+                        this.tiposNumericos.includes(tipoDireito)) {
+                        return Number(valorEsquerdo) + Number(valorDireito);
+                    }
+                    if (valorEsquerdo === null || valorDireito === null) {
+                        return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
+                    }
+                    // Para tipos 'qualquer', delegamos ao operador nativo do JavaScript,
+                    // que resolve concatenação ou soma dependendo dos valores em tempo de execução.
+                    if (tipoEsquerdo === 'qualquer' || tipoDireito === 'qualquer') {
+                        return valorEsquerdo + valorDireito;
+                    }
                     return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
-                }
-                // Para tipos 'qualquer', delegamos ao operador nativo do JavaScript,
-                // que resolve concatenação ou soma dependendo dos valores em tempo de execução.
-                if (tipoEsquerdo === 'qualquer' || tipoDireito === 'qualquer') {
-                    return valorEsquerdo + valorDireito;
-                }
-                return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
-            case delegua_1.default.DIVISAO:
-            case delegua_1.default.DIVISAO_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                if (this.lancarErroPorDivisaoPorZero && Number(valorDireito) === 0) {
-                    throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Divisão por zero não é permitida.', expressao.operador.linha);
-                }
-                // SEMPRE retorna Number para precisão decimal (preferência do usuário)
-                // Mesmo se operandos forem BigInt, converte para Number
-                return Number(valorEsquerdo) / Number(valorDireito);
-            case delegua_1.default.DIVISAO_INTEIRA:
-            case delegua_1.default.DIVISAO_INTEIRA_IGUAL:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                if (this.lancarErroPorDivisaoPorZero && valorDireito === 0) {
-                    throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Divisão por zero não é permitida.', expressao.operador.linha);
-                }
-                // Retorna BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
-                        ? valorEsquerdo
-                        : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
-                        ? valorDireito
-                        : BigInt(Math.floor(Number(valorDireito)));
-                    return valorResolvidoEsquerdo / valorResolvidoDireito; // Trunca automaticamente
-                }
-                return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
-            case delegua_1.default.MULTIPLICACAO:
-            case delegua_1.default.MULTIPLICACAO_IGUAL:
-                // Auto-promove para BigInt se qualquer operando for BigInt (e não for texto)
-                if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
-                    tipoEsquerdo !== delegua_2.default.TEXTO &&
-                    tipoDireito !== delegua_2.default.TEXTO) {
-                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
-                        ? valorEsquerdo
-                        : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
-                        ? valorDireito
-                        : BigInt(Math.floor(Number(valorDireito)));
-                    return valorResolvidoEsquerdo * valorResolvidoDireito;
-                }
-                if (tipoEsquerdo === delegua_2.default.TEXTO ||
-                    tipoDireito === delegua_2.default.TEXTO) {
-                    // Sem ambos os valores resolvem como texto, multiplica normal.
-                    // Se apenas um resolve como texto, o outro repete o
-                    // texto n vezes, sendo n o valor do outro.
-                    if (tipoEsquerdo === delegua_2.default.TEXTO &&
+                case delegua_1.default.DIVISAO:
+                case delegua_1.default.DIVISAO_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    if (this.lancarErroPorDivisaoPorZero && Number(valorDireito) === 0) {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Divisão por zero não é permitida.', expressao.operador.linha);
+                    }
+                    // SEMPRE retorna Number para precisão decimal (preferência do usuário)
+                    // Mesmo se operandos forem BigInt, converte para Number
+                    return Number(valorEsquerdo) / Number(valorDireito);
+                case delegua_1.default.DIVISAO_INTEIRA:
+                case delegua_1.default.DIVISAO_INTEIRA_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    if (this.lancarErroPorDivisaoPorZero && valorDireito === 0) {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Divisão por zero não é permitida.', expressao.operador.linha);
+                    }
+                    // Retorna BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
+                            ? valorEsquerdo
+                            : BigInt(Math.floor(Number(valorEsquerdo)));
+                        const valorResolvidoDireito = typeof valorDireito === 'bigint'
+                            ? valorDireito
+                            : BigInt(Math.floor(Number(valorDireito)));
+                        return valorResolvidoEsquerdo / valorResolvidoDireito; // Trunca automaticamente
+                    }
+                    return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
+                case delegua_1.default.MULTIPLICACAO:
+                case delegua_1.default.MULTIPLICACAO_IGUAL:
+                    // Auto-promove para BigInt se qualquer operando for BigInt (e não for texto)
+                    if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
+                        tipoEsquerdo !== delegua_2.default.TEXTO &&
+                        tipoDireito !== delegua_2.default.TEXTO) {
+                        const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
+                            ? valorEsquerdo
+                            : BigInt(Math.floor(Number(valorEsquerdo)));
+                        const valorResolvidoDireito = typeof valorDireito === 'bigint'
+                            ? valorDireito
+                            : BigInt(Math.floor(Number(valorDireito)));
+                        return valorResolvidoEsquerdo * valorResolvidoDireito;
+                    }
+                    if (tipoEsquerdo === delegua_2.default.TEXTO ||
                         tipoDireito === delegua_2.default.TEXTO) {
-                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Não é possível multiplicar dois textos.', expressao.linha);
+                        // Sem ambos os valores resolvem como texto, multiplica normal.
+                        // Se apenas um resolve como texto, o outro repete o
+                        // texto n vezes, sendo n o valor do outro.
+                        if (tipoEsquerdo === delegua_2.default.TEXTO &&
+                            tipoDireito === delegua_2.default.TEXTO) {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Não é possível multiplicar dois textos.', expressao.linha);
+                        }
+                        const valorTexto = tipoEsquerdo === delegua_2.default.TEXTO ? valorEsquerdo : valorDireito;
+                        const valorQuantidade = tipoEsquerdo === delegua_2.default.TEXTO ? valorDireito : valorEsquerdo;
+                        if (typeof valorQuantidade !== 'number') {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Para multiplicar um texto, o outro operando deve ser um número.', expressao.linha);
+                        }
+                        const textoParaNumero = Number(valorTexto);
+                        if (!isNaN(textoParaNumero)) {
+                            return textoParaNumero * valorQuantidade;
+                        }
+                        if (!Number.isInteger(valorQuantidade)) {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'A multiplicação de texto exige um número inteiro.', expressao.linha);
+                        }
+                        if (valorQuantidade < 0) {
+                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Não é possível multiplicar texto por número negativo.', expressao.linha);
+                        }
+                        return valorTexto.repeat(valorQuantidade);
                     }
-                    const valorTexto = tipoEsquerdo === delegua_2.default.TEXTO ? valorEsquerdo : valorDireito;
-                    const valorQuantidade = tipoEsquerdo === delegua_2.default.TEXTO ? valorDireito : valorEsquerdo;
-                    if (typeof valorQuantidade !== 'number') {
-                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Para multiplicar um texto, o outro operando deve ser um número.', expressao.linha);
+                    return Number(valorEsquerdo) * Number(valorDireito);
+                case delegua_1.default.MODULO:
+                case delegua_1.default.MODULO_IGUAL:
+                    // Se o operando esquerdo é uma string, usar formatação de string
+                    if (tipoEsquerdo === delegua_2.default.TEXTO ||
+                        typeof valorEsquerdo === 'string') {
+                        return this.formatarStringComOperadorPorcentagem(String(valorEsquerdo), direita, // Passar 'direita' ao invés de 'valorDireito' para preservar arrays de tuplas
+                        expressao.operador);
                     }
-                    const textoParaNumero = Number(valorTexto);
-                    if (!isNaN(textoParaNumero)) {
-                        return textoParaNumero * valorQuantidade;
+                    // Caso contrário, operação matemática normal
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) % Number(valorDireito);
+                case delegua_1.default.BIT_AND:
+                    if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
+                        return valorEsquerdo && valorDireito;
                     }
-                    if (!Number.isInteger(valorQuantidade)) {
-                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'A multiplicação de texto exige um número inteiro.', expressao.linha);
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        return (this.converterParaBigInt(valorEsquerdo) &
+                            this.converterParaBigInt(valorDireito));
                     }
-                    if (valorQuantidade < 0) {
-                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Não é possível multiplicar texto por número negativo.', expressao.linha);
+                    return Number(valorEsquerdo) & Number(valorDireito);
+                case delegua_1.default.CIRCUMFLEXO:
+                    if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
+                        return valorEsquerdo !== valorDireito;
                     }
-                    return valorTexto.repeat(valorQuantidade);
-                }
-                return Number(valorEsquerdo) * Number(valorDireito);
-            case delegua_1.default.MODULO:
-            case delegua_1.default.MODULO_IGUAL:
-                // Se o operando esquerdo é uma string, usar formatação de string
-                if (tipoEsquerdo === delegua_2.default.TEXTO ||
-                    typeof valorEsquerdo === 'string') {
-                    return this.formatarStringComOperadorPorcentagem(String(valorEsquerdo), direita, // Passar 'direita' ao invés de 'valorDireito' para preservar arrays de tuplas
-                    expressao.operador);
-                }
-                // Caso contrário, operação matemática normal
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                return Number(valorEsquerdo) % Number(valorDireito);
-            case delegua_1.default.BIT_AND:
-                if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
-                    return valorEsquerdo && valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return (this.converterParaBigInt(valorEsquerdo) &
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) & Number(valorDireito);
-            case delegua_1.default.CIRCUMFLEXO:
-                if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
-                    return valorEsquerdo !== valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return (this.converterParaBigInt(valorEsquerdo) ^
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) ^ Number(valorDireito);
-            case delegua_1.default.BIT_OR:
-                if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
-                    return valorEsquerdo || valorDireito;
-                }
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt se qualquer operando for BigInt
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    return (this.converterParaBigInt(valorEsquerdo) |
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) | Number(valorDireito);
-            case delegua_1.default.MENOR_MENOR:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                if (typeof valorEsquerdo === 'bigint' ||
-                    typeof valorDireito === 'bigint' ||
-                    Number(valorDireito) >= 32) {
-                    return (this.converterParaBigInt(valorEsquerdo) <<
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) << Number(valorDireito);
-            case delegua_1.default.MAIOR_MAIOR:
-                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
-                if (typeof valorEsquerdo === 'bigint' ||
-                    typeof valorDireito === 'bigint' ||
-                    Number(valorDireito) >= 32) {
-                    return (this.converterParaBigInt(valorEsquerdo) >>
-                        this.converterParaBigInt(valorDireito));
-                }
-                return Number(valorEsquerdo) >> Number(valorDireito);
-            case delegua_1.default.DIFERENTE:
-                return !this.eIgual(valorEsquerdo, valorDireito);
-            case delegua_1.default.IGUAL_IGUAL:
-                return this.eIgual(valorEsquerdo, valorDireito);
-        }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        return (this.converterParaBigInt(valorEsquerdo) ^
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    return Number(valorEsquerdo) ^ Number(valorDireito);
+                case delegua_1.default.BIT_OR:
+                    if (typeof valorEsquerdo === 'boolean' && typeof valorDireito === 'boolean') {
+                        return valorEsquerdo || valorDireito;
+                    }
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt se qualquer operando for BigInt
+                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                        return (this.converterParaBigInt(valorEsquerdo) |
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    return Number(valorEsquerdo) | Number(valorDireito);
+                case delegua_1.default.MENOR_MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
+                    if (typeof valorEsquerdo === 'bigint' ||
+                        typeof valorDireito === 'bigint' ||
+                        Number(valorDireito) >= 32) {
+                        return (this.converterParaBigInt(valorEsquerdo) <<
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    return Number(valorEsquerdo) << Number(valorDireito);
+                case delegua_1.default.MAIOR_MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
+                    if (typeof valorEsquerdo === 'bigint' ||
+                        typeof valorDireito === 'bigint' ||
+                        Number(valorDireito) >= 32) {
+                        return (this.converterParaBigInt(valorEsquerdo) >>
+                            this.converterParaBigInt(valorDireito));
+                    }
+                    return Number(valorEsquerdo) >> Number(valorDireito);
+                case delegua_1.default.DIFERENTE:
+                    return !this.eIgual(valorEsquerdo, valorDireito);
+                case delegua_1.default.IGUAL_IGUAL:
+                    return this.eIgual(valorEsquerdo, valorDireito);
+            }
+        }));
     }
     /**
      * Faz a chamada do método de uma primitiva (por exemplo, número, texto, etc.) com seus
@@ -919,7 +952,7 @@ class InterpretadorBase {
             let entidadeChamada = this.resolverValor(variavelEntidadeChamada);
             // Funções anônimas
             if (entidadeChamada instanceof construtos_1.FuncaoConstruto) {
-                entidadeChamada = new estruturas_1.DeleguaFuncao(null, entidadeChamada);
+                entidadeChamada = new estruturas_1.DeleguaFuncao(null, entidadeChamada).capturarEscopo(this.pilhaEscoposExecucao);
             }
             if (entidadeChamada instanceof estruturas_1.DeleguaModulo) {
                 return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Entidade chamada é um módulo de Delégua. Provavelmente você quer chamar um de seus componentes?', expressao.linha));
@@ -1041,57 +1074,63 @@ class InterpretadorBase {
      * @param expressao A expressão.
      * @returns O valor atribuído.
      */
-    async visitarExpressaoDeAtribuicao(expressao) {
-        let valor = await this.avaliar(expressao.valor);
-        if (valor && valor.hasOwnProperty('valorRetornado')) {
-            valor = valor.valorRetornado;
-        }
-        const valorResolvido = this.resolverValor(valor);
-        let indice = null;
-        if (expressao.indice) {
-            indice = this.resolverValor(await this.avaliar(expressao.indice));
-        }
-        switch (expressao.alvo.constructor) {
-            case construtos_1.AcessoMetodoOuPropriedade:
-                const alvoPropriedade = expressao.alvo;
-                const variavelObjeto = await this.avaliar(alvoPropriedade.objeto);
-                const objeto = this.resolverValor(variavelObjeto);
-                const valorProp = await this.avaliar(expressao.valor);
-                await this.definirPropriedadeObjeto(objeto, alvoPropriedade.simbolo, valorProp);
-                break;
-            case construtos_1.Variavel:
-                const alvoVariavel = expressao.alvo;
-                if (expressao.simboloOperador) {
-                    let valorAtual;
-                    valorAtual = this.resolverValor(this.pilhaEscoposExecucao.obterValorVariavel(alvoVariavel.simbolo));
-                    if (typeof valorAtual === 'string') {
-                        let valorDireito;
-                        if (expressao.valor instanceof construtos_1.Binario) {
-                            valorDireito = this.resolverValor(await this.avaliar(expressao.valor.direita));
-                        }
-                        else {
-                            valorDireito = valorResolvido;
-                        }
-                        if (expressao.simboloOperador.tipo === delegua_1.default.MAIS_IGUAL) {
-                            if (typeof valorDireito !== 'string') {
-                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Operador '+=' não pode concatenar texto com ${typeof valorDireito}. Use conversão explícita.`, expressao.linha);
+    visitarExpressaoDeAtribuicao(expressao) {
+        return (0, encadear_1.encadear)(this.avaliar(expressao.valor), (valorBruto) => {
+            let valor = valorBruto;
+            if (valor && valor.hasOwnProperty('valorRetornado')) {
+                valor = valor.valorRetornado;
+            }
+            const valorResolvido = this.resolverValor(valor);
+            const continuarComIndice = (indice) => {
+                switch (expressao.alvo.constructor) {
+                    case construtos_1.AcessoMetodoOuPropriedade: {
+                        const alvoPropriedade = expressao.alvo;
+                        return (0, encadear_1.encadear)(this.avaliar(alvoPropriedade.objeto), (variavelObjeto) => {
+                            const objeto = this.resolverValor(variavelObjeto);
+                            return (0, encadear_1.encadear)(this.avaliar(expressao.valor), (valorProp) => (0, encadear_1.encadear)(this.definirPropriedadeObjeto(objeto, alvoPropriedade.simbolo, valorProp), () => valorResolvido));
+                        });
+                    }
+                    case construtos_1.Variavel: {
+                        const alvoVariavel = expressao.alvo;
+                        const finalizarAtribuicaoVariavel = () => {
+                            this.atribuirVariavel(alvoVariavel, valorResolvido, indice);
+                            return valorResolvido;
+                        };
+                        if (expressao.simboloOperador) {
+                            const valorAtual = this.resolverValor(this.pilhaEscoposExecucao.obterValorVariavel(alvoVariavel.simbolo));
+                            if (typeof valorAtual === 'string') {
+                                const continuarComValorDireito = (valorDireito) => {
+                                    if (expressao.simboloOperador.tipo === delegua_1.default.MAIS_IGUAL) {
+                                        if (typeof valorDireito !== 'string') {
+                                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Operador '+=' não pode concatenar texto com ${typeof valorDireito}. Use conversão explícita.`, expressao.linha);
+                                        }
+                                    }
+                                    else if ([delegua_1.default.MENOS_IGUAL,
+                                        delegua_1.default.MULTIPLICACAO_IGUAL,
+                                        delegua_1.default.DIVISAO_IGUAL,
+                                        delegua_1.default.MODULO_IGUAL]
+                                        .includes(expressao.simboloOperador.tipo)) {
+                                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Operador '${expressao.simboloOperador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
+                                    }
+                                    return finalizarAtribuicaoVariavel();
+                                };
+                                if (expressao.valor instanceof construtos_1.Binario) {
+                                    return (0, encadear_1.encadear)(this.avaliar(expressao.valor.direita), (direitaBruta) => continuarComValorDireito(this.resolverValor(direitaBruta)));
+                                }
+                                return continuarComValorDireito(valorResolvido);
                             }
                         }
-                        else if ([delegua_1.default.MENOS_IGUAL,
-                            delegua_1.default.MULTIPLICACAO_IGUAL,
-                            delegua_1.default.DIVISAO_IGUAL,
-                            delegua_1.default.MODULO_IGUAL]
-                            .includes(expressao.simboloOperador.tipo)) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Operador '${expressao.simboloOperador.lexema}' não pode ser aplicado a um texto.`, expressao.linha);
-                        }
+                        return finalizarAtribuicaoVariavel();
                     }
+                    default:
+                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, "Alvo da atribuição inválido. O lado esquerdo de uma atribuição deve ser uma variável, propriedade ou índice.");
                 }
-                this.atribuirVariavel(alvoVariavel, valorResolvido, indice);
-                break;
-            default:
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, "Alvo da atribuição inválido. O lado esquerdo de uma atribuição deve ser uma variável, propriedade ou índice.");
-        }
-        return valorResolvido;
+            };
+            if (expressao.indice) {
+                return (0, encadear_1.encadear)(this.avaliar(expressao.indice), (indiceBruto) => continuarComIndice(this.resolverValor(indiceBruto)));
+            }
+            return continuarComIndice(null);
+        });
     }
     procurarVariavel(simbolo) {
         return this.pilhaEscoposExecucao.obterValorVariavel(simbolo);
@@ -1099,8 +1138,8 @@ class InterpretadorBase {
     visitarExpressaoDeVariavel(expressao) {
         return this.procurarVariavel(expressao.simbolo);
     }
-    async visitarDeclaracaoDeExpressao(declaracao) {
-        return await this.avaliar(declaracao.expressao);
+    visitarDeclaracaoDeExpressao(declaracao) {
+        return this.avaliar(declaracao.expressao);
     }
     logicaContemOuEm(esquerda, direita, expressao) {
         const valorEsquerdoResolvido = this.resolverValor(esquerda);
@@ -1116,66 +1155,69 @@ class InterpretadorBase {
         }
         throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, `Tipo de chamada inválida com '${expressao.operador.tipo}'.`, expressao.linha);
     }
-    async visitarExpressaoLogica(expressao) {
-        const esquerda = await this.avaliar(expressao.esquerda);
-        if ([delegua_1.default.EM, delegua_1.default.CONTEM].includes(expressao.operador.tipo)) {
-            const direita = await this.avaliar(expressao.direita);
-            // `3 em lista` é igual a `lista contém 3`.
-            // Portanto, precisamos inverter os operandos de acordo com a
-            // palavra reservada usada.
-            switch (expressao.operador.tipo) {
-                case delegua_1.default.EM:
-                    return this.logicaContemOuEm(esquerda, direita, expressao);
-                case delegua_1.default.CONTEM:
-                    return this.logicaContemOuEm(direita, esquerda, expressao);
-            }
-        }
-        // E/OU como bitwise quando ambos operandos são numéricos
-        if ([delegua_1.default.E, delegua_1.default.OU].includes(expressao.operador.tipo)) {
-            const valorEsquerdo = this.resolverValor(esquerda);
-            if (typeof valorEsquerdo === 'number' || typeof valorEsquerdo === 'bigint') {
-                const direita = await this.avaliar(expressao.direita);
-                const valorDireito = this.resolverValor(direita);
-                if (typeof valorDireito === 'number' || typeof valorDireito === 'bigint') {
-                    if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                        const esq = typeof valorEsquerdo === 'bigint'
-                            ? valorEsquerdo
-                            : BigInt(Math.floor(Number(valorEsquerdo)));
-                        const dir = typeof valorDireito === 'bigint'
-                            ? valorDireito
-                            : BigInt(Math.floor(Number(valorDireito)));
-                        return expressao.operador.tipo === delegua_1.default.E
-                            ? esq & dir
-                            : esq | dir;
+    visitarExpressaoLogica(expressao) {
+        return (0, encadear_1.encadear)(this.avaliar(expressao.esquerda), (esquerda) => {
+            if ([delegua_1.default.EM, delegua_1.default.CONTEM].includes(expressao.operador.tipo)) {
+                return (0, encadear_1.encadear)(this.avaliar(expressao.direita), (direita) => {
+                    // `3 em lista` é igual a `lista contém 3`.
+                    // Portanto, precisamos inverter os operandos de acordo com a
+                    // palavra reservada usada.
+                    switch (expressao.operador.tipo) {
+                        case delegua_1.default.EM:
+                            return this.logicaContemOuEm(esquerda, direita, expressao);
+                        case delegua_1.default.CONTEM:
+                            return this.logicaContemOuEm(direita, esquerda, expressao);
                     }
-                    return expressao.operador.tipo === delegua_1.default.E
-                        ? Number(valorEsquerdo) & Number(valorDireito)
-                        : Number(valorEsquerdo) | Number(valorDireito);
-                }
-                // Demais casos sem diferença de tipos
-                if (expressao.operador.tipo === delegua_1.default.OU) {
-                    if (this.eVerdadeiro(esquerda))
-                        return esquerda;
-                    return direita;
-                }
-                if (expressao.operador.tipo === delegua_1.default.E) {
-                    if (!this.eVerdadeiro(esquerda))
-                        return esquerda;
-                    return direita;
+                });
+            }
+            // E/OU como bitwise quando ambos operandos são numéricos
+            if ([delegua_1.default.E, delegua_1.default.OU].includes(expressao.operador.tipo)) {
+                const valorEsquerdo = this.resolverValor(esquerda);
+                if (typeof valorEsquerdo === 'number' || typeof valorEsquerdo === 'bigint') {
+                    return (0, encadear_1.encadear)(this.avaliar(expressao.direita), (direita) => {
+                        const valorDireito = this.resolverValor(direita);
+                        if (typeof valorDireito === 'number' || typeof valorDireito === 'bigint') {
+                            if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
+                                const esq = typeof valorEsquerdo === 'bigint'
+                                    ? valorEsquerdo
+                                    : BigInt(Math.floor(Number(valorEsquerdo)));
+                                const dir = typeof valorDireito === 'bigint'
+                                    ? valorDireito
+                                    : BigInt(Math.floor(Number(valorDireito)));
+                                return expressao.operador.tipo === delegua_1.default.E
+                                    ? esq & dir
+                                    : esq | dir;
+                            }
+                            return expressao.operador.tipo === delegua_1.default.E
+                                ? Number(valorEsquerdo) & Number(valorDireito)
+                                : Number(valorEsquerdo) | Number(valorDireito);
+                        }
+                        // Demais casos sem diferença de tipos
+                        if (expressao.operador.tipo === delegua_1.default.OU) {
+                            if (this.eVerdadeiro(esquerda))
+                                return esquerda;
+                            return direita;
+                        }
+                        if (expressao.operador.tipo === delegua_1.default.E) {
+                            if (!this.eVerdadeiro(esquerda))
+                                return esquerda;
+                            return direita;
+                        }
+                    });
                 }
             }
-        }
-        // se um estado for verdadeiro, retorna verdadeiro
-        if (expressao.operador.tipo === delegua_1.default.OU) {
-            if (this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        // se um estado for falso, retorna falso
-        if (expressao.operador.tipo === delegua_1.default.E) {
-            if (!this.eVerdadeiro(esquerda))
-                return esquerda;
-        }
-        return await this.avaliar(expressao.direita);
+            // se um estado for verdadeiro, retorna verdadeiro
+            if (expressao.operador.tipo === delegua_1.default.OU) {
+                if (this.eVerdadeiro(esquerda))
+                    return esquerda;
+            }
+            // se um estado for falso, retorna falso
+            if (expressao.operador.tipo === delegua_1.default.E) {
+                if (!this.eVerdadeiro(esquerda))
+                    return esquerda;
+            }
+            return this.avaliar(expressao.direita);
+        });
     }
     async visitarDeclaracaoPara(declaracao) {
         const declaracaoInicializador = Array.isArray(declaracao.inicializador)
@@ -1279,26 +1321,33 @@ class InterpretadorBase {
      * @param declaracao A declaração Se.
      * @returns O resultado da avaliação do bloco cuja condição é verdadeira.
      */
-    async visitarDeclaracaoSe(declaracao) {
-        const avaliacaoCondicaoSe = await this.avaliar(declaracao.condicao);
-        if (this.eVerdadeiro(avaliacaoCondicaoSe)) {
-            this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'verdadeiro');
-            return await this.executar(declaracao.caminhoEntao);
-        }
+    visitarDeclaracaoSe(declaracao) {
         const declaracaoCaminhosSeSenao = declaracao.caminhosSeSenao || [];
-        for (let i = 0; i < declaracaoCaminhosSeSenao.length; i++) {
+        const proximoCaminhoSeSenao = (i) => {
+            if (i >= declaracaoCaminhosSeSenao.length) {
+                if (declaracao.caminhoSenao) {
+                    this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'senao');
+                    return this.executar(declaracao.caminhoSenao);
+                }
+                this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'falso');
+                return null;
+            }
             const atual = declaracaoCaminhosSeSenao[i];
-            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
+            return (0, encadear_1.encadear)(this.avaliar(atual.condicao), (condicaoAtual) => {
+                if (this.eVerdadeiro(condicaoAtual)) {
+                    this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'verdadeiro');
+                    return this.executar(atual.caminho);
+                }
+                return proximoCaminhoSeSenao(i + 1);
+            });
+        };
+        return (0, encadear_1.encadear)(this.avaliar(declaracao.condicao), (avaliacaoCondicaoSe) => {
+            if (this.eVerdadeiro(avaliacaoCondicaoSe)) {
                 this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'verdadeiro');
-                return await this.executar(atual.caminho);
+                return this.executar(declaracao.caminhoEntao);
             }
-        }
-        if (declaracao.caminhoSenao) {
-            this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'senao');
-            return await this.executar(declaracao.caminhoSenao);
-        }
-        this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'falso');
-        return null;
+            return proximoCaminhoSeSenao(0);
+        });
     }
     async visitarDeclaracaoEnquanto(declaracao) {
         let retornoExecucao = undefined;
@@ -1473,10 +1522,7 @@ class InterpretadorBase {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
             this.funcaoDeRetornoMesmaLinha?.(formatoTexto);
-            return {
-                tipo: 'vazio',
-                tipoExplicito: false,
-            };
+            return null;
         }
         catch (erro) {
             this.erros.push({
@@ -1496,10 +1542,7 @@ class InterpretadorBase {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
             this.funcaoDeRetorno?.(formatoTexto);
-            return {
-                tipo: 'vazio',
-                tipoExplicito: false,
-            };
+            return null;
         }
         catch (erro) {
             this.erros.push({
@@ -1518,7 +1561,7 @@ class InterpretadorBase {
      * @param declaracoes Um vetor de declaracoes a ser executado.
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
-    async executarBloco(declaracoes, ambiente) {
+    executarBloco(declaracoes, ambiente) {
         const escopoExecucao = {
             declaracoes: declaracoes,
             declaracaoAtual: 0,
@@ -1528,51 +1571,54 @@ class InterpretadorBase {
             emLacoRepeticao: false,
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-        const retornoUltimoEscopo = await this.executarUltimoEscopo();
-        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
-            return Promise.reject(retornoUltimoEscopo);
-        }
-        return retornoUltimoEscopo;
+        return (0, encadear_1.encadear)(this.executarUltimoEscopo(), (retornoUltimoEscopo) => {
+            if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
+                return Promise.reject(retornoUltimoEscopo);
+            }
+            return retornoUltimoEscopo;
+        });
     }
-    async visitarExpressaoBloco(declaracao) {
-        return await this.executarBloco(declaracao.declaracoes);
+    visitarExpressaoBloco(declaracao) {
+        return this.executarBloco(declaracao.declaracoes);
     }
-    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;
+        });
     }
     /**
      * Executa expressão de definição de constante.
      * @param declaracao A declaração `Const`.
      * @returns Um descritor de informações importantes para o retorno externo.
      */
-    async visitarDeclaracaoConst(declaracao) {
-        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        this.pilhaEscoposExecucao.definirConstante(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
-        return {
-            tipo: declaracao.tipo,
-            tipoExplicito: declaracao.tipoExplicito,
-        };
+    visitarDeclaracaoConst(declaracao) {
+        return (0, encadear_1.encadear)(this.avaliacaoDeclaracaoVarOuConst(declaracao), (valorFinal) => {
+            this.pilhaEscoposExecucao.definirConstante(declaracao.simbolo.lexema, valorFinal, declaracao.tipo);
+            return {
+                tipo: declaracao.tipo,
+                tipoExplicito: declaracao.tipoExplicito,
+            };
+        });
     }
     /**
      * Executa expressão de definição de múltiplas constantes.
      * @param declaracao A declaração `ConstMultiplo`.
      * @returns Sempre retorna nulo.
      */
-    async visitarDeclaracaoConstMultiplo(declaracao) {
-        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
-        for (let [indice, valor] of valoresFinais.entries()) {
-            this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
-        }
-        return null;
+    visitarDeclaracaoConstMultiplo(declaracao) {
+        return (0, encadear_1.encadear)(this.avaliacaoDeclaracaoVarOuConst(declaracao), (valoresFinais) => {
+            const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
+            for (let [indice, valor] of valoresFinais.entries()) {
+                this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
+            }
+            return null;
+        });
     }
     visitarExpressaoContinua(_) {
         return new quebras_1.ContinuarQuebra();
@@ -1587,7 +1633,7 @@ class InterpretadorBase {
         return new quebras_1.RetornoQuebra(valor);
     }
     async visitarExpressaoFuncaoConstruto(funcaoConstruto) {
-        return new estruturas_1.DeleguaFuncao(null, funcaoConstruto);
+        return new estruturas_1.DeleguaFuncao(null, funcaoConstruto).capturarEscopo(this.pilhaEscoposExecucao);
     }
     async visitarExpressaoAtribuicaoPorIndice(expressao) {
         const promises = await Promise.all([
@@ -1724,7 +1770,7 @@ class InterpretadorBase {
         }
     }
     async visitarDeclaracaoDefinicaoFuncao(declaracao) {
-        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao).capturarEscopo(this.pilhaEscoposExecucao);
         funcao.documentacao = declaracao.documentacao;
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         this.pilhaEscoposExecucao.registrarReferenciaFuncao(declaracao.id, funcao);
@@ -1782,7 +1828,7 @@ class InterpretadorBase {
         for (const metodoAtual of declaracao.metodos) {
             const nomeMetodo = metodoAtual.simbolo.lexema;
             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;
             metodos[nomeMetodo] = funcao;
         }
@@ -1837,7 +1883,7 @@ class InterpretadorBase {
         const tipoNome = declaracao.simboloTipo.lexema;
         for (const metodoDeclarado of declaracao.metodos) {
             const nomeMetodo = metodoDeclarado.simbolo.lexema;
-            const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoDeclarado.funcao);
+            const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoDeclarado.funcao).capturarEscopo(this.pilhaEscoposExecucao);
             if (declaracao.ehGlobal) {
                 if (!this.extensoesGlobais.has(tipoNome)) {
                     this.extensoesGlobais.set(tipoNome, new Map());
@@ -1986,30 +2032,32 @@ class InterpretadorBase {
      * @param declaracao A declaração Var
      * @returns Um descritor de informações importantes para o retorno externo.
      */
-    async visitarDeclaracaoVar(declaracao) {
-        const valorFinal = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        let tipoResolvido = declaracao.tipo;
-        if (tipoResolvido.startsWith('função<')) {
-            tipoResolvido = tipoResolvido.replace('função<', '').replace('>', '');
-        }
-        if (!declaracao.tipoExplicito && tipoResolvido === delegua_2.default.QUALQUER && valorFinal instanceof Array) {
-            tipoResolvido = (0, inferenciador_1.inferirTipoVariavel)(valorFinal);
-        }
-        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, tipoResolvido, declaracao.tipoExplicito && declaracao.tipoOriginal !== 'qualquer');
-        return null;
+    visitarDeclaracaoVar(declaracao) {
+        return (0, encadear_1.encadear)(this.avaliacaoDeclaracaoVarOuConst(declaracao), (valorFinal) => {
+            let tipoResolvido = declaracao.tipo;
+            if (tipoResolvido.startsWith('função<') && tipoResolvido.endsWith('>')) {
+                tipoResolvido = tipoResolvido.slice('função<'.length, -1);
+            }
+            if (!declaracao.tipoExplicito && tipoResolvido === delegua_2.default.QUALQUER && valorFinal instanceof Array) {
+                tipoResolvido = (0, inferenciador_1.inferirTipoVariavel)(valorFinal);
+            }
+            this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorFinal, tipoResolvido, declaracao.tipoExplicito && declaracao.tipoOriginal !== 'qualquer');
+            return null;
+        });
     }
     /**
      * Executa expressão de definição de múltiplas variáveis.
      * @param declaracao A declaração `VarMultiplo`.
      * @returns Sempre retorna nulo.
      */
-    async visitarDeclaracaoVarMultiplo(declaracao) {
-        const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
-        for (let [indice, valor] of valoresFinais.entries()) {
-            this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
-        }
-        return null;
+    visitarDeclaracaoVarMultiplo(declaracao) {
+        return (0, encadear_1.encadear)(this.avaliacaoDeclaracaoVarOuConst(declaracao), (valoresFinais) => {
+            const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
+            for (let [indice, valor] of valoresFinais.entries()) {
+                this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
+            }
+            return null;
+        });
     }
     /**
      * Formata uma string usando o operador % (similar ao Python).
@@ -2226,34 +2274,35 @@ class InterpretadorBase {
      * @returns O resultado parcial da execução, normalmente usado por
      *          ferramentas externas.
      */
-    async executar(declaracao) {
-        const resultado = await declaracao.aceitar(this);
-        // Alguns casos não possuem retorno, como declarações `se`, `enquanto`, etc.,
-        // que não satisfazem suas respectivas condições.
-        if (resultado === null || resultado === undefined) {
-            return null;
-        }
-        // Se o retorno já possui um `valorRetornado`, apenas retorna o resultado.
-        if (resultado.hasOwnProperty('valorRetornado')) {
-            return resultado;
-        }
-        let tipoResultado = resultado.tipo;
-        switch (resultado.constructor) {
-            case estruturas_1.DescritorTipoClasse:
-                tipoResultado = resultado.simboloOriginal.lexema;
-                break;
-            default:
-                if (!tipoResultado) {
-                    tipoResultado = (0, inferenciador_1.inferirTipoVariavel)(resultado);
-                }
-                break;
-        }
-        return {
-            hashArquivo: declaracao.hashArquivo,
-            linha: declaracao.linha,
-            valorRetornado: resultado,
-            tipo: tipoResultado,
-        };
+    executar(declaracao) {
+        return (0, encadear_1.encadear)(declaracao.aceitar(this), (resultado) => {
+            // Alguns casos não possuem retorno, como declarações `se`, `enquanto`, etc.,
+            // que não satisfazem suas respectivas condições.
+            if (resultado === null || resultado === undefined) {
+                return null;
+            }
+            // Se o retorno já possui um `valorRetornado`, apenas retorna o resultado.
+            if (resultado.hasOwnProperty('valorRetornado')) {
+                return resultado;
+            }
+            let tipoResultado = resultado.tipo;
+            switch (resultado.constructor) {
+                case estruturas_1.DescritorTipoClasse:
+                    tipoResultado = resultado.simboloOriginal.lexema;
+                    break;
+                default:
+                    if (!tipoResultado) {
+                        tipoResultado = (0, inferenciador_1.inferirTipoVariavel)(resultado);
+                    }
+                    break;
+            }
+            return {
+                hashArquivo: declaracao.hashArquivo,
+                linha: declaracao.linha,
+                valorRetornado: resultado,
+                tipo: tipoResultado,
+            };
+        });
     }
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do interpretador.
@@ -2265,38 +2314,62 @@ class 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;
-        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 = () => {
             this.pilhaEscoposExecucao.removerUltimo();
             const escopoAnterior = this.pilhaEscoposExecucao.topoDaPilha();
             if (manterAmbiente || (retornoExecucao && retornoExecucao.preservarEscopo === true)) {
                 escopoAnterior.espacoMemoria.valores = Object.assign(escopoAnterior.espacoMemoria.valores, ultimoEscopo.espacoMemoria.valores);
             }
+        };
+        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();
+            // Um throw síncrono em qualquer passo da recursão é pego pelo catch abaixo; um
+            // erro que só aparece depois de a cadeia já ter virado uma Promise (algum passo
+            // realmente assíncrono no meio) vira uma rejeição, pega aqui.
+            return resultadoOuPromise instanceof Promise
+                ? resultadoOuPromise.catch(tratarErro)
+                : resultadoOuPromise;
+        }
+        catch (erro) {
+            return tratarErro(erro);
         }
     }
     /**