@designliquido/delegua 1.11.0 → 1.12.0

package/interpretador/interpretador-base.js

@@ -172,7 +172,7 @@ class InterpretadorBase {
         }
         // Se é array, resolve recursivamente todos os elementos
         if (Array.isArray(objeto)) {
-            return objeto.map(elemento => this.resolverValorRecursivo(elemento));
+            return objeto.map((elemento) => this.resolverValorRecursivo(elemento));
         }
         // Se é objeto plano, resolve recursivamente todas as propriedades
         if (objeto && objeto.constructor && objeto.constructor === Object) {
@@ -215,8 +215,18 @@ class InterpretadorBase {
     async visitarExpressaoTupla(expressao) {
         // Lista de propriedades válidas para tuplas (ignorar propriedades de controle)
         const propriedadesValidas = [
-            'primeiro', 'segundo', 'terceiro', 'quarto', 'quinto',
-            'sexto', 'sétimo', 'setimo', 'oitavo', 'nono', 'décimo', 'decimo'
+            'primeiro',
+            'segundo',
+            'terceiro',
+            'quarto',
+            'quinto',
+            'sexto',
+            'sétimo',
+            'setimo',
+            'oitavo',
+            'nono',
+            'décimo',
+            'decimo',
         ];
         const valores = [];
         for (let propriedade of propriedadesValidas) {
@@ -233,7 +243,7 @@ class InterpretadorBase {
             const res = await this.avaliar(expressao.elementos[i]);
             elementos.push(this.resolverValor(res));
         }
-        const elementosComoConstrutos = elementos.map(valor => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
+        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) {
@@ -575,8 +585,12 @@ 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)));
+                    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;
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
@@ -604,8 +618,12 @@ 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)));
+                    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 Number(valorEsquerdo) - Number(valorDireito);
@@ -617,8 +635,12 @@ class InterpretadorBase {
                 }
                 // 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)));
+                    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 (this.tiposNumericos.includes(tipoEsquerdo) &&
@@ -648,8 +670,12 @@ class InterpretadorBase {
                 }
                 // Retorna 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)));
+                    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; // Trunca automaticamente
                 }
                 return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
@@ -659,8 +685,12 @@ class InterpretadorBase {
                 if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
                     tipoEsquerdo !== delegua_2.default.TEXTO &&
                     tipoDireito !== delegua_2.default.TEXTO) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    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 (tipoEsquerdo === delegua_2.default.TEXTO ||
@@ -693,7 +723,8 @@ class InterpretadorBase {
             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') {
+                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);
                 }
@@ -707,8 +738,12 @@ 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)));
+                    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 Number(valorEsquerdo) & Number(valorDireito);
@@ -719,8 +754,12 @@ 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)));
+                    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 Number(valorEsquerdo) ^ Number(valorDireito);
@@ -731,8 +770,12 @@ 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)));
+                    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 Number(valorEsquerdo) | Number(valorDireito);
@@ -740,9 +783,15 @@ class InterpretadorBase {
                 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)));
+                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;
                 }
                 return Number(valorEsquerdo) << Number(valorDireito);
@@ -750,9 +799,15 @@ class InterpretadorBase {
                 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)));
+                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;
                 }
                 return Number(valorEsquerdo) >> Number(valorDireito);
