@designliquido/delegua 1.17.2 → 1.18.1

package/umd/delegua.js

@@ -1194,9 +1194,12 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 ];
                 // Classes/construtores geralmente começam com letra maiúscula
                 const pareceSerClasse = nomeFuncao[0] === nomeFuncao[0].toUpperCase();
+                if (pareceSerClasse) {
+                    this.gerenciadorEscopos.marcarComoUsada(nomeFuncao);
+                    break;
+                }
                 // Só verifica se a função existe se não for embutidas e não parecer ser classe
                 if (!funcoesEmbutidas.includes(nomeFuncao) &&
-                    !pareceSerClasse &&
                     !this.funcoes[nomeFuncao] &&
                     !this.gerenciadorEscopos.buscar(nomeFuncao)) {
                     this.erro(entidadeChamadaVariavel.simbolo, `Chamada da função '${nomeFuncao}' não existe.`);
@@ -1501,6 +1504,22 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         this.classesDeclaradas.add(declaracao.simbolo.lexema);
         this.classesRegistradas.set(declaracao.simbolo.lexema, declaracao);
+        // Marca tipos usados em anotações de propriedades e parâmetros de métodos como usados.
+        for (const propriedade of declaracao.propriedades) {
+            const tipoBase = propriedade.tipo?.replace('[]', '');
+            if (tipoBase)
+                this.gerenciadorEscopos.marcarComoUsada(tipoBase);
+        }
+        for (const metodo of declaracao.metodos) {
+            const tipoRetorno = metodo.funcao.tipo?.replace('[]', '');
+            if (tipoRetorno)
+                this.gerenciadorEscopos.marcarComoUsada(tipoRetorno);
+            for (const parametro of metodo.funcao.parametros) {
+                const tipoBase = parametro.tipoDado?.replace('[]', '');
+                if (tipoBase)
+                    this.gerenciadorEscopos.marcarComoUsada(tipoBase);
+            }
+        }
         // Visita corpos dos métodos com contexto de classe ativo.
         // Métodos abstratos implícitos e métodos de classes estrangeiras têm corpo vazio —
         // não há declarações para visitar.
@@ -1510,6 +1529,12 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             for (const metodo of declaracao.metodos) {
                 if (metodo.abstrato)
                     continue;
+                const tipoRetornoMetodo = metodo.funcao.tipo;
+                if (tipoRetornoMetodo &&
+                    !['vazio', 'qualquer'].includes(tipoRetornoMetodo) &&
+                    metodo.funcao.corpo.length === 0) {
+                    this.aviso(metodo.simbolo, `Método especifica tipo de retorno '${tipoRetornoMetodo}', mas não há qualquer retorno correspondente no corpo do método.`);
+                }
                 for (const stmt of metodo.funcao.corpo) {
                     await stmt.aceitar(this);
                 }
@@ -1526,10 +1551,16 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         let tipoRetornoFuncao = declaracao.funcao.tipo;
         if (tipoRetornoFuncao) {
+            this.gerenciadorEscopos.marcarComoUsada(tipoRetornoFuncao);
             if (!['vazio', 'qualquer'].includes(tipoRetornoFuncao)) {
-                const todosOsCaminhosRetornam = this.todosOsCaminhosRetornam(declaracao.funcao.corpo);
-                if (!todosOsCaminhosRetornam) {
-                    this.erro(declaracao.simbolo, `Função '${declaracao.simbolo.lexema}' deve retornar '${tipoRetornoFuncao}' em todos os caminhos de execução.`);
+                if (declaracao.funcao.corpo.length === 0) {
+                    this.aviso(declaracao.simbolo, `Método especifica tipo de retorno '${tipoRetornoFuncao}', mas não há qualquer retorno correspondente no corpo do método.`);
+                }
+                else {
+                    const todosOsCaminhosRetornam = this.todosOsCaminhosRetornam(declaracao.funcao.corpo);
+                    if (!todosOsCaminhosRetornam) {
+                        this.erro(declaracao.simbolo, `Função '${declaracao.simbolo.lexema}' deve retornar '${tipoRetornoFuncao}' em todos os caminhos de execução.`);
+                    }
                 }
             }
             let retornos = [];
@@ -2079,6 +2110,7 @@ const informacao_elemento_sintatico_1 = require("../informacao-elemento-sintatic
 const comum_1 = require("./comum");
 const montao_tipos_1 = require("./montao-tipos");
 const elemento_montao_tipos_1 = require("./elemento-montao-tipos");
+const simbolo_1 = require("../lexador/simbolo");
 const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
 const delegua_2 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const primitivas_dicionario_1 = __importDefault(require("../bibliotecas/primitivas-dicionario"));
@@ -2136,7 +2168,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     verificarDefinicaoTipoAtual() {
         const tipos = [...Object.values(delegua_1.default)];
         if (this.simbolos[this.atual].lexema in this.tiposDefinidosEmCodigo) {
-            return this.simbolos[this.atual].lexema;
+            const nomeBase = this.simbolos[this.atual].lexema;
+            if (this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_ESQUERDO)) {
+                this.avancarEDevolverAnterior(); // avança do tipo para '['
+                if (!this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_DIREITO)) {
+                    throw this.erro(this.simbolos[this.atual], `Esperado símbolo de fechamento do vetor: ']'. Atual: ${this.simbolos[this.atual].lexema}`);
+                }
+                this.avancarEDevolverAnterior(); // avança de '[' para ']'
+                return `${nomeBase}[]`;
+            }
+            return nomeBase;
         }
         if (this.simbolos[this.atual].lexema in this.interfacesDeclaradas) {
             return this.simbolos[this.atual].lexema;
@@ -2237,6 +2278,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.EXTENSAO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), 'extensao', 'texto');
+            case delegua_2.default.ASSERCAO:
+                this.avancarEDevolverAnterior();
+                return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), 'assercao', 'texto');
             default:
                 return undefined;
         }
@@ -3388,6 +3432,38 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const expressaoFalha = await this.expressao();
         return new declaracoes_1.Falhar(simboloFalha, expressaoFalha);
     }
+    async declaracaoAssercao() {
+        const simboloAssercao = this.simbolos[this.atual - 1];
+        let condicao;
+        let mensagemFalha;
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
+            condicao = await this.expressao();
+            if (this.verificarTipoSimboloAtual(delegua_2.default.VIRGULA)) {
+                this.avancarEDevolverAnterior();
+                mensagemFalha = await this.expressao();
+                if (this.verificarTipoSimboloAtual(delegua_2.default.VIRGULA)) {
+                    throw this.erro(this.simbolos[this.atual], "'asserção' aceita apenas condição obrigatória e mensagem opcional.");
+                }
+            }
+            else {
+                mensagemFalha = new construtos_1.Literal(simboloAssercao.hashArquivo, Number(simboloAssercao.linha), 'A asserção falhou.', 'texto', "'");
+            }
+            this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após argumentos de 'asserção'.");
+        }
+        else {
+            condicao = await this.expressao();
+            if (this.verificarTipoSimboloAtual(delegua_2.default.VIRGULA)) {
+                throw this.erro(this.simbolos[this.atual], "Mensagem em 'asserção' exige uso de parênteses.");
+            }
+            mensagemFalha = new construtos_1.Literal(simboloAssercao.hashArquivo, Number(simboloAssercao.linha), 'A asserção falhou.', 'texto', "'");
+        }
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+        const simboloNao = new simbolo_1.Simbolo(delegua_2.default.NEGACAO, 'nao', null, Number(simboloAssercao.linha), simboloAssercao.hashArquivo, simboloAssercao.colunaInicio, simboloAssercao.colunaFim);
+        const condicaoNegada = new construtos_1.Unario(simboloAssercao.hashArquivo, simboloNao, condicao, 'ANTES');
+        const declaracaoFalhar = new declaracoes_1.Falhar(simboloAssercao, mensagemFalha);
+        const blocoFalha = new declaracoes_1.Bloco(simboloAssercao.hashArquivo, Number(simboloAssercao.linha), [declaracaoFalhar]);
+        return new declaracoes_1.Se(condicaoNegada, blocoFalha);
+    }
     async logicaComumFazer() {
         const caminhoFazer = await this.declaracaoBloco();
         this.consumir(delegua_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
@@ -4661,14 +4737,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     /**
      * Usado quando há erros na avaliação sintática.
-     * Garante que o código não entre em _loop_ infinito.
+     * Garante que o avaliador sintático não entre em _loop_ infinito.
      * @returns Sempre retorna `void`.
      */
     sincronizar() {
         this.avancarEDevolverAnterior(); // avança além do token com erro
         while (!this.estaNoFinal()) {
             // Um ponto-e-vírgula já consumido indica fronteira limpa entre declarações.
-            if (this.simbolos[this.atual - 1].tipo === delegua_2.default.PONTO_E_VIRGULA)
+            if (this.simbolos[this.atual].tipo === delegua_2.default.PONTO_E_VIRGULA)
                 return;
             // Uma palavra-chave de início de declaração ou fecha-chave à frente:
             // retorna SEM consumir o token, para que o chamador o analise normalmente.
@@ -4700,6 +4776,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         switch (this.simbolos[this.atual].tipo) {
             case delegua_2.default.AJUDA:
                 return await this.declaracaoAjuda();
+            case delegua_2.default.ASSERCAO:
+                this.avancarEDevolverAnterior();
+                return await this.declaracaoAssercao();
             case delegua_2.default.CHAVE_ESQUERDA:
                 return await this.declaracaoBloco();
             case delegua_2.default.COMENTARIO:
@@ -4988,7 +5067,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":110,"../inferenciador":139,"../informacao-elemento-sintatico":140,"../tipos-de-dados/delegua":220,"../tipos-de-simbolos/delegua":225,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":418}],11:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":29,"../bibliotecas/primitivas-numero":30,"../bibliotecas/primitivas-texto":31,"../bibliotecas/primitivas-vetor":32,"../construtos":62,"../construtos/tuplas":80,"../declaracoes":110,"../inferenciador":139,"../informacao-elemento-sintatico":140,"../lexador/simbolo":218,"../tipos-de-dados/delegua":220,"../tipos-de-simbolos/delegua":225,"./avaliador-sintatico-base":9,"./comum":11,"./elemento-montao-tipos":19,"./erro-avaliador-sintatico":20,"./informacao-escopo":22,"./montao-tipos":25,"./pilha-escopos":26,"browser-process-hrtime":418}],11:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buscarRetornos = buscarRetornos;
@@ -5251,7 +5330,7 @@ class AvaliadorSintaticoEguaClassico {
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.NULO))
             return new construtos_1.Literal(this.hashArquivo, 0, null);
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.ISTO))
-            return new construtos_1.Isto(this.hashArquivo, Number(this.simboloAnterior()));
+            return new construtos_1.Isto(this.hashArquivo, Number(this.simboloAnterior().linha), this.simboloAnterior());
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.NUMERO, egua_classico_1.default.TEXTO)) {
             return new construtos_1.Literal(this.hashArquivo, 0, this.simboloAnterior().literal);
         }
