@designliquido/delegua 1.23.1 → 1.23.3

package/umd/delegua.js

@@ -2408,6 +2408,28 @@ const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitiv
 const primitivas_numero_1 = __importDefault(require("../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-vetor"));
+// Constante usada em "declaracaoRetorna()"
+const simbolosInicioExpressao = new Set([
+    delegua_2.default.CHAVE_ESQUERDA,
+    delegua_2.default.COLCHETE_ESQUERDO,
+    delegua_2.default.FALSO,
+    delegua_2.default.FUNCAO,
+    delegua_2.default.FUNÇÃO,
+    delegua_2.default.IDENTIFICADOR,
+    delegua_2.default.ISTO,
+    delegua_2.default.NAO,
+    delegua_2.default.NEGACAO,
+    delegua_2.default.NUMERO,
+    delegua_2.default.NULO,
+    delegua_2.default.PARENTESE_ESQUERDO,
+    delegua_2.default.SUPER,
+    delegua_2.default.TEXTO,
+    delegua_2.default.VERDADEIRO,
+    delegua_2.default.ADICAO,
+    delegua_2.default.SUBTRACAO,
+    delegua_2.default.INCREMENTAR,
+    delegua_2.default.DECREMENTAR
+]);
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -3073,7 +3095,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return await this.resolverCadeiaChamadas(chamada);
             case delegua_2.default.PONTO:
                 this.avancarEDevolverAnterior();
-                this.verificarSeSimboloAtualEIgualA();
+                const simboloAtual = this.simbolos[this.atual];
+                if (!simboloAtual ||
+                    !/^[A-Za-z_$À-ÿ][A-Za-z0-9_$À-ÿ]*$/.test(simboloAtual.lexema)) {
+                    throw this.erro(simboloAtual, "Esperado nome do método ou propriedade após o '.'");
+                }
                 const nome = this.avancarEDevolverAnterior();
                 let tipoInferido = expressaoAnterior.tipo;
                 // Se não for um dicionário anônimo (ou seja, ser variável ou constante com nome)
