@designliquido/delegua 1.23.2 → 1.23.4

package/umd/delegua.js

@@ -712,9 +712,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     async visitarExpressaoDeChamada(expressao) {
         for (const argumento of expressao.argumentos) {
-            if (argumento instanceof construtos_1.Variavel) {
-                this.gerenciadorEscopos.marcarComoUsada(argumento.simbolo.lexema);
-            }
+            this.marcarVariaveisUsadasEmExpressao(argumento);
         }
         switch (expressao.entidadeChamada.constructor) {
             case construtos_1.AcessoMetodo:
@@ -2408,6 +2406,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.
@@ -2753,7 +2773,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 this.avancarEDevolverAnterior();
                 valores = [];
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
-                    return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), [], 'qualquer[]');
+                    return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 'qualquer[]');
                 }
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                     return this.construtoTupla();
@@ -2788,21 +2808,34 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const valoresSemComentarios = valores.filter((v) => v.constructor !== construtos_1.ComentarioComoConstruto);
                 let elementoSeparador = false; // O primeiro elemento não pode ser separador.
                 for (const elemento of valoresSemComentarios) {
+                    const simboloErro = elemento.simbolo || simboloAtual;
                     if (elementoSeparador) {
                         if (elemento.constructor !== construtos_1.Separador) {
-                            throw this.erro(elemento.simbolo, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                            throw this.erro(simboloErro, 'Os itens dos vetores devem ser separados através de uma vírgula.');
                         }
                         elementoSeparador = false;
                     }
                     else {
                         if (elemento.constructor === construtos_1.Separador) {
-                            throw this.erro(elemento.simbolo, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                            throw this.erro(simboloErro, 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
                         }
                         elementoSeparador = true;
                     }
                 }
                 const valoresSemSeparadores = valoresSemComentarios.filter((v) => v.constructor !== construtos_1.Separador);
-                const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresSemSeparadores);
+                let tipoVetor;
+                if (valoresSemSeparadores.length === 0) {
+                    tipoVetor = 'qualquer[]';
+                }
+                else {
+                    const primeiroElemento = valoresSemSeparadores[0];
+                    if (primeiroElemento instanceof construtos_1.Vetor) {
+                        tipoVetor = primeiroElemento.tipo + '[]';
+                    }
+                    else {
+                        tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresSemSeparadores);
+                    }
+                }
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores, tipoVetor);
             case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
