@designliquido/delegua 0.73.0 → 1.1.0

package/avaliador-sintatico/dialetos/avaliador-sintatico-prisma.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avaliador-sintatico-prisma.d.ts","sourceRoot":"","sources":["../../../fontes/avaliador-sintatico/dialetos/avaliador-sintatico-prisma.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"avaliador-sintatico-prisma.d.ts","sourceRoot":"","sources":["../../../fontes/avaliador-sintatico/dialetos/avaliador-sintatico-prisma.ts"],"names":[],"mappings":"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"}

package/avaliador-sintatico/dialetos/avaliador-sintatico-prisma.js

@@ -8,7 +8,6 @@ const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime
 const construtos_1 = require("../../construtos");
 const declaracoes_1 = require("../../declaracoes");
 const avaliador_sintatico_base_1 = require("../avaliador-sintatico-base");
-const erro_avaliador_sintatico_1 = require("../erro-avaliador-sintatico");
 const inferenciador_1 = require("../../inferenciador");
 const pilha_escopos_1 = require("../pilha-escopos");
 const informacao_escopo_1 = require("../informacao-escopo");
@@ -59,11 +58,6 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             this.avancarEDevolverAnterior();
         }
     }
-    erro(simbolo, mensagemDeErro) {
-        const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
-        this.erros.push(excecao);
-        return excecao;
-    }
     consumir(tipo, mensagemDeErro) {
         if (this.verificarTipoSimboloAtual(tipo))
             return this.avancarEDevolverAnterior();
@@ -97,7 +91,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         return false;
     }
-    primario() {
+    async primario() {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
@@ -124,7 +118,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                         // Lógica para índice nomeado
                         // TODO: Terminar
                     }
-                    const valor = this.ou();
+                    const valor = await this.ou();
                     chaves.push(chave);
                     valores.push(valor);
                     indice++;
@@ -138,7 +132,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             case prisma_1.default.FUNCAO:
             case prisma_1.default.FUNÇÃO:
                 const simboloFuncao = this.avancarEDevolverAnterior();
-                const corpoDaFuncao = this.corpoDaFuncao(simboloFuncao.lexema);
+                const corpoDaFuncao = await this.corpoDaFuncao(simboloFuncao.lexema);
                 this.pilhaEscopos.definirInformacoesVariavel(simboloFuncao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloFuncao.lexema, 'função'));
                 return corpoDaFuncao;
             case prisma_1.default.IMPORTAR:
@@ -174,7 +168,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando);
             case prisma_1.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
-                const expressao = this.expressao();
+                const expressao = await this.expressao();
                 this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
                 return new construtos_1.Agrupamento(this.hashArquivo, simboloAtual.linha, expressao);
             case prisma_1.default.SUPER:
@@ -205,43 +199,43 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.consumir(prisma_1.default.COLCHETE_DIREITO, "Esperado ']' após o texto multilinhas.");
         return new construtos_1.Literal(this.hashArquivo, segundoColchete.linha, texto);
     }
-    expressaoLeia() {
+    async expressaoLeia() {
         const simboloLeia = this.avancarEDevolverAnterior();
         this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
             do {
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
         }
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
         return new construtos_1.Leia(simboloLeia, argumentos);
     }
-    finalizarChamada(entidadeChamada) {
+    async finalizarChamada(entidadeChamada) {
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
                     throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
                 }
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
         }
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, argumentos);
     }
-    chamar() {
-        let expressao = this.primario();
+    async chamar() {
+        let expressao = await this.primario();
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PARENTESE_ESQUERDO)) {
-                expressao = this.finalizarChamada(expressao);
+                expressao = await this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PONTO)) {
                 const nome = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
             else if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.COLCHETE_ESQUERDO)) {
-                const indice = this.expressao();
+                const indice = await this.expressao();
                 const simboloFechamento = this.consumir(prisma_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             }
@@ -251,119 +245,119 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         return expressao;
     }