@@ -873,7 +928,8 @@ class InterpretadorBase {
             // Casos que passam aqui: chamadas a métodos de bibliotecas de Delégua.
             if (typeof entidadeChamada === primitivos_1.default.FUNCAO) {
                 let objeto = null;
-                if (expressao.entidadeChamada.objeto) { // TODO: Qual o tipo certo aqui?
+                if (expressao.entidadeChamada.objeto) {
+                    // TODO: Qual o tipo certo aqui?
                     objeto = await this.avaliar(expressao.entidadeChamada.objeto);
                 }
                 return entidadeChamada.apply(this.resolverValor(objeto), argumentos);
@@ -932,7 +988,8 @@ class InterpretadorBase {
     }
     logicaContemOuEm(esquerda, direita, expressao) {
         const valorDireitoResolvido = this.resolverValor(direita);
-        if (Array.isArray(valorDireitoResolvido) || typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
+        if (Array.isArray(valorDireitoResolvido) ||
+            typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
             const avaliacao = valorDireitoResolvido.includes(esquerda);
             return expressao.negado ? !avaliacao : avaliacao;
         }
@@ -964,13 +1021,19 @@ class InterpretadorBase {
                 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);
+                        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));
+                        ? Number(valorEsquerdo) & Number(valorDireito)
+                        : Number(valorEsquerdo) | Number(valorDireito);
                 }
                 // Demais casos sem diferença de tipos
                 if (expressao.operador.tipo === delegua_1.default.OU) {
@@ -1064,7 +1127,7 @@ class InterpretadorBase {
                     const valorComoDupla = valorVetorResolvido[declaracao.posicaoAtual];
                     const promises = await Promise.all([
                         this.avaliar(declaracao.variavelIteracao.primeiro),
-                        this.avaliar(declaracao.variavelIteracao.segundo)
+                        this.avaliar(declaracao.variavelIteracao.segundo),
                     ]);
                     // TODO: O que fazer quando não forem literais?
                     this.pilhaEscoposExecucao.definirVariavel(String(promises[0].valor), valorComoDupla.primeiro);
@@ -1244,7 +1307,9 @@ class InterpretadorBase {
         let formatoTexto = '';
         for (const argumento of argumentos) {
             let resultadoAvaliacao = await this.avaliar(argumento);
-            if (resultadoAvaliacao && resultadoAvaliacao.hasOwnProperty && resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
+            if (resultadoAvaliacao &&
+                resultadoAvaliacao.hasOwnProperty &&
+                resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
                 resultadoAvaliacao = resultadoAvaliacao.valorRetornado;
             }
             let valor = this.resolverValor(resultadoAvaliacao);
@@ -1485,12 +1550,12 @@ class InterpretadorBase {
         }, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
     /**
-        * Método base para acesso a intervalo.
-        * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
-        * ainda não suporta isso nativamente, apenas Pituguês.
-    */
+     * Método base para acesso a intervalo.
+     * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
+     * ainda não suporta isso nativamente, apenas Pituguês.
+     */
     visitarExpressaoAcessoIntervaloVariavel(expressao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, "Acesso por intervalo não implementado para este dialeto.", expressao.linha));
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Acesso por intervalo não implementado para este dialeto.', expressao.linha));
     }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
@@ -1507,14 +1572,12 @@ class InterpretadorBase {
             objeto[expressao.nome.lexema] = valor;
         }
     }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
         const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         funcao.documentacao = declaracao.documentacao;
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         this.pilhaEscoposExecucao.registrarReferenciaFuncao(declaracao.id, funcao);
-        return Promise.resolve({
-            declaracao: funcao,
-        });
+        return { declaracao: funcao };
     }
     /**
      * Executa uma declaração de classe.
@@ -1574,9 +1637,7 @@ class InterpretadorBase {
             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;
+            const ehEstatico = declaracao.classeEstatica ? !eInicializador : metodoAtual.estatico;
             if (metodoAtual.eObtenedor) {
                 if (ehEstatico) {
                     obtenedoresEstaticos[nomeMetodo] = funcao;
@@ -1632,7 +1693,9 @@ class InterpretadorBase {
         // 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) {
+        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.
@@ -1895,21 +1958,25 @@ class InterpretadorBase {
         let valoresArray;
         // Verificar se é uma TuplaN (verifica instanceof OU propriedade elementos/tipo para maior compatibilidade)
         if (valores instanceof construtos_1.TuplaN ||
-            (valores && valores.tipo === 'tupla' && valores.elementos && Array.isArray(valores.elementos))) {
+            (valores &&
+                valores.tipo === 'tupla' &&
+                valores.elementos &&
+                Array.isArray(valores.elementos))) {
             valoresArray = valores.elementos.map((elem) => {
-                if (elem instanceof construtos_1.Literal || (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
+                if (elem instanceof construtos_1.Literal ||
+                    (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
                     return this.resolverValor(elem.valor);
                 }
                 return this.resolverValor(elem);
             });
         }
         else if (Array.isArray(valores)) {
-            valoresArray = valores.map(v => this.resolverValor(v));
+            valoresArray = valores.map((v) => this.resolverValor(v));
         }
         else {
             const valorResolvido = this.resolverValor(valores);
             if (Array.isArray(valorResolvido)) {
-                valoresArray = valorResolvido.map(v => this.resolverValor(v));
+                valoresArray = valorResolvido.map((v) => this.resolverValor(v));
             }
             else {
                 valoresArray = [valorResolvido];
@@ -2031,7 +2098,9 @@ class InterpretadorBase {
             return objeto.valor.paraTexto();
         if (objeto instanceof construtos_1.Literal)
             return this.paraTexto(objeto.valor);
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao || objeto instanceof estruturas_1.DescritorTipoClasse)
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse)
             return objeto.paraTexto();
         if (objeto instanceof quebras_1.RetornoQuebra) {
             if (typeof objeto.valor === 'boolean')