@@ -4017,24 +4050,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.
@@ -4234,17 +4252,28 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         switch (inicializador.constructor) {
             case construtos_1.AcessoIndiceVariavel:
-                const entidadeChamadaAcessoIndiceVariavel = inicializador
-                    .entidadeChamada;
-                // Este condicional ocorre com chamadas aninhadas. Por exemplo, `vetor[1][2]`.
-                if (entidadeChamadaAcessoIndiceVariavel.constructor === construtos_1.AcessoIndiceVariavel) {
-                    return this.logicaComumInferenciaTiposVariaveisEConstantes(entidadeChamadaAcessoIndiceVariavel, tipo);
-                }
-                const tipoEntidadeChamadaAcessoIndiceVariavel = entidadeChamadaAcessoIndiceVariavel.tipo;
-                if (tipoEntidadeChamadaAcessoIndiceVariavel.endsWith('[]')) {
-                    return tipoEntidadeChamadaAcessoIndiceVariavel.slice(0, -2);
+                const acessoAtual = inicializador;
+                let entidade = acessoAtual.entidadeChamada;
+                let numeroIndices = 1;
+                // Percorre a cadeia de acessos aninhados para contar quantos índices existem
+                // Cada índice consome um nível de vetor, então removemos um '[]' por acesso.
+                while (entidade.constructor === construtos_1.AcessoIndiceVariavel) {
+                    numeroIndices++;
+                    entidade = entidade
+                        .entidadeChamada;
+                }
+                const tipoBase = entidade.tipo;
+                if (tipoBase.endsWith('[]')) {
+                    let tipoResultante = tipoBase;
+                    for (let i = 0; i < numeroIndices; i++) {
+                        if (tipoResultante.endsWith('[]')) {
+                            tipoResultante = tipoResultante.slice(0, -2);
+                        }
+                        else
+                            break;
+                    }
+                    return tipoResultante;
                 }
-                // Normalmente, `entidadeChamadaAcessoIndiceVariavel.tipo` aqui será 'vetor'.
                 return 'qualquer';
             case construtos_1.Chamada:
                 const entidadeChamadaChamada = inicializador.entidadeChamada;
@@ -4326,51 +4355,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 = [];
@@ -6368,19 +6392,31 @@ 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
-                    .entidadeChamada;
-                // Este condicional ocorre com chamadas aninhadas. Por exemplo, `vetor[1][2]`.
-                if (entidadeChamadaAcessoIndiceVariavel.constructor === construtos_1.AcessoIndiceVariavel) {
-                    return this.logicaComumInferenciaTiposVariaveisEConstantes(entidadeChamadaAcessoIndiceVariavel, tipoPrevio);
-                }
-                if (entidadeChamadaAcessoIndiceVariavel.tipo.endsWith('[]')) {
-                    return entidadeChamadaAcessoIndiceVariavel.tipo.slice(0, -2);
+                const acessoAtual = inicializador;
+                let entidade = acessoAtual.entidadeChamada;
+                let numeroIndices = 1;
+                // Percorre acessos aninhados como `vetor[1][2]` contando quantos índices foram aplicados.
+                // Cada índice consome um nível de vetor, então removemos um '[]' por acesso.
+                while (entidade.constructor === construtos_1.AcessoIndiceVariavel) {
+                    numeroIndices++;
+                    entidade = entidade
+                        .entidadeChamada;
+                }
+                const tipoBase = entidade.tipo;
+                if (tipoBase.endsWith('[]')) {
+                    let tipoResultante = tipoBase;
+                    for (let i = 0; i < numeroIndices; i++) {
+                        if (tipoResultante.endsWith('[]')) {
+                            tipoResultante = tipoResultante.slice(0, -2);
+                        }
+                        else
+                            break;
+                    }
+                    return tipoResultante;
                 }
                 // Normalmente, `entidadeChamadaAcessoIndiceVariavel.tipo` aqui será 'vetor'.
                 return 'qualquer';
@@ -6403,7 +6439,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:
@@ -6583,15 +6628,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.');
             }
@@ -6604,41 +6647,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];
@@ -6788,6 +6842,9 @@ class AvaliadorSintaticoPitugues {
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 'qualquer[]');
                 }
+                if (this.verificarTipoSimboloAtual(pitugues_2.default.VIRGULA)) {
+                    throw this.erro(this.simboloAtual(), 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                }
                 // Ao resolver a expressão aqui, identificadores dentro da expressão de compreensão
                 // de lista serão tratados como 'qualquer', para evitar erros de tipo.
                 this.intuirTipoQualquerParaIdentificadores = true;
@@ -6798,13 +6855,35 @@ class AvaliadorSintaticoPitugues {
                 }
                 // Aqui já sabemos que não é uma compreensão de lista.
                 const valoresVetor = [retornoExpressaoOuPrimeiroValor];
+                this.ignorarComentarios();
                 while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
-                    this.consumir(pitugues_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
-                    this.ignorarComentarios();
-                    valoresVetor.push(await this.atribuir());
-                    this.ignorarComentarios();
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA)) {
+                        this.ignorarComentarios();
+                        if (this.verificarTipoSimboloAtual(pitugues_2.default.VIRGULA)) {
+                            throw this.erro(this.simboloAtual(), 'Não podem haver duas vírgulas seguidas em uma definição de vetor, ou definição de vetor começando em vírgula.');
+                        }
+                    }
+                    else {
+                        throw this.erro(this.simboloAtual() || simboloAtual, 'Os itens dos vetores devem ser separados através de uma vírgula.');
+                    }
+                    if (!this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO)) {
+                        valoresVetor.push(await this.atribuir());
+                        this.ignorarComentarios();
+                    }
+                }
+                let tipoVetor;
+                if (valoresVetor.length === 0) {
+                    tipoVetor = 'qualquer[]';
+                }
+                else {
+                    const primeiroElemento = valoresVetor[0];
+                    if (primeiroElemento instanceof construtos_1.Vetor) {
+                        tipoVetor = primeiroElemento.tipo + '[]';
+                    }
+                    else {
+                        tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresVetor);
+                    }
                 }
-                const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valoresVetor);
                 return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, valoresVetor, tipoVetor);
             case pitugues_2.default.COMENTARIO:
                 const simboloComentario = this.avancarEDevolverAnterior();
@@ -7761,10 +7840,10 @@ class AvaliadorSintaticoPitugues {
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         return definicaoClasse;
     }
-    declaracaoFalhar() {
+    async declaracaoFalhar() {
         const simboloFalha = this.simbolos[this.atual - 1];
-        const textoFalha = this.consumir(pitugues_2.default.TEXTO, 'Esperado texto para explicar falha.');
-        return new declaracoes_1.Falhar(simboloFalha, textoFalha.literal);
+        const explicacao = await this.atribuir();
+        return new declaracoes_1.Falhar(simboloFalha, explicacao);
     }
     /**
      * Verifica se há pontos e vírgula no final de sentenças.
@@ -7874,7 +7953,7 @@ class AvaliadorSintaticoPitugues {
                 return this.declaracaoEscreva(simboloEscrevaOuImprima);
             case pitugues_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoFalhar();
+                return await this.declaracaoFalhar();
             case pitugues_2.default.FAZER:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFazer();
@@ -14322,8 +14401,12 @@ exports.Atribuir = Atribuir;
 
 },{"./variavel":95}],50:[function(require,module,exports){
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Binario = void 0;
+const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 /**
  * Binário é uma estrutura com um operador e dois operandos: esquerda e direita.
  * Implementa as seguintes operações para Delégua e todos os dialetos:
@@ -14361,6 +14444,17 @@ class Binario {
      * @returns O tipo deduzido.
      */
     deduzirTipo() {
+        if ([
+            delegua_1.default.MAIOR,
+            delegua_1.default.MAIOR_IGUAL,
+            delegua_1.default.MENOR,
+            delegua_1.default.MENOR_IGUAL,
+            delegua_1.default.IGUAL,
+            delegua_1.default.IGUAL_IGUAL,
+            delegua_1.default.DIFERENTE,
+        ].includes(this.operador.tipo)) {
+            return 'lógico';
+        }
         if (['logico', 'lógico'].includes(this.esquerda.tipo) ||
             ['logico', 'lógico'].includes(this.direita.tipo)) {
             return 'lógico';
@@ -14392,7 +14486,7 @@ class Binario {
 }
 exports.Binario = Binario;
 
-},{}],51:[function(require,module,exports){
+},{"../tipos-de-simbolos/delegua":253}],51:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Bote = void 0;
@@ -20490,7 +20584,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         }
         return argumentosResolvidos;
     }
-    resolverAmbiente(argumentos) {
+    async resolverAmbiente(visitante, argumentos) {
         const ambiente = new espaco_memoria_1.EspacoMemoria();
         const parametros = this.declaracao.parametros || [];
         for (let i = 0; i < parametros.length; i++) {
@@ -20506,15 +20600,28 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
                 };
             }
             else {
-                let argumento = argumentos[i];
-                if (argumento.valor === null) {
-                    argumentos[i].valor = parametro.valorPadrao ? parametro.valorPadrao : null;
+                let valorFinal;
+                const argumento = argumentos[i];
+                const valorExtraido = (argumento && argumento.hasOwnProperty('valor'))
+                    ? argumento.valor
+                    : argumento;
+                if (i < argumentos.length &&
+                    valorExtraido !== undefined &&
+                    valorExtraido !== null) {
+                    valorFinal = valorExtraido;
+                }
+                else if (parametro.valorPadrao) {
+                    valorFinal = await visitante.avaliar(parametro.valorPadrao);
                 }
-                ambiente.valores[nome] =
-                    argumento && argumento.hasOwnProperty('valor') ? argumento.valor : argumento;
+                else {
+                    valorFinal = null;
+                }
+                ambiente.valores[nome] = valorFinal;
                 // Se o argumento é `DeleguaFuncao`, para habilitar o recurso de _currying_,
                 // copiamos seu valor para o escopo atual. Nem sempre podemos contar com a tipagem explícita aqui.
-                if (argumento.valor && ['funcao', 'função'].includes(argumento.valor.tipo)) {
+                if (valorFinal &&
+                    typeof valorFinal === 'object' &&
+                    ['funcao', 'função'].includes(valorFinal.tipo)) {
                     parametro.referencia = true;
                 }
             }
@@ -20522,7 +20629,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         return ambiente;
     }
     async chamar(visitante, argumentos) {
-        const ambiente = this.resolverAmbiente(argumentos);
+        const ambiente = await this.resolverAmbiente(visitante, argumentos);
         if (this.instancia !== undefined) {
             ambiente.valores['isto'] = {
                 valor: this.instancia,
@@ -21905,7 +22012,28 @@ class InterpretadorBase {
         throw new Error('Método não implementado.');
     }
     async visitarExpressaoFalhar(expressao) {
-        const textoFalha = expressao.explicacao.valor ?? (await this.avaliar(expressao.explicacao)).valor;
+        let valorAvaliado = expressao.explicacao;
+        // Se for um construto (ex.: Variavel), avalia para obter seu valor real
+        if (expressao.explicacao &&
+            typeof expressao.explicacao.aceitar === 'function') {
+            valorAvaliado = await this.avaliar(expressao.explicacao);
+        }
+        let textoFalha;
+        if (valorAvaliado === null || valorAvaliado === undefined) {
+            textoFalha = 'nulo';
+        }
+        else if (typeof valorAvaliado === 'string') {
+            textoFalha = valorAvaliado;
+        }
+        else if (typeof valorAvaliado === 'object' &&
+            'valor' in valorAvaliado) {
+            // Objetos tipados como { valor: 'mensagem', tipo: 'texto' }
+            textoFalha = String(valorAvaliado.valor);
+        }
+        else {
+            // Caso incomum: usa a representação textual padrão
+            textoFalha = this.paraTexto(valorAvaliado);
+        }
         throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, textoFalha, expressao.linha);
     }
     async visitarExpressaoFimPara(_) {
@@ -22910,36 +23038,47 @@ class InterpretadorBase {
         } while (!(retornoExecucao && retornoExecucao.valorRetornado instanceof quebras_1.Quebra) &&
             this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
     }
+    /**
+     * Unifica a execução do bloco 'pegue', tratando tanto o caso de
+     * declarações simples quanto o caso de função com parâmetro de erro.
+     */
+    async executarBlocoPegue(pegue, erro) {
+        if (Array.isArray(pegue)) {
+            return await this.executarBloco(pegue);
+        }
+        // Caso seja FuncaoConstruto (pegue com parâmetro de erro)
+        const literalErro = new construtos_1.Literal(pegue.hashArquivo, pegue.linha, erro.mensagem || erro.message || erro);
+        const chamadaPegue = new construtos_1.Chamada(pegue.hashArquivo, pegue, [literalErro]);
+        return await chamadaPegue.aceitar(this);
+    }
     /**
      * Interpretação de uma declaração `tente`.
      * @param declaracao O objeto da declaração.
      */
     async visitarDeclaracaoTente(declaracao) {
         let valorRetorno;
+        let sucessoNoTente = false;
         try {
             this.emDeclaracaoTente = true;
             try {
                 valorRetorno = await this.executarBloco(declaracao.caminhoTente);
+                sucessoNoTente = true;
             }
             catch (erro) {
                 if (declaracao.caminhoPegue !== null) {
-                    // `caminhoPegue` aqui pode ser um construto de função (se `pegue` tem parâmetros)
-                    // ou um vetor de `Declaracao` (`pegue` sem parâmetros).
-                    // As execuções, portanto, são diferentes.
-                    if (Array.isArray(declaracao.caminhoPegue)) {
-                        valorRetorno = await this.executarBloco(declaracao.caminhoPegue);
-                    }
-                    else {
-                        const literalErro = new construtos_1.Literal(declaracao.hashArquivo, Number(declaracao.linha), erro.mensagem);
-                        const chamadaPegue = new construtos_1.Chamada(declaracao.caminhoPegue.hashArquivo, declaracao.caminhoPegue, [literalErro]);
-                        valorRetorno = await chamadaPegue.aceitar(this);
-                    }
+                    valorRetorno = await this.executarBlocoPegue(declaracao.caminhoPegue, erro);
                 }
+                else
+                    throw erro;
+            }
+            if (sucessoNoTente && declaracao.caminhoSenao) {
+                valorRetorno = await this.executarBloco(declaracao.caminhoSenao);
             }
         }
         finally {
-            if (declaracao.caminhoFinalmente)
+            if (declaracao.caminhoFinalmente) {
                 valorRetorno = await this.executarBloco(declaracao.caminhoFinalmente);
+            }
             this.emDeclaracaoTente = false;
         }
         return valorRetorno;
@@ -23398,6 +23537,13 @@ class InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(variavelObjeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.simbolo.lexema].implementacao;
+                return new metodo_primitiva_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.simbolo.lexema, tipoObjeto);
+            }
+        }
         // Caso 3: Vetor simples do JavaScript.
         if (Array.isArray(objeto)) {
             if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
@@ -24665,6 +24811,23 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(objeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.nomeMetodo in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.nomeMetodo].implementacao;
+                return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.nomeMetodo, tipoObjeto);
+            }
+            else {
+                const funcaoExt = this.encontrarMetodoExtensao(['vetor', 'objeto'], expressao.nomeMetodo, this.hashArquivoDeclaracaoAtual);
+                if (funcaoExt)
+                    return funcaoExt.funcaoPorExtensao(objeto);
+                throw new excecoes_1.ErroEmTempoDeExecucao({
+                    hashArquivo: this.hashArquivoDeclaracaoAtual,
+                    linha: this.linhaDeclaracaoAtual,
+                    lexema: expressao.nomeMetodo
+                }, `Método de primitiva '${expressao.nomeMetodo}' não existe para o tipo ${tipoObjeto}.`, expressao.linha);
+            }
+        }
         // Como internamente um dicionário de Delégua é simplesmente um objeto de
         // JavaScript, as primitivas de dicionário, especificamente, são tratadas
         // mais acima.
@@ -24840,6 +25003,19 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         if (tipoObjeto === null || tipoObjeto === undefined) {
             tipoObjeto = (0, inferenciador_1.inferirTipoVariavel)(objeto);
         }
+        // Trata qualquer tipo terminado em '[]' como vetor
+        if (tipoObjeto && tipoObjeto.endsWith('[]')) {
+            if (expressao.simbolo.lexema in primitivas_vetor_1.default) {
+                const metodo = primitivas_vetor_1.default[expressao.simbolo.lexema].implementacao;
+                return new estruturas_1.MetodoPrimitiva(nomeObjeto, objeto, metodo, expressao.simbolo.lexema, tipoObjeto);
+            }
+            else {
+                const funcaoExt = this.encontrarMetodoExtensao(['vetor', 'objeto'], expressao.simbolo.lexema, this.hashArquivoDeclaracaoAtual);
+                if (funcaoExt)
+                    return funcaoExt.funcaoPorExtensao(objeto);
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simbolo, `Método de primitiva '${expressao.simbolo.lexema}' não existe para o tipo ${tipoObjeto}.`, expressao.linha);
+            }
+        }
         // Como internamente um dicionário de Delégua é simplesmente um objeto de
         // JavaScript, as primitivas de dicionário, especificamente, são tratadas
         // mais acima.