-    unario() {
+    async unario() {
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.NEGACAO, prisma_1.default.SUBTRACAO, prisma_1.default.BIT_NOT)) {
             const operador = this.simboloAnterior();
-            const direito = this.unario();
+            const direito = await this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito);
         }
-        return this.chamar();
+        return await this.chamar();
     }
-    exponenciacao() {
-        let expressao = this.unario();
+    async exponenciacao() {
+        let expressao = await this.unario();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.EXPONENCIACAO)) {
             const operador = this.simboloAnterior();
-            const direito = this.unario();
+            const direito = await this.unario();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    multiplicar() {
-        let expressao = this.exponenciacao();
+    async multiplicar() {
+        let expressao = await this.exponenciacao();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.DIVISAO, prisma_1.default.DIVISAO_INTEIRA, prisma_1.default.MULTIPLICACAO, prisma_1.default.MODULO)) {
             const operador = this.simboloAnterior();
-            const direito = this.exponenciacao();
+            const direito = await this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    adicaoOuSubtracao() {
-        let expressao = this.multiplicar();
+    async adicaoOuSubtracao() {
+        let expressao = await this.multiplicar();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SUBTRACAO, prisma_1.default.ADICAO)) {
             const operador = this.simboloAnterior();
-            const direito = this.multiplicar();
+            const direito = await this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitShift() {
-        let expressao = this.adicaoOuSubtracao();
+    async bitShift() {
+        let expressao = await this.adicaoOuSubtracao();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.MENOR_MENOR, prisma_1.default.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
-            const direito = this.adicaoOuSubtracao();
+            const direito = await this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitE() {
-        let expressao = this.bitShift();
+    async bitE() {
+        let expressao = await this.bitShift();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.BIT_AND)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitShift();
+            const direito = await this.bitShift();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitOu() {
-        let expressao = this.bitE();
+    async bitOu() {
+        let expressao = await this.bitE();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.BIT_OR, prisma_1.default.BIT_XOR)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitE();
+            const direito = await this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    comparar() {
-        let expressao = this.bitOu();
+    async comparar() {
+        let expressao = await this.bitOu();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.MAIOR, prisma_1.default.MAIOR_IGUAL, prisma_1.default.MENOR, prisma_1.default.MENOR_IGUAL)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitOu();
+            const direito = await this.bitOu();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
+    async comparacaoIgualdade() {
+        let expressao = await this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.DIFERENTE, prisma_1.default.IGUAL_IGUAL)) {
             const operador = this.simboloAnterior();
-            const direito = this.comparar();
+            const direito = await this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    em() {
-        let expressao = this.comparacaoIgualdade();
+    async em() {
+        let expressao = await this.comparacaoIgualdade();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.EM)) {
             const operador = this.simboloAnterior();
-            const direito = this.comparacaoIgualdade();
+            const direito = await this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    e() {
-        let expressao = this.em();
+    async e() {
+        let expressao = await this.em();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.E)) {
             const operador = this.simboloAnterior();
-            const direito = this.em();
+            const direito = await this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    ou() {
-        let expressao = this.e();
+    async ou() {
+        let expressao = await this.e();
         while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.OU)) {
             const operador = this.simboloAnterior();
-            const direito = this.e();
+            const direito = await this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    atribuir() {
-        const expressao = this.ou();
+    async atribuir() {
+        const expressao = await this.ou();
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(prisma_1.default.MAIS_IGUAL)) {
             const igual = this.simboloAnterior();
-            const valor = this.atribuir();
+            const valor = await this.atribuir();
             if (expressao instanceof construtos_1.Variavel) {
                 return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
             }
@@ -377,31 +371,31 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         }
         return expressao;
     }
-    expressao() {
-        return this.atribuir();
+    async expressao() {
+        return await this.atribuir();
     }
-    declaracaoEscreva() {
+    async declaracaoEscreva() {
         const simboloEscreva = this.simboloAnterior();
         this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em imprima.");
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
             do {
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
         }
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em imprima.");
         this.verificarSeSimboloAtualEIgualA(prisma_1.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Escreva(Number(simboloEscreva.linha), simboloEscreva.hashArquivo, argumentos);
     }
-    declaracaoExpressao() {
-        const expressao = this.expressao();
+    async declaracaoExpressao() {
+        const expressao = await this.expressao();
         return new declaracoes_1.Expressao(expressao);
     }
-    blocoEscopo() {
+    async blocoEscopo() {
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
         let declaracoes = [];
         while (!this.verificarTipoSimboloAtual(prisma_1.default.FIM) && !this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
@@ -413,11 +407,11 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.pilhaEscopos.removerUltimo();
         return declaracoes;
     }
-    declaracaoDeLocal() {
+    async declaracaoDeLocal() {
         const identificador = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
         let inicializador = null;
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL)) {
-            inicializador = this.expressao();
+            inicializador = await this.expressao();
         }
         this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após declaração de variável.");
         // Para Prisma, mantemos a tipagem inferida de forma simples por enquanto.
@@ -425,24 +419,24 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
         return new declaracoes_1.Var(identificador, inicializador, tipo);
     }
-    declaracaoEnquanto() {
+    async declaracaoEnquanto() {
         try {
             this.blocos += 1;
-            const condicao = this.expressao();
-            const bloco = this.resolverDeclaracao();
+            const condicao = await this.expressao();
+            const bloco = await this.resolverDeclaracao();
             return new declaracoes_1.Enquanto(condicao, bloco);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    declaracaoSe() {
+    async declaracaoSe() {
         const simboloSe = this.simbolos[this.atual];
-        const condicao = this.expressao();
+        const condicao = await this.expressao();
         this.consumir(prisma_1.default.ENTAO, "Esperado palavra reservada 'entao' ou 'então' após condição em declaração 'se'.");
         const declaracoes = [];
         do {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            declaracoes.push(await this.resolverDeclaracaoForaDeBloco());
         } while (!this.estaNoFinal() &&
             ![prisma_1.default.SENAO, prisma_1.default.SENÃO, prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
         let caminhoSenao = null;
@@ -450,14 +444,14 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             const simboloSenao = this.simbolos[this.atual - 1];
             const declaracoesSenao = [];
             do {
-                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
+                declaracoesSenao.push(await this.resolverDeclaracaoForaDeBloco());
             } while (![prisma_1.default.FIM].includes(this.simbolos[this.atual].tipo));
             caminhoSenao = new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSenao.linha), declaracoesSenao.filter((d) => d));
         }
         this.consumir(prisma_1.default.FIM, "Esperado palavra-chave 'fimse' para fechamento de declaração 'se'.");
         return new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(this.hashArquivo, Number(simboloSe.linha), declaracoes.filter((d) => d)), [], caminhoSenao);
     }
-    declaracaoQuebre() {
+    async declaracaoQuebre() {
         if (this.blocos < 1) {
             throw this.erro(this.simboloAnterior(), "'quebre' deve estar dentro de um laço de repetição.");
         }
@@ -471,37 +465,37 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após 'continua'.");
         return new declaracoes_1.Continua(this.simbolos[this.atual]);
     }
-    declaracaoRetorna() {
+    async declaracaoRetorna() {
         const palavraChave = this.simboloAnterior();
         let valor = null;
         if (!this.verificarTipoSimboloAtual(prisma_1.default.PONTO_E_VIRGULA)) {
-            valor = this.expressao();
+            valor = await this.expressao();
         }
         this.consumir(prisma_1.default.PONTO_E_VIRGULA, "Esperado ';' após valor de retorno.");
         return new declaracoes_1.Retorna(palavraChave, valor);
     }
-    declaracaoImportar() {
+    async declaracaoImportar() {
         this.avancarEDevolverAnterior();
         this.consumir(prisma_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
-        const caminho = this.expressao();
+        const caminho = await this.expressao();
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new declaracoes_1.Importar(caminho);
     }
-    corpoDaFuncao(tipo) {
+    async corpoDaFuncao(tipo) {
         const parenteseEsquerdo = this.consumir(prisma_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
         let parametros = [];
         if (!this.verificarTipoSimboloAtual(prisma_1.default.PARENTESE_DIREITO)) {
-            parametros = this.logicaComumParametros();
+            parametros = await this.logicaComumParametros();
         }
         this.consumir(prisma_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.SETA)) {
             tipoRetorno = 'qualquer'; // Simplificado por enquanto
         }
-        const corpo = this.blocoEscopo();
+        const corpo = await this.blocoEscopo();
         return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo, tipoRetorno, false);
     }
-    logicaComumParametros() {
+    async logicaComumParametros() {
         const parametros = [];
         do {
             if (parametros.length >= 255) {
@@ -511,24 +505,24 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             parametro.abrangencia = 'padrao';
             parametro.nome = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
             if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.IGUAL)) {
-                parametro.valorPadrao = this.primario();
+                parametro.valorPadrao = await this.primario();
             }
             this.pilhaEscopos.definirInformacoesVariavel(parametro.nome.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer'));
             parametros.push(parametro);
         } while (this.verificarSeSimboloAtualEIgualA(prisma_1.default.VIRGULA));
         return parametros;
     }
-    funcao(tipo) {
+    async funcao(tipo) {
         const simbolo = this.consumir(prisma_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`);
         this.pilhaEscopos.definirInformacoesVariavel(simbolo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simbolo.lexema, 'qualquer'));
-        const corpoDaFuncao = this.corpoDaFuncao(tipo);
+        const corpoDaFuncao = await this.corpoDaFuncao(tipo);
         const tipoDaFuncao = `função<${corpoDaFuncao.tipo}>`;
         this.pilhaEscopos.definirInformacoesVariavel(simbolo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simbolo.lexema, tipoDaFuncao));
         const funcaoDeclaracao = new declaracoes_1.FuncaoDeclaracao(simbolo, corpoDaFuncao, tipoDaFuncao);
         this.pilhaEscopos.registrarReferenciaFuncao(simbolo.lexema, funcaoDeclaracao);
         return funcaoDeclaracao;
     }
-    resolverDeclaracao() {
+    async resolverDeclaracao() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
             case prisma_1.default.CONTINUA:
@@ -541,44 +535,44 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             case prisma_1.default.ENTAO:
             case prisma_1.default.INICIO:
                 const simboloInicioBloco = this.avancarEDevolverAnterior();
-                return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
+                return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), await this.blocoEscopo());
             case prisma_1.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoEnquanto();
+                return await this.declaracaoEnquanto();
             case prisma_1.default.IDENTIFICADOR:
                 const proximoSimbolo = this.simbolos[this.atual + 1];
                 if (proximoSimbolo && proximoSimbolo.tipo === prisma_1.default.IGUAL) {
-                    return this.declaracaoOuAtribuicaoVariaveis();
+                    return await this.declaracaoOuAtribuicaoVariaveis();
                 }
                 // Avaliar como expressão normal, sair do `switch`.
                 break;
             case prisma_1.default.IMPRIMA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoEscreva();
+                return await this.declaracaoEscreva();
             case prisma_1.default.PARA:
-                return this.declaracaoPara();
+                return await this.declaracaoPara();
             case prisma_1.default.QUEBRE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoQuebre();
             case prisma_1.default.SE:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoSe();
+                return await this.declaracaoSe();
             case prisma_1.default.RETORNE:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoRetorna();
+                return await this.declaracaoRetorna();
             case prisma_1.default.LOCAL:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoDeLocal();
+                return await this.declaracaoDeLocal();
         }
-        return this.declaracaoExpressao();
+        return await this.declaracaoExpressao();
     }
-    declaracaoOuAtribuicaoVariaveis() {
+    async declaracaoOuAtribuicaoVariaveis() {
         const identificador = this.avancarEDevolverAnterior();
         this.consumir(prisma_1.default.IGUAL, "Esperado '=' após identificador.");
         if (this.estaNoFinal()) {
             throw this.erro(this.simboloAnterior(), 'Esperado valor após o símbolo de igual.');
         }
-        const valor = this.expressao();
+        const valor = await this.expressao();
         const tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(valor, 'qualquer');
         if (this.pilhaEscopos.variavelJaDefinida(identificador.lexema)) {
             return new declaracoes_1.Expressao(new construtos_1.Atribuir(identificador.hashArquivo, new construtos_1.Variavel(identificador.hashArquivo, identificador), valor));
@@ -608,15 +602,15 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 console.log(inicializador.constructor.name);
         }
     }
-    declaracaoPara() {
+    async declaracaoPara() {
         try {
             this.blocos += 1;
             const simboloPara = this.avancarEDevolverAnterior();
             const variavelIteracao = this.consumir(prisma_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
             this.consumir(prisma_1.default.IGUAL, `'=' or 'em' esperado próximo a '${this.simbolos[this.atual].lexema}'.`);
-            const literalOuVariavelInicio = this.adicaoOuSubtracao();
+            const literalOuVariavelInicio = await this.adicaoOuSubtracao();
             this.consumir(prisma_1.default.VIRGULA, `Espera-se '=' próximo a '${this.simbolos[this.atual].lexema}'.`);
-            const literalOuVariavelFim = this.adicaoOuSubtracao();
+            const literalOuVariavelFim = await this.adicaoOuSubtracao();
             let operadorCondicao = new lexador_1.Simbolo(prisma_1.default.MENOR_IGUAL, '<=', null, Number(simboloPara.linha), this.hashArquivo);
             let operadorCondicaoIncremento = new lexador_1.Simbolo(prisma_1.default.MENOR, '<', null, Number(simboloPara.linha), this.hashArquivo);
             let passo = new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), 1);
@@ -627,7 +621,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             const declaracoesBlocoPara = [];
             let simboloAtualBlocoPara = this.simbolos[this.atual];
             while (simboloAtualBlocoPara.tipo !== prisma_1.default.FIM) {
-                declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
+                declaracoesBlocoPara.push(await this.resolverDeclaracaoForaDeBloco());
                 simboloAtualBlocoPara = this.simbolos[this.atual];
             }
             this.avancarEDevolverAnterior(); // fim
@@ -647,24 +641,25 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             this.blocos -= 1;
         }
     }
-    resolverDeclaracaoForaDeBloco() {
+    async resolverDeclaracaoForaDeBloco() {
         try {
             if ((this.verificarTipoSimboloAtual(prisma_1.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(prisma_1.default.FUNÇÃO)) &&
                 this.verificarTipoProximoSimbolo(prisma_1.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
-                return this.funcao('funcao');
+                return await this.funcao('funcao');
             }
             if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.CLASSE))
-                return this.declaracaoDeClasse();
-            return this.resolverDeclaracao();
+                return await this.declaracaoDeClasse();
+            return await this.resolverDeclaracao();
         }
         catch (erro) {
             this.sincronizar();
+            this.erros.push(erro);
             return null;
         }
     }
-    declaracaoDeClasse() {
+    async declaracaoDeClasse() {
         const simbolo = this.consumir(prisma_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(prisma_1.default.PARENTESE_ESQUERDO)) {
@@ -680,7 +675,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
                 this.verificarTipoSimboloAtual(prisma_1.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(prisma_1.default.FUNÇÃO))) {
             const ehConstrutor = this.verificarSeSimboloAtualEIgualA(prisma_1.default.CONSTRUTOR);
-            metodos.push(this.funcao('método'));
+            metodos.push(await this.funcao('método'));
         }
         this.consumir(prisma_1.default.CHAVE_DIREITA, "Esperado '}' após métodos da classe.");
         this.superclasseAtual = undefined;
@@ -721,7 +716,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
             ])
         ); */
     }
-    analisar(retornoLexador, hashArquivo) {
+    async analisar(retornoLexador, hashArquivo) {
         const inicioAnalise = (0, browser_process_hrtime_1.default)();
         this.erros = [];
         this.atual = 0;
@@ -732,7 +727,7 @@ class AvaliadorSintaticoPrisma extends avaliador_sintatico_base_1.AvaliadorSinta
         this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
         let declaracoes = [];
         while (!this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }