@designliquido/delegua 1.11.1 → 1.13.0

package/umd/delegua.js

@@ -4343,13 +4343,26 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 const simboloDoc = this.avancarEDevolverAnterior();
                 docTopLevel = new construtos_1.ComentarioComoConstruto(simboloDoc);
             }
-            if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
-                this.avancarEDevolverAnterior();
-                const declaracaoFuncao = (await this.funcao('funcao'));
-                declaracaoFuncao.documentacao = docTopLevel;
-                return declaracaoFuncao;
+            if (this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) {
+                if (this.verificarTipoProximoSimbolo(delegua_2.default.DE)) {
+                    this.avancarEDevolverAnterior(); // `função`
+                    this.avancarEDevolverAnterior(); // `de`
+                    const simboloDecorador = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado 'decorador' após 'função de'.");
+                    if (simboloDecorador.lexema !== 'decorador') {
+                        throw this.erro(simboloDecorador, "Esperado 'decorador' após 'função de'.");
+                    }
+                    const declaracaoFuncao = (await this.funcao('funcao'));
+                    declaracaoFuncao.eFuncaoDeDecorador = true;
+                    declaracaoFuncao.documentacao = docTopLevel;
+                    return declaracaoFuncao;
+                }
+                if (this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
+                    this.avancarEDevolverAnterior();
+                    const declaracaoFuncao = (await this.funcao('funcao'));
+                    declaracaoFuncao.documentacao = docTopLevel;
+                    return declaracaoFuncao;
+                }
             }
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CLASSE)) {
                 return await this.declaracaoDeClasse();
@@ -4414,7 +4427,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.COMENTARIO:
                 return this.declaracaoComentarioUmaLinha();
             case delegua_2.default.DOCUMENTARIO: {
-                const simboloDoc = this.avancarEDevolverAnterior();
+                const simboloDocumentario = this.avancarEDevolverAnterior();
                 // Se o próximo token for uma declaração de função com identificador,
                 // anexa o documentário como documentação da função.
                 if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
@@ -4422,10 +4435,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                     this.avancarEDevolverAnterior();
                     const declaracaoFuncao = (await this.funcao('funcao'));
-                    declaracaoFuncao.documentacao = new construtos_1.ComentarioComoConstruto(simboloDoc);
+                    declaracaoFuncao.documentacao = new construtos_1.ComentarioComoConstruto(simboloDocumentario);
                     return declaracaoFuncao;
                 }
-                return new declaracoes_1.Comentario(simboloDoc.hashArquivo, simboloDoc.linha, simboloDoc.literal, false);
+                return new declaracoes_1.Comentario(simboloDocumentario.hashArquivo, simboloDocumentario.linha, simboloDocumentario.literal, false);
             }
             case delegua_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
@@ -5841,7 +5854,8 @@ class AvaliadorSintaticoPitugues {
         }
     }
     erro(simbolo, mensagemDeErro) {
-        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        const simboloParaErro = simbolo || this.simboloAnterior();
+        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simboloParaErro, mensagemDeErro);
         this.erros.push(excecao);
         return excecao;
     }
@@ -5856,7 +5870,7 @@ class AvaliadorSintaticoPitugues {
         return this.simboloAtual().tipo === tipo;
     }
     verificarTipoProximoSimbolo(tipo) {
-        if (this.estaNoFinal())
+        if (this.atual + 1 >= this.simbolos.length)
             return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
@@ -6226,7 +6240,7 @@ class AvaliadorSintaticoPitugues {
             while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
                 const operador = this.simbolos[this.atual - 1];
                 const expressaoOuCondicao = await this.seTernario();
-                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
+                this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
                     ${this.simbolos[this.atual].lexema}.`);
                 const expressaoSenao = await this.seTernario();
                 expressaoEntao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
@@ -6324,55 +6338,40 @@ class AvaliadorSintaticoPitugues {
         let declaracoes = [];
         let simboloAtual = this.simboloAtual();
         const simboloAnterior = this.simboloAnterior();
-        // Situação 1: não tem bloco de escopo.
-        //
-        // Exemplo: `se verdadeiro: escreva('Alguma coisa')`.
-        // Neste caso, linha do símbolo atual é igual à linha do símbolo anterior.
+        if (!simboloAtual) {
+            throw this.erro(simboloAnterior, 'Esperado corpo do escopo após a declaração.');
+        }
+        // Declaração na mesma linha (ex: 'se verdadeiro: escreva("Oi")')
         if (simboloAtual.linha === simboloAnterior.linha) {
-            const declaracoesBloco = await this.resolverDeclaracaoForaDeBloco();
-            if (declaracoesBloco !== null) {
-                if (Array.isArray(declaracoesBloco)) {
-                    declaracoes = declaracoes.concat(declaracoesBloco);
-                }
-                else {
-                    declaracoes.push(declaracoesBloco);
-                }
-            }
+            const retorno = await this.resolverDeclaracaoForaDeBloco();
+            if (retorno !== null)
+                declaracoes = declaracoes.concat(retorno);
         }
         else {
-            // Situação 2: símbolo atual fica na próxima linha.
-            //
-            // Verifica-se o número de espaços à esquerda da linha através dos pragmas.
-            // Se número de espaços da linha do símbolo atual é menor ou igual ao número de espaços
-            // da linha anterior, e bloco ainda não começou, é uma situação de erro.
-            let espacosIndentacaoLinhaAtual = this.localizacoes[simboloAtual.linha].espacosIndentacao;
-            const espacosIndentacaoLinhaAnterior = this.localizacoes[simboloAnterior.linha].espacosIndentacao;
-            if (espacosIndentacaoLinhaAtual <= espacosIndentacaoLinhaAnterior) {
+            // Bloco de múltiplas linhas baseado em indentação
+            let espacosAtual = this
+                .localizacoes[simboloAtual.linha]
+                .espacosIndentacao;
+            const espacosAnterior = this
+                .localizacoes[simboloAnterior.linha]
+                .espacosIndentacao;
+            if (espacosAtual <= espacosAnterior) {
                 throw this.erro(simboloAtual, `Indentação inconsistente na linha ${simboloAtual.linha}. ` +
-                    `Esperado: >= ${espacosIndentacaoLinhaAnterior}. ` +
-                    `Atual: ${espacosIndentacaoLinhaAtual}`);
-            }
-            // Indentação ok, é um bloco de escopo.
-            // Inclui todas as declarações cujas linhas tenham o mesmo número de espaços
-            // de indentação do bloco.
-            // Se `simboloAtual` for definido em algum momento como indefinido,
-            // Significa que o código acabou, então o bloco também acabou.
-            const espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
-            while (espacosIndentacaoLinhaAtual === espacosIndentacaoBloco) {
-                const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
-                if (retornoDeclaracao !== null) {
-                    if (Array.isArray(retornoDeclaracao)) {
-                        declaracoes = declaracoes.concat(retornoDeclaracao);
-                    }
-                    else {
-                        declaracoes.push(retornoDeclaracao);
-                    }
-                }
+                    `Esperado: >= ${espacosAnterior}. ` +
+                    `Atual: ${espacosAtual}`);
+            }
+            const indentacaoBloco = espacosAtual;
+            // Consome as declarações enquanto a indentação for estritamente igual à do bloco
+            while (simboloAtual && espacosAtual === indentacaoBloco) {
+                const retorno = await this.resolverDeclaracaoForaDeBloco();
+                if (retorno !== null)
+                    declaracoes = declaracoes.concat(retorno);
                 simboloAtual = this.simboloAtual();
-                if (!simboloAtual)
-                    break;
-                espacosIndentacaoLinhaAtual =
-                    this.localizacoes[simboloAtual.linha].espacosIndentacao;
+                if (simboloAtual) {
+                    espacosAtual = this
+                        .localizacoes[simboloAtual.linha]
+                        .espacosIndentacao;
+                }
             }
         }
         this.pilhaEscopos.removerUltimo();
@@ -6848,11 +6847,10 @@ class AvaliadorSintaticoPitugues {
      */
     async resolverDeclaracaoForaDeBloco() {
         try {
-            if ((this.verificarTipoSimboloAtual(pitugues_2.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(pitugues_2.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(pitugues_2.default.IDENTIFICADOR)) {
+            if (this.verificarTipoSimboloAtual(pitugues_2.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(pitugues_2.default.FUNÇÃO)) {
                 this.avancarEDevolverAnterior();
-                return await this.funcao('funcao');
+                return await this.funcao('da função');
             }
             if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CLASSE))
                 return await this.declaracaoDeClasse();
@@ -14172,7 +14170,7 @@ const geracao_identificadores_1 = require("../geracao-identificadores");
  * Uma declaração de função.
  */
 class FuncaoDeclaracao extends declaracao_1.Declaracao {
-    constructor(simbolo, funcao, tipoRetorno = 'qualquer', decoradores = [], acesso = 'publico', estatico = false, abstrato = false, eObtenedor = false, eDefinidor = false) {
+    constructor(simbolo, funcao, tipoRetorno = 'qualquer', decoradores = [], acesso = 'publico', estatico = false, abstrato = false, eObtenedor = false, eDefinidor = false, eFuncaoDeDecorador = false) {
         super(Number(simbolo.linha), simbolo.hashArquivo);
         this.id = (0, geracao_identificadores_1.uuidv4)();
         this.simbolo = simbolo;
@@ -14184,6 +14182,7 @@ class FuncaoDeclaracao extends declaracao_1.Declaracao {
         this.abstrato = abstrato;
         this.eObtenedor = eObtenedor;
         this.eDefinidor = eDefinidor;
+        this.eFuncaoDeDecorador = eFuncaoDeDecorador;
     }
     async aceitar(visitante) {
         return await visitante.visitarDeclaracaoDefinicaoFuncao(this);
@@ -20247,14 +20246,12 @@ class InterpretadorBase {
             objeto[expressao.nome.lexema] = valor;
         }
     }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
         const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         funcao.documentacao = declaracao.documentacao;
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         this.pilhaEscoposExecucao.registrarReferenciaFuncao(declaracao.id, funcao);
-        return Promise.resolve({
-            declaracao: funcao,
-        });
+        return { declaracao: funcao };
     }
     /**
      * Executa uma declaração de classe.
@@ -21160,15 +21157,25 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
     async visitarDeclaracaoAjuda(declaracao) {
         return Promise.resolve((0, comum_1.pontoEntradaAjuda)(declaracao.funcao, declaracao.elemento));
     }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
-        const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
+        var _a, _b;
+        let funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         funcao.documentacao = declaracao.documentacao;
+        if (declaracao.decoradores && declaracao.decoradores.length > 0) {
+            for (const decorador of [...declaracao.decoradores].reverse()) {
+                const nomeDecorador = decorador.nome.slice(1);
+                const variavelDecoradora = this.pilhaEscoposExecucao.obterVariavelPorNome(nomeDecorador);
+                const funcaoDecoradora = variavelDecoradora.valor;
+                const resultado = await funcaoDecoradora.chamar(this, [{ nome: null, valor: funcao }]);
+                funcao = this.resolverValorRecursivo(resultado);
+            }
+        }
         // TODO: Depreciar essa abordagem a favor do uso por referências?
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         this.pilhaEscoposExecucao.registrarReferenciaFuncao(declaracao.id, funcao);
         return Promise.resolve({
-            tipo: `função<${funcao.declaracao.tipo || 'qualquer'}>`,
-            tipoExplicito: funcao.declaracao.tipoExplicito,
+            tipo: `função<${((_a = funcao.declaracao) === null || _a === void 0 ? void 0 : _a.tipo) || 'qualquer'}>`,
+            tipoExplicito: (_b = funcao.declaracao) === null || _b === void 0 ? void 0 : _b.tipoExplicito,
             declaracao: funcao,
         });
     }
@@ -23465,25 +23472,26 @@ class LexadorPitugues {
         this.simbolos.push(new simbolo_1.Simbolo(tipoSimbolo, textoCompleto, valor, linhaPrimeiroCaracter + 1, this.hashArquivo));
     }
     analisarNumero() {
-        const linhaPrimeiroDigito = this.linha;
-        while (this.eDigito(this.simboloAtual()) && this.linha === linhaPrimeiroDigito) {
+        const linhaInicial = this.linha;
+        while (this.linha === linhaInicial &&
+            this.eDigito(this.simboloAtual()))
             this.avancar();
-        }
-        if (this.simboloAtual() == '.' && this.eDigito(this.proximoSimbolo())) {
+        const temPonto = this.simboloAtual() === '.';
+        const proximoEhDigito = this.eDigito(this.proximoSimbolo());
+        if (this.linha === linhaInicial && temPonto && proximoEhDigito) {
             this.avancar();
-            while (this.eDigito(this.simboloAtual())) {
+            while (this.linha === linhaInicial &&
+                this.eDigito(this.simboloAtual()))
                 this.avancar();
-            }
         }
         let numeroCompleto;
-        if (linhaPrimeiroDigito < this.linha) {
-            const linhaNumero = this.codigo[linhaPrimeiroDigito];
-            numeroCompleto = linhaNumero.substring(this.inicioSimbolo, linhaNumero.length);
+        if (linhaInicial < this.linha) {
+            numeroCompleto = this.codigo[linhaInicial].substring(this.inicioSimbolo, this.codigo[linhaInicial].length);
         }
         else {
             numeroCompleto = this.codigo[this.linha].substring(this.inicioSimbolo, this.atual);
         }
-        this.simbolos.push(new simbolo_1.Simbolo(pitugues_2.default.NUMERO, numeroCompleto, parseFloat(numeroCompleto), linhaPrimeiroDigito + 1, this.hashArquivo));
+        this.simbolos.push(new simbolo_1.Simbolo(pitugues_2.default.NUMERO, numeroCompleto, parseFloat(numeroCompleto), linhaInicial + 1, this.hashArquivo));
     }
     identificarPalavraChave() {
         const linhaPrimeiroCaracter = this.linha;
@@ -23587,8 +23595,13 @@ class LexadorPitugues {
                 this.avancar();
                 break;
             case '.':
-                this.adicionarSimbolo(pitugues_2.default.PONTO);
-                this.avancar();
+                if (this.eDigito(this.proximoSimbolo())) {
+                    this.analisarNumero();
+                }
+                else {
+                    this.adicionarSimbolo(pitugues_2.default.PONTO);
+                    this.avancar();
+                }
                 break;
             case '-':
                 this.avancar();