@@ -18679,6 +18758,19 @@ function obterAjudaTemaClasse(chave) {
                 `\tvar s = "olá"\n` +
                 `\tescreva(s.gritarMaiusculas())  // OLÁ!!!\n\n` +
                 `Ver também: 'classe'.`);
+        case 'assercao':
+            return (`A instrução 'asserção' valida uma condição em tempo de execução.\n` +
+                `Se condição for falsa, execução falha com erro.\n\n` +
+                `Sintaxe:\n` +
+                `\tasserção condicao\n` +
+                `\tasserção(condicao)\n` +
+                `\tasserção(condicao, "mensagem de erro")\n\n` +
+                `Exemplo:\n` +
+                `\tvar idade = 20\n` +
+                `\tasserção idade >= 18\n` +
+                `\tasserção(idade >= 18, "idade precisa ser maior de idade")\n\n` +
+                `Internamente, primeira implementação usa fluxo equivalente a 'se' + 'falhar'.\n\n` +
+                `Ver também: 'falhar'.`);
         default:
             return `Desculpe, não há documentação disponível para o tópico '${chave}' no momento.`;
     }
@@ -28737,6 +28829,8 @@ const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
 exports.palavrasReservadasDelegua = {
     abstrata: delegua_1.default.ABSTRATO,
     abstrato: delegua_1.default.ABSTRATO,
+    assercao: delegua_1.default.ASSERCAO,
+    asserção: delegua_1.default.ASSERCAO,
     ajuda: delegua_1.default.AJUDA,
     cada: delegua_1.default.CADA,
     caso: delegua_1.default.CASO,
@@ -29058,6 +29152,7 @@ exports.default = {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
     ADICAO: 'ADICAO',
+    ASSERCAO: 'ASSERCAO',
     ABSTRATO: 'ABSTRATO',
     AJUDA: 'AJUDA',
     ARROBA: 'ARROBA',
@@ -43315,7 +43410,12 @@ ${labelFuncao}:
     }
     traduzirConstrutoLiteral(construto) {
         if (typeof construto.valor === 'string') {
-            return this.criaStringLiteral(construto);
+            return this.criarStringLiteral(construto);
+        }
+        if (typeof construto.valor === 'number' &&
+            Number.isFinite(construto.valor) &&
+            !Number.isInteger(construto.valor)) {
+            return this.criarLiteralPontoFlutuante(construto.valor);
         }
         return String(construto.valor);
     }
@@ -43447,7 +43547,10 @@ ${labelProximo}:`;
     traduzirDeclaracaoExpressao(declaracao) {
         if (declaracao.expressao &&
             this.dicionarioConstrutos[declaracao.expressao.constructor.name]) {
-            this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
+            const resultado = this.dicionarioConstrutos[declaracao.expressao.constructor.name](declaracao.expressao);
+            if (typeof resultado === 'string' && resultado && resultado !== 'a0') {
+                this.emitirCarga('a0', resultado);
+            }
         }
     }
     traduzirDeclaracaoFazer(declaracao) {
@@ -43661,19 +43764,24 @@ ${labelSenao}:`;
             }
         }
     }
-    criaStringLiteral(literal) {
+    criarStringLiteral(literal) {
         const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
         this.data += `    ${varLiteral}: .asciz "${literal.valor}"\n`;
         return varLiteral;
     }
-    criaTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
+    criarLiteralPontoFlutuante(valor) {
+        const varLiteral = `Delegua_${this.gerarDigitoAleatorio()}`;
+        this.data += `    ${varLiteral}: .double ${valor}\n`;
+        return varLiteral;
+    }
+    criarTamanhoNaMemoriaReferenteAVar(nomeStringLiteral) {
         return `tam_${nomeStringLiteral}`;
     }
     traduzirDeclaracaoEscreva(declaracaoEscreva) {
         let nomeStringLiteral = '';
         let tamanhoString = '';
         if (declaracaoEscreva.argumentos[0] instanceof construtos_1.Literal) {
-            nomeStringLiteral = this.criaStringLiteral(declaracaoEscreva.argumentos[0]);
+            nomeStringLiteral = this.criarStringLiteral(declaracaoEscreva.argumentos[0]);
             const stringValue = declaracaoEscreva.argumentos[0].valor;
             tamanhoString = String(stringValue.length);
         }
@@ -44495,7 +44603,7 @@ class TradutorAssemblyScript {
         this.dicionarioConstrutos = {
             AcessoIndiceVariavel: this.traduzirConstrutoAcessoIndiceVariavel.bind(this),
             AcessoMetodo: this.traduzirConstrutoAcessoMetodo.bind(this),
-            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodo.bind(this),
+            AcessoMetodoOuPropriedade: this.traduzirConstrutoAcessoMetodoOuPropriedade.bind(this),
             AcessoPropriedade: this.traduzirConstrutoAcessoPropriedade.bind(this),
             Agrupamento: this.traduzirConstrutoAgrupamento.bind(this),
             ArgumentoReferenciaFuncao: this.traduzirConstrutoArgumentoReferenciaFuncao.bind(this),
@@ -44698,7 +44806,7 @@ class TradutorAssemblyScript {
             case 'aleatorio':
                 return `Math.random()`;
             case 'aleatorioEntre':
-            case 'aleatorioente':
+            case 'aleatorioentre':
                 if (argumentos.length >= 2) {
                     return `(Math.random() * (${argumentos[1]} - ${argumentos[0]}) + ${argumentos[0]})`;
                 }
@@ -45596,11 +45704,20 @@ class TradutorAssemblyScript {
         return resultado;
     }
     traduzirConstrutoAcessoMetodo(acessoMetodo) {
+        const nomeMetodo = acessoMetodo.nomeMetodo;
         if (acessoMetodo.objeto instanceof construtos_1.Variavel) {
             let objetoVariavel = acessoMetodo.objeto;
-            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(acessoMetodo.simbolo.lexema)}`;
+            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(nomeMetodo)}`;
         }
-        return `this.${acessoMetodo.simbolo.lexema}`;
+        return `this.${nomeMetodo}`;
+    }
+    traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodoOuPropriedade) {
+        const nomeMetodo = acessoMetodoOuPropriedade.simbolo?.lexema;
+        if (acessoMetodoOuPropriedade.objeto instanceof construtos_1.Variavel) {
+            let objetoVariavel = acessoMetodoOuPropriedade.objeto;
+            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(nomeMetodo)}`;
+        }
+        return `this.${nomeMetodo}`;
     }
     traduzirConstrutoAcessoIndiceVariavel(acessoIndiceVariavel) {
         let resultado = '';