@designliquido/delegua 0.64.1 → 0.66.0

package/umd/delegua.js

@@ -3445,71 +3445,173 @@ class AvaliadorSintaticoPitugues {
     }
     temPadraoMultiplaAtribuicao() {
         // Verifica padrão: IDENTIFICADOR, VIRGULA, IDENTIFICADOR, ..., IGUAL
+        // Também aceita * antes de identificador
         let pos = this.atual;
-        let contadorIdentificadores = 0;
+        let identificadores = 0;
         while (pos < this.simbolos.length) {
-            if (this.simbolos[pos].tipo === pitugues_2.default.IDENTIFICADOR) {
-                contadorIdentificadores++;
+            // Consome opcionalmente o operador de resto (*)
+            if (this.simbolos[pos].tipo === pitugues_2.default.MULTIPLICACAO) {
                 pos++;
-                if (pos >= this.simbolos.length)
-                    return false;
-                // Se encontrou =, verifica se tinha mais de 1 identificador
-                if (this.simbolos[pos].tipo === pitugues_2.default.IGUAL) {
-                    return contadorIdentificadores > 1;
-                }
-                // Se não é vírgula, não é padrão múltiplo
-                if (this.simbolos[pos].tipo !== pitugues_2.default.VIRGULA) {
-                    return false;
-                }
+            }
+            // Verifica se há um identificador obrigatório
+            if (pos >= this.simbolos.length || this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR) {
+                return false;
+            }
+            pos++;
+            identificadores++;
+            // Verifica o próximo símbolo (deve ser ',' ou '=')
+            if (pos >= this.simbolos.length)
+                return false;
+            const proximoTipo = this.simbolos[pos].tipo;
+            if (proximoTipo === pitugues_2.default.IGUAL) {
+                return identificadores >= 2;
+            }
+            if (proximoTipo === pitugues_2.default.VIRGULA) {
                 pos++;
                 continue;
             }
-            break;
+            // Se chegou aqui, não é vírgula nem igual, então o padrão quebrou
+            return false;
         }
         return false;
     }
     temPadraoVarComoPalavraChave() {
         // Verifica padrão: var identificador = ...
-        var _a;
-        if (this.simbolos[this.atual].lexema !== 'var') {
+        if (this.simbolos[this.atual].lexema !== "var") {
             return false;
         }
-        // Exemplos permitidos: var = 10 | var, a = 10, 20
-        if (((_a = this.simbolos[this.atual + 1]) === null || _a === void 0 ? void 0 : _a.tipo) !== pitugues_2.default.IDENTIFICADOR) {
+        const proximo = this.simbolos[this.atual + 1];
+        if (!proximo)
+            return false;
+        if (proximo.tipo === pitugues_2.default.MULTIPLICACAO) {
             return false;
         }
+        // Busca pelo sinal de igualdade, permitido apenas IDENTIFICADORES e VÍRGULAS no caminho
         let pos = this.atual + 1;
         while (pos < this.simbolos.length) {
-            if (this.simbolos[pos].tipo === pitugues_2.default.IGUAL) {
-                return true; // Encontrou padrão var identificador = ...
-            }
-            // Se encontrou algo que não seja IDENTIFICADOR ou VIRGULA, não é o padrão
-            if (this.simbolos[pos].tipo !== pitugues_2.default.IDENTIFICADOR &&
-                this.simbolos[pos].tipo !== pitugues_2.default.VIRGULA) {
+            const tipo = this.simbolos[pos].tipo;
+            // Encontrou padrão var a, b = ...
+            if (tipo === pitugues_2.default.IGUAL)
+                return true;
+            // Encontrou algo como 'var a + b'
+            if (tipo !== pitugues_2.default.IDENTIFICADOR && tipo !== pitugues_2.default.VIRGULA)
                 return false;
-            }
             pos++;
         }
         return false;
     }
-    declaracaoDeVariaveis() {
+    consumirIdentificadores() {
         const identificadores = [];
-        let retorno = [];
-        let tipo = 'qualquer';
+        let indexResto = -1;
         do {
-            identificadores.push(this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome de variável.'));
+            let ehRestoAtual = false;
+            // Verifica * como token separado
+            if (this.verificarTipoSimboloAtual(pitugues_2.default.MULTIPLICACAO)) {
+                this.consumir(pitugues_2.default.MULTIPLICACAO, '');
+                ehRestoAtual = true;
+            }
+            const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, ehRestoAtual ? 'Esperado nome de variável após operador *.' : 'Esperado nome de variável.');
+            // Verifica * no nome da variável
+            if (identificador.lexema.startsWith('*')) {
+                ehRestoAtual = true;
+                identificador.lexema = identificador.lexema.slice(1);
+            }
+            if (ehRestoAtual) {
+                if (indexResto > -1) {
+                    throw this.erro(this.simboloAtual(), 'Sintaxe inválida: apenas um operador de resto é permitido.');
+                }
+                indexResto = identificadores.length;
+            }
+            identificadores.push(identificador);
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
-        this.consumir(pitugues_2.default.IGUAL, 'Esperado o símbolo igual(=) após identificador.');
+        return { simbolos: identificadores, indexResto };
+    }
+    consumirInicializadores() {
         const inicializadores = [];
         do {
+            if (this.estaNoFinal()) {
+                throw this.erro(this.simboloAtual(), 'Esperado inicializador após vírgula.');
+            }
             inicializadores.push(this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
-        if (identificadores.length !== inicializadores.length) {
-            throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
+        return inicializadores;
+    }
+    construirValidacaoDesempacotamento(identificador, origem, qtdEsperada) {
+        const linha = identificador.linha;
+        const chamadaTamanho = new construtos_1.Chamada(this.hashArquivo, new construtos_1.Variavel(this.hashArquivo, new lexador_1.Simbolo(pitugues_2.default.IDENTIFICADOR, "tamanho", null, linha, -1)), [origem]);
+        const condicaoErro = new construtos_1.Binario(this.hashArquivo, chamadaTamanho, new lexador_1.Simbolo(pitugues_2.default.DIFERENTE, "!=", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, qtdEsperada, 'número'));
+        const mensagem = `Erro de execução: Você tentou desempacotar em ${qtdEsperada} variáveis, mas o vetor possui tamanho diferente.`;
+        const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, "falhar", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
+        return new declaracoes_1.Se(condicaoErro, new declaracoes_1.Bloco(this.hashArquivo, linha, [falha]), [], null);
+    }
+    declaracaoDeVariaveis() {
+        const { simbolos: identificadores, indexResto } = this.consumirIdentificadores();
+        this.consumir(pitugues_2.default.IGUAL, 'Esperado o símbolo igual(=) após identificador.');
+        const inicializadores = this.consumirInicializadores();
+        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.');
+                }
+            }
         }
-        for (let [indice, identificador] of identificadores.entries()) {
-            const inicializador = inicializadores[indice];
-            tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializadores[indice], tipo);
+        else {
+            if (!ehDesempacotamento && qtdIdentificadores !== qtdValores) {
+                throw this.erro(this.simboloAnterior(), 'Quantidade de inicializadores à esquerda do igual é diferente da quantidade de identificadores à direita.');
+            }
+            if (ehDesempacotamento && inicializadores[0] instanceof construtos_1.Vetor) {
+                const vetor = inicializadores[0];
+                if (vetor.tamanho !== qtdIdentificadores) {
+                    throw this.erro(this.simboloAnterior(), `O vetor possui ${vetor.tamanho} elementos, mas você tentou desempacotar em ${qtdIdentificadores} variáveis.`);
+                }
+            }
+        }
+        const retorno = [];
+        let origemParaAtribuicao = inicializadores[0];
+        // Injeção de Código (Runtime Check)
+        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 identificador = identificadores[i];
+            let inicializador;
+            let tipo = "qualquer";
+            if (i === indexResto) {
+                const valoresResto = inicializadores.slice(cursorValores, cursorValores + qtdParaResto);
+                let tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(valoresResto);
+                if (!tipoInferido.endsWith('[]'))
+                    tipoInferido = `${tipoInferido}[]`;
+                inicializador = new construtos_1.Vetor(identificador.hashArquivo, identificador.linha, valoresResto, valoresResto.length, tipoInferido);
+                tipo = tipoInferido;
+                cursorValores += qtdParaResto;
+            }
+            else if (ehDesempacotamento) {
+                if (inicializadores[0] instanceof construtos_1.Vetor) {
+                    inicializador = inicializadores[0].valores[i];
+                }
+                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));
+                }
+            }
+            else {
+                inicializador = inicializadores[cursorValores];
+                cursorValores++;
+                tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipo);
+            }
             this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
             retorno.push(new declaracoes_1.Var(identificador, inicializador, tipo));
         }
@@ -4346,23 +4448,26 @@ class AvaliadorSintaticoPitugues {
         }
     }
     resolverDeclaracao() {
-        var _a;
-        // Detecção de declaração implícita
-        if (this.simbolos[this.atual].tipo === pitugues_2.default.IDENTIFICADOR) {
-            // Detecta e bloqueia "var x = 10"
-            if (this.temPadraoVarComoPalavraChave()) {
-                throw this.erro(this.simbolos[this.atual], 'Palavra "var" não pode ser usada como palavra-chave para declaração. Use declarações implícitas: "x = 10" em vez de "var x = 10".');
-            }
-            // Verifica se é múltipla atribuição (a, b, c = 1, 2, 3)
-            if (this.temPadraoMultiplaAtribuicao()) {
+        // Detecção de declaração implícita ou múltipla atribuição (pode começar com * ou identificador)
+        const simboloAtual = this.simbolos[this.atual];
+        // Bloqueio explícito do uso de "var"
+        if (this.temPadraoVarComoPalavraChave()) {
+            throw this.erro(simboloAtual, 'Palavra "var" não pode ser usada como palavra-chave para declaração. Use declarações implícitas: "x = 10" em vez de "var x = 10".');
+        }
+        // Se caso começar com o operador resto (*), ex: *a, b = ...
+        if (simboloAtual.tipo === pitugues_2.default.MULTIPLICACAO) {
+            return this.declaracaoDeVariaveis();
+        }
+        // Se caso começar com um identificador
+        if (simboloAtual.tipo === pitugues_2.default.IDENTIFICADOR) {
+            if (simboloAtual.lexema.startsWith('*'))
                 return this.declaracaoDeVariaveis();
-            }
-            // Verifica se é atribuição simples (a = 1)
-            if (((_a = this.simbolos[this.atual + 1]) === null || _a === void 0 ? void 0 : _a.tipo) === pitugues_2.default.IGUAL) {
-                const nomeVariavel = this.simbolos[this.atual].lexema;
-                if (!this.variavelJaDeclarada(nomeVariavel)) {
+            if (this.temPadraoMultiplaAtribuicao())
+                return this.declaracaoDeVariaveis();
+            const proximoSimbolo = this.simbolos[this.atual + 1];
+            if (proximoSimbolo && proximoSimbolo.tipo === pitugues_2.default.IGUAL) {
+                if (!this.variavelJaDeclarada(simboloAtual.lexema))
                     return this.declaracaoImplicita();
-                }
             }
         }
         switch (this.simbolos[this.atual].tipo) {
@@ -13430,6 +13535,8 @@ class InterpretadorBase {
                 return (objetoAcessado as AcessoMetodoOuPropriedade).simbolo.lexema;
             case AcessoIndiceVariavel:
                 return this.resolverNomeObjectoAcessado((objetoAcessado as AcessoIndiceVariavel).entidadeChamada); */
+            case construtos_1.Chamada:
+                return this.resolverNomeObjectoAcessado(objetoAcessado.entidadeChamada);
             case construtos_1.Constante:
                 return objetoAcessado.simbolo.lexema;
             case construtos_1.AcessoMetodoOuPropriedade: