@designliquido/delegua 0.64.0 → 0.65.0

package/umd/delegua.js

@@ -3445,71 +3445,131 @@ 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() {
         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 se o * veio 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 se o * veio como parte do 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.');
         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.');
+        const qtdIdentificadores = identificadores.length;
+        const qtdValores = inicializadores.length;
+        if (indexResto > -1) {
+            // Com resto: precisa de valores suficientes para cobrir as variáveis obrigatórias.
+            if (qtdValores < qtdIdentificadores - 1) {
+                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 {
+            // Sem resto: a quantidade deve ser exata.
+            if (qtdIdentificadores !== qtdValores) {
+                throw this.erro(this.simboloAnterior(), 'Quantidade de inicializadores à esquerda do igual é diferente da quantidade de identificadores à direita.');
+            }
+        }
+        const retorno = [];
+        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) {
+                // Caso Resto (*): absorve N valores em um Vetor e força tipagem de array.
+                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 {
+                // Caso comum: consome 1 valor
+                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 +4406,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) {