@@ -4013,24 +4039,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     async declaracaoRetorna() {
         const simboloChave = this.simbolos[this.atual - 1];
-        let valor = null;
-        if ([
-            delegua_2.default.CHAVE_ESQUERDA,
-            delegua_2.default.COLCHETE_ESQUERDO,
-            delegua_2.default.FALSO,
-            delegua_2.default.FUNCAO,
-            delegua_2.default.FUNÇÃO,
-            delegua_2.default.IDENTIFICADOR,
-            delegua_2.default.ISTO,
-            delegua_2.default.NAO,
-            delegua_2.default.NEGACAO,
-            delegua_2.default.NUMERO,
-            delegua_2.default.NULO,
-            delegua_2.default.PARENTESE_ESQUERDO,
-            delegua_2.default.SUPER,
-            delegua_2.default.TEXTO,
-            delegua_2.default.VERDADEIRO,
-        ].includes(this.simbolos[this.atual].tipo)) {
+        const simboloAtual = this.simbolos[this.atual];
+        let valor;
+        if (simboloAtual && simbolosInicioExpressao.has(simboloAtual.tipo)) {
             valor = await this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
@@ -4322,51 +4333,46 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      */
     async declaracaoDeVariaveis() {
         const simboloVariavel = this.simboloAnterior();
-        const identificadores = [];
-        const retorno = [];
-        let tipo = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return await this.declaracaoDesestruturacaoVariavel();
         }
+        const identificadores = [];
         do {
             identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        let tipo = 'qualquer';
         let tipoExplicito = false;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             tipoExplicito = true;
             this.avancarEDevolverAnterior();
         }
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
-            // Inicialização de variáveis sem valor.
-            for (let identificador of identificadores.values()) {
+        const retorno = [];
+        const decoradores = Array.from(this.pilhaDecoradores);
+        const temAtribuicao = this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA);
+        if (!temAtribuicao) {
+            for (const identificador of identificadores) {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
-                retorno.push(new declaracoes_1.Var(identificador, undefined, tipo, tipoExplicito, Array.from(this.pilhaDecoradores)));
+                retorno.push(new declaracoes_1.Var(identificador, undefined, tipo, tipoExplicito, decoradores));
             }
-            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
-            this.pilhaDecoradores = [];
-            return retorno;
         }
-        const inicializadores = [];
-        do {
-            inicializadores.push(await this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
-        if (identificadores.length !== inicializadores.length) {
-            throw this.erro(simboloVariavel, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
-        }
-        for (let [indice, identificador] of identificadores.entries()) {
-            const tipoOriginal = tipo; // Preserva o tipo antes da inferência
-            tipo =
-                this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo) ?? tipo;
-            if (tipo !== 'dicionário') {
-                this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
+        else {
+            const inicializadores = [];
+            do {
+                inicializadores.push(await this.expressao());
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+            if (identificadores.length !== inicializadores.length) {
+                throw this.erro(simboloVariavel, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
             }
-            else {
-                const inicializadorDicionario = inicializadores[indice];
-                this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, this.resolverInformacaoElementoSintaticoDeDicionario(inicializadorDicionario));
+            for (let [indice, identificador] of identificadores.entries()) {
+                const inicializador = inicializadores[indice];
+                const tipoInferido = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipo) ?? tipo;
+                const informacaoSintatica = tipo === 'dicionário'
+                    ? this.resolverInformacaoElementoSintaticoDeDicionario(inicializador)
+                    : new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipoInferido);
+                this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, informacaoSintatica);
+                retorno.push(new declaracoes_1.Var(identificador, inicializador, tipoInferido, tipoExplicito, decoradores, tipo));
             }
-            retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice], tipo, tipoExplicito, Array.from(this.pilhaDecoradores), tipoOriginal // Passa o tipo original para o construtor
-            ));
         }
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         this.pilhaDecoradores = [];
@@ -6364,9 +6370,8 @@ class AvaliadorSintaticoPitugues {
         throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Primitiva '${entidadeChamada.simbolo.lexema}' não existe.`);
     }
     logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipoPrevio) {
-        if (tipoPrevio !== 'qualquer') {
+        if (tipoPrevio !== 'qualquer')
             return tipoPrevio;
-        }
         switch (inicializador.constructor) {
             case construtos_1.AcessoIndiceVariavel:
                 const entidadeChamadaAcessoIndiceVariavel = inicializador
@@ -6399,7 +6404,16 @@ class AvaliadorSintaticoPitugues {
                         return entidadeChamadaReferenciaFuncao.tipo;
                     case construtos_1.Variavel:
                         const entidadeChamadaVariavel = entidadeChamadaChamada;
-                        return entidadeChamadaVariavel.tipo;
+                        const tipoBruto = entidadeChamadaVariavel.tipo;
+                        if (tipoBruto &&
+                            tipoBruto.startsWith('função<') &&
+                            tipoBruto.endsWith('>')) {
+                            return tipoBruto.substring(7, tipoBruto.length - 1);
+                        }
+                        else if (tipoBruto === 'função') {
+                            return 'qualquer';
+                        }
+                        return tipoBruto;
                 }
                 break;
             case construtos_1.FuncaoConstruto:
@@ -6579,15 +6593,13 @@ class AvaliadorSintaticoPitugues {
         const qtdIdentificadores = identificadores.length;
         const qtdValores = inicializadores.length;
         const ehDesempacotamento = qtdIdentificadores > 1 && qtdValores === 1;
-        if (indexResto > -1) {
-            if (qtdValores < qtdIdentificadores - 1) {
-                if (!ehDesempacotamento ||
-                    (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
-                    throw this.erro(this.simboloAnterior(), 'Quantidade insuficiente de valores para desempacotamento com operador de resto.');
-                }
+        if (indexResto > -1 && qtdValores < qtdIdentificadores - 1) {
+            if (!ehDesempacotamento ||
+                (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Literal)) {
+                throw this.erro(this.simboloAnterior(), 'Quantidade insuficiente de valores para desempacotamento com operador de resto.');
             }
         }
-        else {
+        else if (indexResto === -1) {
             if (!ehDesempacotamento && qtdIdentificadores !== qtdValores) {
                 throw this.erro(this.simboloAnterior(), 'Quantidade de inicializadores à esquerda do igual é diferente da quantidade de identificadores à direita.');
             }
@@ -6600,41 +6612,52 @@ class AvaliadorSintaticoPitugues {
         }
         const retorno = [];
         let origemParaAtribuicao = inicializadores[0];
-        // Injeção de Código (Runtime Check)
+        // Injeção de código para variáveis temporárias
         if (ehDesempacotamento && !(inicializadores[0] instanceof construtos_1.Vetor)) {
             const linha = identificadores[0].linha;
-            // Cria variável temporária para evitar reavaliar a expressão original múltiplas vezes
             const nomeVarTemp = `__temp_desempacotamento_${new Date().getTime()}_${Math.floor(Math.random() * 1000)}`;
             const simboloVarTemp = new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, nomeVarTemp, null, linha, -1);
             retorno.push(new declaracoes_1.Var(simboloVarTemp, inicializadores[0], 'qualquer[]'));
             origemParaAtribuicao = new construtos_1.Variavel(this.hashArquivo, simboloVarTemp);
-            // Injeta validação de tamanho se não houver operador de resto
             if (indexResto === -1) {
                 retorno.push(this.construirValidacaoDesempacotamento(identificadores[0], origemParaAtribuicao, qtdIdentificadores));
             }
         }
-        let cursorValores = 0;
         const qtdParaResto = qtdValores - (qtdIdentificadores - 1);
-        for (let i = 0; i < identificadores.length; i++) {
+        const elementosAposResto = qtdIdentificadores - 1 - indexResto;
+        let cursorValores = 0;
+        let cursorDesempacotamento = 0;
+        for (let i = 0; i < qtdIdentificadores; i++) {
             const identificador = identificadores[i];
             let inicializador;
             let tipo = 'qualquer';
             if (i === indexResto) {
-                const valoresResto = inicializadores.slice(cursorValores, cursorValores + qtdParaResto);
+                let valoresResto;
+                if (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Vetor) {
+                    const vetorLiteral = inicializadores[0];
+                    valoresResto = vetorLiteral.valores.slice(cursorDesempacotamento, vetorLiteral.valores.length - elementosAposResto);
+                    cursorDesempacotamento += valoresResto.length;
+                }
+                else {
+                    valoresResto = inicializadores.slice(cursorValores, cursorValores + qtdParaResto);
+                    cursorValores += qtdParaResto;
+                }
                 let tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(valoresResto);
-                if (!tipoInferido.endsWith('[]'))
+                if (!tipoInferido.endsWith('[]')) {
                     tipoInferido = `${tipoInferido}[]`;
+                }
                 inicializador = new construtos_1.Vetor(identificador.hashArquivo, identificador.linha, valoresResto, tipoInferido);
                 tipo = tipoInferido;
-                cursorValores += qtdParaResto;
             }
             else if (ehDesempacotamento) {
                 if (inicializadores[0] instanceof construtos_1.Vetor) {
-                    inicializador = inicializadores[0].valores[i];
+                    const vetorLiteral = inicializadores[0];
+                    inicializador = vetorLiteral.valores[cursorDesempacotamento];
                 }
                 else {
                     inicializador = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, origemParaAtribuicao, new construtos_1.Literal(this.hashArquivo, identificador.linha, i, 'número'), new lexador_1.Simbolo(pitugues_2.default.COLCHETE_DIREITO, ']', null, identificador.linha, -1));
                 }
+                cursorDesempacotamento++;
             }
             else {
                 inicializador = inicializadores[cursorValores];
@@ -6924,7 +6947,7 @@ class AvaliadorSintaticoPitugues {
                 expressao = await this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO)) {
-                const nome = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+                const nome = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado nome do método ou propriedade após o '.'");
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
             else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_ESQUERDO)) {
@@ -24125,8 +24148,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         });
     }
     async logicaComumExecucaoEnquanto(enquanto, acumularRetornos) {
-        let retornoExecucao = undefined;
         const retornos = [];
+        let retornoExecucao = undefined;
+        let iteracoes = 0;
         while ((acumularRetornos ||
             !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
             this.eVerdadeiro(await this.avaliar(enquanto.condicao))) {
@@ -24134,6 +24158,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 if (this.funcaoVerificarIteracao) {
                     await this.funcaoVerificarIteracao();
                 }
+                await this.cederControle(++iteracoes);
                 retornoExecucao = await this.executar(enquanto.corpo);
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
                     if (acumularRetornos) {
@@ -24172,13 +24197,15 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         return this.logicaComumExecucaoEnquanto(declaracao, false);
     }
     async logicaComumExecucaoFazer(fazer, acumularRetornos) {
-        let retornoExecucao = undefined;
         const retornos = [];
+        let retornoExecucao = undefined;
+        let iteracoes = 0;
         do {
             try {
                 if (this.funcaoVerificarIteracao) {
                     await this.funcaoVerificarIteracao();
                 }
+                await this.cederControle(++iteracoes);
                 retornoExecucao = await this.executar(fazer.caminhoFazer);
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
                     if (acumularRetornos) {
@@ -24224,8 +24251,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (declaracaoInicializador !== null && declaracaoInicializador !== undefined) {
             await this.avaliar(declaracaoInicializador);
         }
-        let retornoExecucao = undefined;
         const retornos = [];
+        let retornoExecucao = undefined;
+        let iteracoes = 0;
         while (acumularRetornos ||
             !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) {
             if (para.condicao !== null && !this.eVerdadeiro(await this.avaliar(para.condicao))) {
@@ -24234,6 +24262,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             if (this.funcaoVerificarIteracao) {
                 await this.funcaoVerificarIteracao();
             }
+            await this.cederControle(++iteracoes);
             retornoExecucao = await this.executar(para.corpo);
             if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
                 if (acumularRetornos) {
@@ -24265,6 +24294,24 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarDeclaracaoPara(declaracao) {
         return this.logicaComumExecucaoPara(declaracao, false);
     }
+    /**
+    * Define a variável de iteração de um laço 'para cada' (ou compreensão de lista) SEM coerção de tipo. A iteração sempre preserva o valor original do elemento, independentemente do tipo inferido para a variável.
+    */
+    definirVariavelIteracao(variavelIteracao, valorElemento) {
+        if (variavelIteracao instanceof construtos_1.Variavel) {
+            this.pilhaEscoposExecucao.definirVariavel(variavelIteracao.simbolo.lexema, valorElemento, 'qualquer');
+        }
+        else if (variavelIteracao instanceof construtos_1.Dupla) {
+            const nomePrimeiro = variavelIteracao.primeiro?.valor?.toString?.() ?? variavelIteracao.primeiro?.lexema;
+            const nomeSegundo = variavelIteracao.segundo?.valor?.toString?.() ?? variavelIteracao.segundo?.lexema;
+            if (nomePrimeiro) {
+                this.pilhaEscoposExecucao.definirVariavel(nomePrimeiro, valorElemento.primeiro?.valor ?? valorElemento.primeiro, 'qualquer');
+            }
+            if (nomeSegundo) {
+                this.pilhaEscoposExecucao.definirVariavel(nomeSegundo, valorElemento.segundo?.valor ?? valorElemento.segundo, 'qualquer');
+            }
+        }
+    }
     async logicaComumExecucaoParaCada(paraCada, acumularRetornos) {
         let retornoExecucao = undefined;
         // Posição atual precisa ser reiniciada, pois pode estar dentro de outro
@@ -24285,6 +24332,7 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             return Promise.reject("Variável ou literal provida em instrução 'para cada' não é um vetor.");
         }
         const retornos = [];
+        let iteracoes = 0;
         while ((acumularRetornos ||
             !(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra)) &&
             paraCada.posicaoAtual < valorVetorOuDicionarioResolvido.length) {
@@ -24292,23 +24340,8 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
                 if (this.funcaoVerificarIteracao) {
                     await this.funcaoVerificarIteracao();
                 }
-                if (paraCada.variavelIteracao instanceof construtos_1.Variavel) {
-                    this.pilhaEscoposExecucao.definirVariavel(paraCada.variavelIteracao.simbolo.lexema, valorVetorOuDicionarioResolvido[paraCada.posicaoAtual]);
-                }
-                if (paraCada.variavelIteracao instanceof construtos_1.Dupla) {
-                    const valorComoDupla = valorVetorOuDicionarioResolvido[paraCada.posicaoAtual];
-                    const nomesVariaveis = await Promise.all([
-                        this.avaliar(paraCada.variavelIteracao.primeiro),
-                        this.avaliar(paraCada.variavelIteracao.segundo),
-                    ]);
-                    const valoresDupla = await Promise.all([
-                        this.avaliar(valorComoDupla.primeiro),
-                        this.avaliar(valorComoDupla.segundo),
-                    ]);
-                    // nomesVariaveis são strings (nomes das variáveis)
-                    this.pilhaEscoposExecucao.definirVariavel(String(nomesVariaveis[0]), valoresDupla[0]);
-                    this.pilhaEscoposExecucao.definirVariavel(String(nomesVariaveis[1]), valoresDupla[1]);
-                }
+                await this.cederControle(++iteracoes);
+                this.definirVariavelIteracao(paraCada.variavelIteracao, valorVetorOuDicionarioResolvido[paraCada.posicaoAtual]);
                 retornoExecucao = await this.executar(paraCada.corpo);
                 if (retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.SustarQuebra) {
                     if (acumularRetornos) {