@designliquido/delegua 1.16.3 → 1.17.1

package/interpretador/interpretador-base.js

@@ -30,14 +30,16 @@ const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-ve
  * recomendado para uso em execuções que ocorrem no navegador de internet.
  */
 class InterpretadorBase {
-    constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
+    constructor(diretorioBase, performance = false, funcaoDeRetorno = undefined, funcaoDeRetornoMesmaLinha = undefined) {
         this.resultadoInterpretador = [];
+        this.linhaDeclaracaoAtual = -1;
+        this.hashArquivoDeclaracaoAtual = -1;
         this.classeAtualEmExecucao = null;
-        this.funcaoDeRetorno = null;
-        this.funcaoDeRetornoMesmaLinha = null;
-        this.interfaceDeEntrada = null; // Originalmente é `readline.Interface`
-        this.interfaceEntradaSaida = null;
-        this.funcaoVerificarIteracao = null;
+        this.funcaoDeRetorno = undefined;
+        this.funcaoDeRetornoMesmaLinha = undefined;
+        this.interfaceDeEntrada = undefined; // Originalmente é `readline.Interface`
+        this.interfaceEntradaSaida = undefined;
+        this.funcaoVerificarIteracao = undefined;
         this.emDeclaracaoTente = false;
         // typeName → methodName → DeleguaFuncao
         this.extensoesGlobais = new Map();
@@ -60,8 +62,12 @@ class InterpretadorBase {
         this.diretorioBase = diretorioBase;
         this.performance = performance;
         this.funcaoDeRetorno = funcaoDeRetorno || console.log;
+        const _process = globalThis.process;
         this.funcaoDeRetornoMesmaLinha =
-            funcaoDeRetornoMesmaLinha || process.stdout.write.bind(process.stdout);
+            funcaoDeRetornoMesmaLinha ||
+                (_process?.stdout?.write
+                    ? _process.stdout.write.bind(_process.stdout)
+                    : (texto) => console.log(texto));
         this.erros = [];
         this.declaracoes = [];
         this.resultadoInterpretador = [];
@@ -92,8 +98,9 @@ class InterpretadorBase {
     async cederControle(iteracoes) {
         if (iteracoes % this.iteracoesParaCederControle === 0) {
             await new Promise((resolve) => {
-                if (typeof setImmediate !== 'undefined') {
-                    setImmediate(resolve);
+                const _setImmediate = globalThis.setImmediate;
+                if (_setImmediate) {
+                    _setImmediate(resolve);
                 }
                 else {
                     setTimeout(resolve, 0);
@@ -127,10 +134,14 @@ class InterpretadorBase {
                 return this.resolverNomeObjectoAcessado((objetoAcessado as AcessoIndiceVariavel).entidadeChamada); */
             case construtos_1.Chamada:
                 return this.resolverNomeObjectoAcessado(objetoAcessado.entidadeChamada);
+            case construtos_1.Agrupamento:
+                return this.resolverNomeObjectoAcessado(objetoAcessado.expressao);
             case construtos_1.Constante:
                 return objetoAcessado.simbolo.lexema;
+            case construtos_1.AcessoMetodo:
             case construtos_1.AcessoMetodoOuPropriedade:
             case construtos_1.AcessoIndiceVariavel:
+            case construtos_1.Binario:
             case construtos_1.Dicionario:
             case construtos_1.Leia:
             case construtos_1.Literal:
@@ -248,10 +259,10 @@ class InterpretadorBase {
         const elementosComoConstrutos = elementos.map((valor) => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
         return new construtos_1.TuplaN(expressao.hashArquivo, expressao.linha, elementosComoConstrutos);
     }
-    async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
+    async visitarExpressaoAtribuicaoPorIndicesMatriz(_) {
         throw new Error('Método não implementado.');
     }
-    async visitarExpressaoAcessoElementoMatriz(expressao) {
+    async visitarExpressaoAcessoElementoMatriz(_) {
         throw new Error('Método não implementado.');
     }
     textoParaRegex(texto) {
@@ -266,14 +277,14 @@ class InterpretadorBase {
     visitarExpressaoExpressaoRegular(expressao) {
         return Promise.resolve(this.textoParaRegex(expressao.valor));
     }
-    visitarExpressaoTipoDe(expressao) {
+    visitarExpressaoTipoDe(_) {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoFalhar(expressao) {
         const textoFalha = expressao.explicacao.valor ?? (await this.avaliar(expressao.explicacao)).valor;
         throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
     }
-    async visitarExpressaoFimPara(declaracao) {
+    async visitarExpressaoFimPara(_) {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoReferenciaFuncao(expressao) {
@@ -342,6 +353,9 @@ class InterpretadorBase {
      */
     async resolverInterpolacoes(textoOriginal, linha) {
         const variaveis = textoOriginal.match(this.regexInterpolacao);
+        if (!variaveis) {
+            return [];
+        }
         return await Promise.all(variaveis.map(async (s) => {
             const expressaoInterpolacao = s.replace(/[\$\{\}]*/gm, '');
             const microLexador = this.microLexador.mapear(expressaoInterpolacao);
@@ -556,6 +570,9 @@ class InterpretadorBase {
         }
         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);
@@ -567,7 +584,7 @@ class InterpretadorBase {
             const nomeOperador = 'operador' + expressao.operador.lexema;
             const metodoOperador = valorEsquerdo.classe.encontrarMetodo(nomeOperador);
             if (metodoOperador) {
-                const metodoBound = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
+                const metodoASerChamado = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
                 const argumentoOperador = direita && Object.prototype.hasOwnProperty.call(direita, 'tipo')
                     ? direita
                     : {
@@ -575,7 +592,7 @@ class InterpretadorBase {
                         valor: valorDireito,
                         imutavel: false,
                     };
-                return await metodoBound.chamar(this, [{ nome: null, valor: argumentoOperador }]);
+                return await metodoASerChamado.chamar(this, [{ nome: null, valor: argumentoOperador }]);
             }
         }
         const tipoEsquerdo = esquerda?.hasOwnProperty('tipo')
@@ -589,13 +606,7 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for 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 esq ** dir;
+                    return this.converterParaBigInt(valorEsquerdo) ** this.converterParaBigInt(valorDireito);
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
                 return resultadoExponenciacao;
@@ -622,13 +633,7 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for 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 esq - dir;
+                    return this.converterParaBigInt(valorEsquerdo) - this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) - Number(valorDireito);
             case delegua_1.default.ADICAO:
@@ -637,15 +642,25 @@ class InterpretadorBase {
                 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 esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq + dir;
+                    return valorResolvidoEsquerdo + valorResolvidoDireito;
                 }
                 if (this.tiposNumericos.includes(tipoEsquerdo) &&
                     this.tiposNumericos.includes(tipoDireito)) {
@@ -675,13 +690,13 @@ class InterpretadorBase {
                 }
                 // Retorna BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq / dir; // Trunca automaticamente
+                    return valorResolvidoEsquerdo / valorResolvidoDireito; // Trunca automaticamente
                 }
                 return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
             case delegua_1.default.MULTIPLICACAO:
@@ -690,13 +705,13 @@ class InterpretadorBase {
                 if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
                     tipoEsquerdo !== delegua_2.default.TEXTO &&
                     tipoDireito !== delegua_2.default.TEXTO) {
-                    const esq = typeof valorEsquerdo === 'bigint'
+                    const valorResolvidoEsquerdo = typeof valorEsquerdo === 'bigint'
                         ? valorEsquerdo
                         : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
+                    const valorResolvidoDireito = typeof valorDireito === 'bigint'
                         ? valorDireito
                         : BigInt(Math.floor(Number(valorDireito)));
-                    return esq * dir;
+                    return valorResolvidoEsquerdo * valorResolvidoDireito;
                 }
                 if (tipoEsquerdo === delegua_2.default.TEXTO ||
                     tipoDireito === delegua_2.default.TEXTO) {
@@ -743,13 +758,7 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for 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 esq & dir;
+                    return this.converterParaBigInt(valorEsquerdo) & this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) & Number(valorDireito);
             case delegua_1.default.CIRCUMFLEXO:
@@ -759,13 +768,7 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for 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 esq ^ dir;
+                    return this.converterParaBigInt(valorEsquerdo) ^ this.converterParaBigInt(valorDireito);
                 }
                 return Number(valorEsquerdo) ^ Number(valorDireito);
             case delegua_1.default.BIT_OR:
@@ -775,45 +778,21 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for 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 esq | dir;
+                    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
-                const tamanhoDeslocamentoEsquerda = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' ||
-                    typeof valorDireito === 'bigint' ||
-                    tamanhoDeslocamentoEsquerda >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint'
-                        ? valorEsquerdo
-                        : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
-                        ? valorDireito
-                        : BigInt(Math.floor(Number(valorDireito)));
-                    return esq << dir;
+                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
-                const tamanhoDeslocamentoDireita = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' ||
-                    typeof valorDireito === 'bigint' ||
-                    tamanhoDeslocamentoDireita >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint'
-                        ? valorEsquerdo
-                        : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint'
-                        ? valorDireito
-                        : BigInt(Math.floor(Number(valorDireito)));
-                    return esq >> dir;
+                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:
@@ -846,7 +825,7 @@ class InterpretadorBase {
                 : undefined;
             let valor = await this.avaliar(variavelArgumento);
             argumentos.push({
-                nome: nomeArgumento,
+                nome: nomeArgumento ?? null,
                 valor,
             });
         }
@@ -860,11 +839,11 @@ class InterpretadorBase {
     async visitarExpressaoDeChamada(expressao) {
         try {
             let variavelEntidadeChamada = await this.avaliar(expressao.entidadeChamada);
-            if (variavelEntidadeChamada === null) {
+            if (variavelEntidadeChamada === null || variavelEntidadeChamada === undefined) {
                 return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Chamada de função ou método inexistente: ' +
                     String(expressao.entidadeChamada), expressao.linha));
             }
-            if (variavelEntidadeChamada.hasOwnProperty('valorRetornado')) {
+            if (Object.prototype.hasOwnProperty.call(variavelEntidadeChamada, 'valorRetornado')) {
                 variavelEntidadeChamada = variavelEntidadeChamada.valorRetornado;
             }
             let entidadeChamada = this.resolverValor(variavelEntidadeChamada);
@@ -915,8 +894,8 @@ class InterpretadorBase {
             // mesmo que esteja tudo certo com `DeleguaFuncao`,
             // então precisamos testar o nome do construtor também.
             if (entidadeChamada instanceof estruturas_1.Chamavel ||
-                entidadeChamada.constructor.name === 'DeleguaFuncao' ||
-                entidadeChamada.constructor.name === 'MetodoPolimorfico') {
+                entidadeChamada.constructor === estruturas_1.DeleguaFuncao ||
+                entidadeChamada.constructor === estruturas_1.MetodoPolimorfico) {
                 const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
                 return retornoEntidadeChamada;
             }
@@ -962,10 +941,6 @@ class InterpretadorBase {
             indice = this.resolverValor(await this.avaliar(expressao.indice));
         }
         switch (expressao.alvo.constructor) {
-            case construtos_1.Variavel:
-                const alvoVariavel = expressao.alvo;
-                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
-                break;
             case construtos_1.AcessoMetodoOuPropriedade:
                 // Nunca será método aqui: apenas propriedade.
                 const alvoPropriedade = expressao.alvo;
@@ -977,8 +952,12 @@ class InterpretadorBase {
                     await objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor, this);
                 }
                 break;
+            case construtos_1.Variavel:
+                const alvoVariavel = expressao.alvo;
+                this.pilhaEscoposExecucao.atribuirVariavel(alvoVariavel.simbolo, valorResolvido, indice);
+                break;
             default:
-                throw new excecoes_1.ErroEmTempoDeExecucao(null, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloOperador, `Atribuição com caso faltante: ${JSON.stringify(expressao)}.`);
         }
         return valorResolvido;
     }
@@ -1070,10 +1049,10 @@ class InterpretadorBase {
         const declaracaoInicializador = Array.isArray(declaracao.inicializador)
             ? declaracao.inicializador[0]
             : declaracao.inicializador;
-        if (declaracaoInicializador !== null) {
+        if (declaracaoInicializador !== null && declaracaoInicializador !== undefined) {
             await this.avaliar(declaracaoInicializador);
         }
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
             if (declaracao.condicao !== null &&
@@ -1087,7 +1066,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -1098,15 +1077,19 @@ class InterpretadorBase {
                 });
                 return Promise.reject(erro);
             }
-            if (declaracao.incrementar !== null) {
+            if (declaracao.incrementar) {
                 await this.avaliar(declaracao.incrementar);
             }
         }
         return retornoExecucao;
     }
-    // TODO: Descobrir se mais algum dialeto, fora Delégua e Pituguês, usam isso.
+    /**
+     * Lógica de `para cada`, usada por Delégua, Pituguês, e Tenda.
+     * @param {ParaCada} declaracao A declaração de `para cada` a ser executada.
+     * @returns {Promise<any>} O resultado da execução da declaração.
+     */
     async visitarDeclaracaoParaCada(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         // Posição atual precisa ser reiniciada, pois pode estar dentro de outro
         // laço de repetição.
         declaracao.posicaoAtual = 0;
@@ -1144,7 +1127,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
                 declaracao.posicaoAtual++;
             }
@@ -1170,19 +1153,20 @@ class InterpretadorBase {
         if (this.eVerdadeiro(avaliacaoCondicaoSe)) {
             return await this.executar(declaracao.caminhoEntao);
         }
-        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
-            const atual = declaracao.caminhosSeSenao[i];
+        const declaracaoCaminhosSeSenao = declaracao.caminhosSeSenao || [];
+        for (let i = 0; i < declaracaoCaminhosSeSenao.length; i++) {
+            const atual = declaracaoCaminhosSeSenao[i];
             if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
                 return await this.executar(atual.caminho);
             }
         }
-        if (declaracao.caminhoSenao !== null) {
+        if (declaracao.caminhoSenao) {
             return await this.executar(declaracao.caminhoSenao);
         }
         return null;
     }
     async visitarDeclaracaoEnquanto(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) &&
             this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
@@ -1193,7 +1177,7 @@ class InterpretadorBase {
                     return null;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -1248,17 +1232,17 @@ class InterpretadorBase {
         }
     }
     async visitarDeclaracaoFazer(declaracao) {
-        let retornoExecucao;
+        let retornoExecucao = undefined;
         let iteracoes = 0;
         do {
             try {
                 await this.cederControle(++iteracoes);
                 retornoExecucao = await this.executar(declaracao.caminhoFazer);
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
-                    return null;
+                    return undefined;
                 }
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.ContinuarQuebra) {
-                    retornoExecucao = null;
+                    retornoExecucao = undefined;
                 }
             }
             catch (erro) {
@@ -1300,7 +1284,7 @@ class InterpretadorBase {
             }
         }
         finally {
-            if (declaracao.caminhoFinalmente !== null)
+            if (declaracao.caminhoFinalmente)
                 valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
             this.emDeclaracaoTente = false;
         }
@@ -1332,7 +1316,7 @@ class InterpretadorBase {
     async visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetornoMesmaLinha(formatoTexto);
+            this.funcaoDeRetornoMesmaLinha?.(formatoTexto);
             return {
                 tipo: 'vazio',
                 tipoExplicito: false,
@@ -1355,7 +1339,7 @@ class InterpretadorBase {
     async visitarDeclaracaoEscreva(declaracao) {
         try {
             const formatoTexto = await this.avaliarArgumentosEscreva(declaracao.argumentos);
-            this.funcaoDeRetorno(formatoTexto);
+            this.funcaoDeRetorno?.(formatoTexto);
             return {
                 tipo: 'vazio',
                 tipoExplicito: false,
@@ -1399,7 +1383,7 @@ class InterpretadorBase {
     }
     async avaliacaoDeclaracaoVarOuConst(declaracao) {
         let valorOuOutraVariavel = null;
-        if (declaracao.inicializador !== null) {
+        if (declaracao.inicializador != null) {
             valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
         }
         let valorFinal = null;
@@ -1428,16 +1412,16 @@ class InterpretadorBase {
      */
     async visitarDeclaracaoConstMultiplo(declaracao) {
         const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = declaracao.tipo.replace('[]', '');
+        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
         for (let [indice, valor] of valoresFinais.entries()) {
             this.pilhaEscoposExecucao.definirConstante(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
         }
         return null;
     }
-    visitarExpressaoContinua(declaracao) {
+    visitarExpressaoContinua(_) {
         return new quebras_1.ContinuarQuebra();
     }
-    visitarExpressaoSustar(declaracao) {
+    visitarExpressaoSustar(_) {
         return new quebras_1.SustarQuebra();
     }
     async visitarExpressaoRetornar(declaracao) {
@@ -1617,133 +1601,29 @@ class InterpretadorBase {
         if (superClassesResolvidas.length > 0) {
             this.pilhaEscoposExecucao.definirVariavel('super', superClassesResolvidas[0]);
         }
+        const descritorTipoClasse = this.resolverMetodoDeClasse(declaracao, superClassesResolvidas, mesclaResolvidas);
+        // TODO: Até então, a única exceção a isso é Égua Clássico.
+        // Por enquanto, tudo bem deixar isso aqui.
+        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
+        return descritorTipoClasse;
+    }
+    resolverMetodoDeClasse(declaracao, superClassesResolvidas, _mesclaResolvidas) {
         const metodos = {};
-        const metodosEstaticos = {};
-        const obtenedores = {};
-        const definidores = {};
-        const obtenedoresEstaticos = {};
-        const definidoresEstaticos = {};
-        const metodosAbstratos = [];
-        const acessoMetodos = {};
-        const acessoPropriedades = {};
-        const definirMetodos = declaracao.metodos;
-        for (let i = 0; i < declaracao.metodos.length; i++) {
-            const metodoAtual = definirMetodos[i];
+        for (const metodoAtual of declaracao.metodos) {
             const nomeMetodo = metodoAtual.simbolo.lexema;
-            // Registrar nível de acesso do método.
-            if (metodoAtual.acesso && metodoAtual.acesso !== 'publico') {
-                acessoMetodos[nomeMetodo] = metodoAtual.acesso;
-            }
-            // Métodos abstratos: registrar apenas o nome, não criar função executável.
-            if (metodoAtual.abstrato) {
-                metodosAbstratos.push(nomeMetodo);
-                continue;
-            }
             const eInicializador = nomeMetodo === 'construtor';
             const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoAtual.funcao, undefined, eInicializador);
             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;
-            if (metodoAtual.eObtenedor) {
-                if (ehEstatico) {
-                    obtenedoresEstaticos[nomeMetodo] = funcao;
-                }
-                else {
-                    obtenedores[nomeMetodo] = funcao;
-                }
-                continue;
-            }
-            if (metodoAtual.eDefinidor) {
-                if (ehEstatico) {
-                    definidoresEstaticos[nomeMetodo] = funcao;
-                }
-                else {
-                    definidores[nomeMetodo] = funcao;
-                }
-                continue;
-            }
-            const destino = ehEstatico && !eInicializador ? metodosEstaticos : metodos;
-            if (destino[nomeMetodo]) {
-                if (!Array.isArray(destino[nomeMetodo])) {
-                    destino[nomeMetodo] = [destino[nomeMetodo]];
-                }
-                destino[nomeMetodo].push(funcao);
-            }
-            else {
-                destino[nomeMetodo] = funcao;
-            }
-        }
-        // Registrar propriedades estáticas no mapa de membros estáticos e níveis de acesso.
-        // Numa classe estática, todas as propriedades são tratadas como estáticas.
-        const membrosEstaticos = {};
-        for (const prop of declaracao.propriedades) {
-            if (prop.estatico || declaracao.classeEstatica) {
-                membrosEstaticos[prop.nome.lexema] = undefined;
-            }
-            if (prop.acesso && prop.acesso !== 'publico') {
-                acessoPropriedades[prop.nome.lexema] = prop.acesso;
-            }
+            metodos[nomeMetodo] = funcao;
         }
         const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClassesResolvidas, metodos, declaracao.propriedades);
-        descritorTipoClasse.metodosEstaticos = metodosEstaticos;
-        descritorTipoClasse.membrosEstaticos = membrosEstaticos;
-        descritorTipoClasse.obtenedores = obtenedores;
-        descritorTipoClasse.definidores = definidores;
-        descritorTipoClasse.obtenedoresEstaticos = obtenedoresEstaticos;
-        descritorTipoClasse.definidoresEstaticos = definidoresEstaticos;
-        descritorTipoClasse.abstrata = declaracao.abstrata;
-        descritorTipoClasse.estrangeira = declaracao.estrangeira;
-        descritorTipoClasse.classeEstatica = declaracao.classeEstatica;
-        descritorTipoClasse.metodosAbstratos = metodosAbstratos;
-        descritorTipoClasse.acessoMetodos = acessoMetodos;
-        descritorTipoClasse.acessoPropriedades = acessoPropriedades;
-        // Toda classe sem superclasse explícita herda implicitamente de `Objeto`.
-        // Isso só deve acontecer quando OBJETO_BASE já estiver inicializado e a classe
-        // atual não for o próprio OBJETO_BASE, para evitar cadeias de herança recursivas.
         if (descritorTipoClasse.superClasses.length === 0 &&
             estruturas_1.OBJETO_BASE &&
             descritorTipoClasse !== estruturas_1.OBJETO_BASE) {
             descritorTipoClasse.superClasses = [estruturas_1.OBJETO_BASE];
         }
-        // Calcular o OReM (linearização C3) após os pais estarem definidos.
         descritorTipoClasse.orem = estruturas_1.DescritorTipoClasse.computarOReM(descritorTipoClasse);
-        // Mesclar métodos e propriedades dos misturávels (primeiro misturável ganha se não definido na classe).
-        for (const misturável of mesclaResolvidas) {
-            for (const [nome, funcao] of Object.entries(misturável.metodos)) {
-                if (!descritorTipoClasse.metodos.hasOwnProperty(nome)) {
-                    descritorTipoClasse.metodos[nome] = funcao;
-                }
-            }
-            for (const [nome, funcao] of Object.entries(misturável.obtenedores)) {
-                if (!descritorTipoClasse.obtenedores.hasOwnProperty(nome)) {
-                    descritorTipoClasse.obtenedores[nome] = funcao;
-                }
-            }
-            for (const [nome, funcao] of Object.entries(misturável.definidores)) {
-                if (!descritorTipoClasse.definidores.hasOwnProperty(nome)) {
-                    descritorTipoClasse.definidores[nome] = funcao;
-                }
-            }
-            for (const prop of misturável.propriedades) {
-                const jaDeclarada = descritorTipoClasse.propriedades.some((p) => p.nome.lexema === prop.nome.lexema);
-                if (!jaDeclarada) {
-                    descritorTipoClasse.propriedades.push(prop);
-                }
-            }
-        }
-        // Verifica se a subclasse concreta implementa todos os métodos abstratos
-        // da(s) superclasse(s) abstrata(s).
-        if (!declaracao.abstrata && !declaracao.estrangeira) {
-            for (const superClasse of superClassesResolvidas) {
-                if (superClasse.abstrata || superClasse.estrangeira) {
-                    superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
-                }
-            }
-        }
-        // TODO: Até então, a única exceção a isso é Égua Clássico.
-        // Por enquanto, tudo bem deixar isso aqui.
-        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
-        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
         return descritorTipoClasse;
     }
     /**
@@ -1790,7 +1670,8 @@ class InterpretadorBase {
                 if (!this.extensoesGlobais.has(tipoNome)) {
                     this.extensoesGlobais.set(tipoNome, new Map());
                 }
-                this.extensoesGlobais.get(tipoNome).set(nomeMetodo, funcao);
+                const extensaoGlobal = this.extensoesGlobais.get(tipoNome);
+                extensaoGlobal?.set(nomeMetodo, funcao);
             }
             else {
                 const hash = declaracao.hashArquivo;
@@ -1798,10 +1679,13 @@ class InterpretadorBase {
                     this.extensoesModulo.set(hash, new Map());
                 }
                 const mapa = this.extensoesModulo.get(hash);
+                if (!mapa) {
+                    throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloTipo, 'Erro interno: mapa de extensões do módulo não encontrado.', declaracao.linha);
+                }
                 if (!mapa.has(tipoNome)) {
-                    mapa.set(tipoNome, new Map());
+                    mapa?.set(tipoNome, new Map());
                 }
-                mapa.get(tipoNome).set(nomeMetodo, funcao);
+                mapa.get(tipoNome)?.set(nomeMetodo, funcao);
             }
         }
     }
@@ -1904,7 +1788,7 @@ class InterpretadorBase {
                     dicionario[chaveLogico] = this.resolverValor(promises[1]);
                     continue;
                 }
-                dicionario[promises[0]] = this.resolverValor(promises[1]);
+                dicionario[promises[0].toString()] = this.resolverValor(promises[1]);
             }
         }
         return dicionario;
@@ -1947,7 +1831,7 @@ class InterpretadorBase {
      */
     async visitarDeclaracaoVarMultiplo(declaracao) {
         const valoresFinais = await this.avaliacaoDeclaracaoVarOuConst(declaracao);
-        const tipoIndividual = declaracao.tipo.replace('[]', '');
+        const tipoIndividual = (declaracao.tipo || '').replace('[]', '');
         for (let [indice, valor] of valoresFinais.entries()) {
             this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolos[indice].lexema, valor, tipoIndividual);
         }