@designliquido/potigol 0.7.2 → 0.8.1

package/avaliador-sintatico/avaliador-sintatico-potigol.js

@@ -75,9 +75,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * @param tipoRetorno O tipo de retorno da função.
      * @returns Um construto do tipo `FuncaoDeclaracao`.
      */
-    declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloPrimario, parametros, tipoRetorno) {
+    async declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloPrimario, parametros, tipoRetorno) {
         const corpo = new construtos_1.FuncaoConstruto(simboloPrimario.hashArquivo, simboloPrimario.linha, parametros, [
-            new declaracoes_1.Retorna(simboloPrimario, this.expressao()),
+            new declaracoes_1.Retorna(simboloPrimario, await this.expressao()),
         ]);
         if (tipoRetorno) {
             corpo.tipo = tipoRetorno.lexema;
@@ -94,15 +94,15 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * @param tipoRetorno O tipo de retorno da função.
      * @returns Um construto do tipo `FuncaoDeclaracao`.
      */
-    declaracaoFuncaoPotigolTerminadaPorFim(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
-        const corpo = this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros);
+    async declaracaoFuncaoPotigolTerminadaPorFim(simboloPrimario, parenteseEsquerdo, parametros, tipoRetorno) {
+        const corpo = await this.corpoDaFuncao(simboloPrimario.lexema, parenteseEsquerdo, parametros);
         if (tipoRetorno) {
             corpo.tipo = tipoRetorno.lexema;
         }
         return new declaracoes_1.FuncaoDeclaracao(simboloPrimario, corpo, tipoRetorno.lexema);
     }
-    corpoDaFuncao(nomeFuncao, simboloLocalizacao, parametros) {
-        const corpo = this.blocoEscopo();
+    async corpoDaFuncao(nomeFuncao, simboloLocalizacao, parametros) {
+        const corpo = await this.blocoEscopo();
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(simboloLocalizacao.linha), parametros, corpo);
     }
     /**
@@ -112,7 +112,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * @param {SimboloInterface} simboloNomeFuncao Normalmente um `Simbolo` do tipo `IDENTIFICADOR`.
      * @returns
      */
-    logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao) {
+    async logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de localização.
         const parenteseEsquerdo = this.avancarEDevolverAnterior();
@@ -133,26 +133,26 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         // seja após a dica de retorno, é uma declaração de função.
         if (this.simbolos[this.atual].tipo === lexico_regular_1.default.IGUAL) {
             this.avancarEDevolverAnterior();
-            const corpoFuncao = this.declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloNomeFuncao, resolucaoParametros.parametros, tipoRetorno);
+            const corpoFuncao = await this.declaracaoFuncaoPotigolIniciadaPorIgualOuSeta(simboloNomeFuncao, resolucaoParametros.parametros, tipoRetorno);
             return new declaracoes_1.FuncaoDeclaracao(simboloNomeFuncao, corpoFuncao, tipoRetorno ? tipoRetorno.lexema : 'qualquer');
         }
         return this.declaracaoFuncaoPotigolTerminadaPorFim(simboloNomeFuncao, parenteseEsquerdo, resolucaoParametros.parametros, tipoRetorno);
     }
-    declaracaoDeFuncaoComDef() {
+    async declaracaoDeFuncaoComDef() {
         this.avancarEDevolverAnterior(); // `def`
         const simboloNomeFuncao = this.consumir(lexico_regular_1.default.IDENTIFICADOR, `Esperado nome da função após palavra reservada 'def'. Atual: ${this.simbolos[this.atual].tipo}.`);
-        return this.logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao);
+        return await this.logicaComumDefinicaoFuncaoComNome(simboloNomeFuncao);
     }
-    declaracaoDeFuncaoOuMetodo(construtoPrimario) {
-        return this.logicaComumDefinicaoFuncaoComNome(construtoPrimario.simbolo);
+    async declaracaoDeFuncaoOuMetodo(construtoPrimario) {
+        return await this.logicaComumDefinicaoFuncaoComNome(construtoPrimario.simbolo);
     }
-    finalizarChamada(entidadeChamada) {
+    async finalizarChamada(entidadeChamada) {
         const simbolosEntreParenteses = [];
         while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.PARENTESE_DIREITO)) {
             simbolosEntreParenteses.push(this.avancarEDevolverAnterior());
         }
         this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        const argumentos = this.microAvaliadorSintatico.analisar({ simbolos: simbolosEntreParenteses }, entidadeChamada.linha);
+        const argumentos = await this.microAvaliadorSintatico.analisar({ simbolos: simbolosEntreParenteses }, entidadeChamada.linha);
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, argumentos.declaracoes.filter((d) => d));
     }
     /**
@@ -214,10 +214,10 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
             tipagemDefinida,
         };
     }
-    logicaLeiaMultiplo() {
+    async logicaLeiaMultiplo() {
         const simboloLeiaMultiplo = this.avancarEDevolverAnterior();
         this.consumir(lexico_regular_1.default.PARENTESE_ESQUERDO, `Esperado parêntese esquerdo após ${simboloLeiaMultiplo.lexema}.`);
-        const argumento = this.expressao();
+        const argumento = await this.expressao();
         this.consumir(lexico_regular_1.default.PARENTESE_DIREITO, `Esperado parêntese direito após número de parâmetros em chamada de ${simboloLeiaMultiplo.lexema}.`);
         switch (simboloLeiaMultiplo.tipo) {
             case lexico_regular_1.default.LEIA_INTEIROS:
@@ -289,12 +289,12 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 return new SeletorTuplas(...argumentos) as Tupla;
         } */
     }
-    primario() {
+    async primario() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
             case lexico_regular_1.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
-                const expressao = this.ou();
+                const expressao = await this.ou();
                 switch (this.simbolos[this.atual].tipo) {
                     case lexico_regular_1.default.DOIS_PONTOS:
                         const argumentosFuncao = this.logicaArgumentosTipados(expressao);
@@ -314,7 +314,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                     return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
                 }
                 while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.COLCHETE_DIREITO)) {
-                    const valor = this.atribuir();
+                    const valor = await this.atribuir();
                     valores.push(valor);
                     if (this.simbolos[this.atual].tipo !== lexico_regular_1.default.COLCHETE_DIREITO) {
                         this.consumir(lexico_regular_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
@@ -351,14 +351,14 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
             case lexico_regular_1.default.LEIA_INTEIROS:
             case lexico_regular_1.default.LEIA_REAIS:
             case lexico_regular_1.default.LEIA_TEXTOS:
-                return this.logicaLeiaMultiplo();
+                return await this.logicaLeiaMultiplo();
             default:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 return new construtos_2.ConstanteOuVariavel(this.hashArquivo, simboloIdentificador);
         }
     }
-    formato() {
-        const expressao = this.primario();
+    async formato() {
+        const expressao = await this.primario();
         if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.FORMATO)) {
             // O próximo símbolo precisa ser um texto no padrão "%Nd" ou "%.Nf", onde N é um inteiro.
             const simboloMascaraFormato = this.consumir(lexico_regular_1.default.TEXTO, "Esperado máscara de formato após método 'formato'.");
@@ -375,14 +375,14 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * em sequência
      * @returns Um construto, ou vindo da continuação da análise, ou um Binário.
      */
-    concatenacaoLista() {
-        let expressao = this.formato();
+    async concatenacaoLista() {
+        let expressao = await this.formato();
         if (this.atual < this.simbolos.length) {
             if (this.simbolos[this.atual].tipo === lexico_regular_1.default.DOIS_PONTOS &&
                 this.verificarTipoProximoSimbolo(lexico_regular_1.default.DOIS_PONTOS)) {
                 const primeiroDoisPontos = this.avancarEDevolverAnterior();
                 this.avancarEDevolverAnterior();
-                const ladoDireito = this.formato();
+                const ladoDireito = await this.formato();
                 // Como aqui precisamos resolver se o lado direito é constante ou variável,
                 // e a concatenação funciona para o operando direito apenas como leitura,
                 // é seguro emitir um construto de constante aqui.
@@ -403,14 +403,14 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * @returns Um construto do tipo `AcessoMetodo`, `AcessoIndiceVariavel` ou `Constante`,
      * dependendo dos símbolos encontrados.
      */
-    chamar() {
-        let expressao = this.concatenacaoLista();
+    async chamar() {
+        let expressao = await this.concatenacaoLista();
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PARENTESE_ESQUERDO)) {
                 if (expressao instanceof construtos_2.ConstanteOuVariavel) {
                     expressao = new construtos_1.Constante(expressao.hashArquivo, expressao.simbolo);
                 }
-                expressao = this.finalizarChamada(expressao);
+                expressao = await this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PONTO)) {
                 if (this.verificarTipoSimboloAtual(lexico_regular_1.default.QUAL_TIPO)) {
@@ -428,7 +428,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 }
             }
             else if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.COLCHETE_ESQUERDO)) {
-                const indice = this.expressao();
+                const indice = await this.expressao();
                 const simboloFechamento = this.consumir(lexico_regular_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 const variavelVetor = new construtos_1.Variavel(expressao.hashArquivo, expressao.simbolo);
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, variavelVetor, indice, simboloFechamento);
@@ -452,11 +452,11 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
         return expressao;
     }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
+    async comparacaoIgualdade() {
+        let expressao = await this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.DIFERENTE, lexico_regular_1.default.IGUAL_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.comparar();
+            const direito = await this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
@@ -511,20 +511,18 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
     }
     logicaComumInferenciaTiposLeia(inicializador) {
-        // Por algum motivo (muito) estranho, `inicializador.constructor.name` não funciona aqui.
-        // O nome da classe vai parar numa propriedade `name`.
-        switch (inicializador.name) {
-            case 'LeiaInteiros':
+        switch (inicializador.constructor) {
+            case construtos_2.LeiaInteiros:
                 return 'inteiro[]';
-            case 'LeiaInteiro':
+            case construtos_2.LeiaInteiro:
                 return 'inteiro';
-            case 'LeiaReais':
+            case construtos_2.LeiaReais:
                 return 'real[]';
-            case 'LeiaReal':
+            case construtos_2.LeiaReal:
                 return 'real';
-            case 'LeiaTextos':
+            case construtos_2.LeiaTextos:
                 return 'texto[]';
-            case 'LeiaTexto':
+            case construtos_2.LeiaTexto:
                 return 'texto';
             default:
                 return 'qualquer';
@@ -533,7 +531,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
     /**
      * Em Potigol, a palavra reservada `val` indica uma constante.
      */
-    declaracaoDeConstanteExplicita() {
+    async declaracaoDeConstanteExplicita() {
         this.avancarEDevolverAnterior(); // `val`
         const nomeConstante = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome da constante.');
         let tipo = null;
@@ -546,13 +544,13 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
             this.avancarEDevolverAnterior();
         }
         this.consumir(lexico_regular_1.default.IGUAL, "Esperado '=' após identificador em instrução 'val'.");
-        let inicializador = this.expressao();
-        if (['LeiaInteiro', 'LeiaReal', 'LeiaTexto'].includes(inicializador.constructor.name)) {
+        let inicializador = await this.expressao();
+        if (inicializador instanceof construtos_2.LeiaInteiro || inicializador instanceof construtos_2.LeiaReal || inicializador instanceof construtos_2.LeiaTexto) {
             inicializador = this.logicaComumInicializadorLeia(inicializador, [nomeConstante]);
         }
         return new declaracoes_1.Const(nomeConstante, inicializador, tipo);
     }
-    declaracaoDeConstantes(primeiroIdentificador) {
+    async declaracaoDeConstantes(primeiroIdentificador) {
         // Normalmente o símbolo atual aqui será uma vírgula.
         this.avancarEDevolverAnterior();
         const identificadores = [primeiroIdentificador.simbolo];
@@ -574,9 +572,8 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         this.consumir(lexico_regular_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
         const inicializadores = [];
         do {
-            let inicializador = this.expressao();
-            if (identificadores.length > 1 &&
-                ['LeiaInteiro', 'LeiaReal', 'LeiaTexto'].includes(inicializador.constructor.name)) {
+            let inicializador = await this.expressao();
+            if (identificadores.length > 1 && (inicializador instanceof construtos_2.LeiaInteiro || inicializador instanceof construtos_2.LeiaReal || inicializador instanceof construtos_2.LeiaTexto)) {
                 inicializador = this.logicaComumInicializadorLeia(inicializador, identificadores);
             }
             inicializadores.push(inicializador);
@@ -585,10 +582,12 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
             // Pode ser que a inicialização seja feita por uma das
             // funções `leia`, que podem ler vários valores. Neste caso, não deve dar erro.
             if (!(inicializadores.length === 1 &&
-                ['LeiaInteiros', 'LeiaReais', 'LeiaTextos'].includes(inicializadores[0].constructor.name))) {
-                throw this.erro(this.simbolos[this.atual], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
+                (inicializadores[0] instanceof construtos_2.LeiaInteiro || inicializadores[0] instanceof construtos_2.LeiaInteiros ||
+                    inicializadores[0] instanceof construtos_2.LeiaReal || inicializadores[0] instanceof construtos_2.LeiaReais ||
+                    inicializadores[0] instanceof construtos_2.LeiaTexto || inicializadores[0] instanceof construtos_2.LeiaTextos))) {
+                throw this.erro(identificadores[0], 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
             }
-            const tipoConversao = this.logicaComumInferenciaTiposLeia(inicializadores[0].constructor);
+            const tipoConversao = this.logicaComumInferenciaTiposLeia(inicializadores[0]);
             return new declaracoes_1.ConstMultiplo(identificadores, inicializadores[0], tipoConversao);
         }
         let retorno = [];
@@ -607,7 +606,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * @param primeiroIdentificador Um construto de variável. É defiido em reatribuições.
      * @returns Um vetor de declarações `Var`.
      */
-    declaracaoDeVariaveisPotigol(primeiroIdentificador) {
+    async declaracaoDeVariaveisPotigol(primeiroIdentificador) {
         const identificadores = [];
         let simboloVar;
         // Se houver primeiro identificador definido (reatribuição),
@@ -625,7 +624,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         this.consumir(lexico_regular_1.default.REATRIBUIR, "Esperado ':=' após identificador em instrução 'var'.");
         const inicializadores = [];
         do {
-            inicializadores.push(this.expressao());
+            inicializadores.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(simboloVar, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
@@ -638,7 +637,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         }
         return retorno;
     }
-    logicaAtribuicaoComDicaDeTipo(expressao) {
+    logicaAtribuicaoComDicaDeTipo() {
         // A dica de tipo é opcional.
         // Só que, se a avaliação entra na dica, só
         // podemos ter uma constante apenas.
@@ -659,9 +658,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * Em Potigol, `escreva` aceita apenas um argumento.
      * @returns Uma declaração `Escreva`.
      */
-    declaracaoEscreva() {
+    async declaracaoEscreva() {
         const simboloAtual = this.avancarEDevolverAnterior();
-        const argumento = this.ou();
+        const argumento = await this.ou();
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, [argumento]);
     }
     /**
@@ -670,9 +669,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * o resultado na saída na mesma linha.
      * @see https://potigol.github.io/docs/basico/entrada_saida.html
      */
-    declaracaoImprima() {
+    async declaracaoImprima() {
         const simboloAtual = this.avancarEDevolverAnterior();
-        const argumento = this.ou();
+        const argumento = await this.ou();
         return new declaracoes_1.EscrevaMesmaLinha(Number(simboloAtual.linha), simboloAtual.hashArquivo, [argumento]);
     }
     /**
@@ -685,11 +684,11 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * - Em uma declaração `para`.
      * @returns Um vetor de `Declaracao`.
      */
-    blocoEscopo() {
+    async blocoEscopo() {
         let declaracoes = [];
         this.pilhaEscoposVariaveisConhecidas.empilhar([]);
         while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(lexico_regular_1.default.FIM)) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
@@ -700,44 +699,44 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         this.pilhaEscoposVariaveisConhecidas.removerUltimo();
         return declaracoes;
     }
-    declaracaoSe() {
+    async declaracaoSe() {
         const simboloSe = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
+        const condicao = await this.expressao();
         this.consumir(lexico_regular_1.default.ENTAO, "Esperado palavra reservada 'entao' após condição em declaração 'se'.");
         const declaracoes = [];
         do {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            declaracoes.push(await this.resolverDeclaracaoForaDeBloco());
         } while (![lexico_regular_1.default.SENAO, lexico_regular_1.default.FIM].includes(this.simbolos[this.atual].tipo));
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.SENAO)) {
             const simboloSenao = this.simbolos[this.atual - 1];
             const declaracoesSenao = [];
             do {
-                declaracoesSenao.push(this.resolverDeclaracaoForaDeBloco());
+                declaracoesSenao.push(await this.resolverDeclaracaoForaDeBloco());
             } while (![lexico_regular_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(lexico_regular_1.default.FIM, "Esperado palavra-chave 'fim' 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);
     }
-    declaracaoEnquanto() {
+    async declaracaoEnquanto() {
         const simboloAtual = this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
+        const condicao = await this.expressao();
         this.consumir(lexico_regular_1.default.FACA, "Esperado paravra reservada 'faca' após condição de continuidade em declaracão 'enquanto'.");
         const declaracoes = [];
         do {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            declaracoes.push(await this.resolverDeclaracaoForaDeBloco());
         } while (![lexico_regular_1.default.FIM].includes(this.simbolos[this.atual].tipo));
         this.consumir(lexico_regular_1.default.FIM, "Esperado palavra-chave 'fim' para fechamento de declaração 'enquanto'.");
         return new declaracoes_1.Enquanto(condicao, new declaracoes_1.Bloco(simboloAtual.hashArquivo, Number(simboloAtual.linha), declaracoes.filter((d) => d)));
     }
-    declaracaoPara() {
+    async declaracaoPara() {
         const simboloPara = this.avancarEDevolverAnterior();
         const variavelIteracao = this.consumir(lexico_regular_1.default.IDENTIFICADOR, "Esperado identificador de variável após 'para'.");
         this.consumir(lexico_regular_1.default.DE, "Esperado palavra reservada 'de' após variável de controle de 'para'.");
-        const literalOuVariavelInicio = this.adicaoOuSubtracao();
+        const literalOuVariavelInicio = await this.adicaoOuSubtracao();
         this.consumir(lexico_regular_1.default.ATE, "Esperado palavra reservada 'ate' após valor inicial do laço de repetição 'para'.");
-        const literalOuVariavelFim = this.adicaoOuSubtracao();
+        const literalOuVariavelFim = await this.adicaoOuSubtracao();
         let operadorCondicao = new lexador_1.Simbolo(lexico_regular_1.default.MENOR_IGUAL, '<=', null, Number(simboloPara.linha), this.hashArquivo);
         let operadorCondicaoIncremento = new lexador_1.Simbolo(lexico_regular_1.default.MENOR, '<', null, Number(simboloPara.linha), this.hashArquivo);
         // Isso existe porque o laço `para` do Potigol pode ter o passo positivo ou negativo
@@ -748,7 +747,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         let passo;
         let resolverIncrementoEmExecucao = false;
         if (this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.PASSO)) {
-            passo = this.unario();
+            passo = await this.unario();
         }
         else {
             if (literalOuVariavelInicio instanceof construtos_1.Literal && literalOuVariavelFim instanceof construtos_1.Literal) {
@@ -773,7 +772,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         const declaracoesBlocoPara = [];
         let simboloAtualBlocoPara = this.simbolos[this.atual];
         while (simboloAtualBlocoPara.tipo !== lexico_regular_1.default.FIM) {
-            declaracoesBlocoPara.push(this.resolverDeclaracaoForaDeBloco());
+            declaracoesBlocoPara.push(await this.resolverDeclaracaoForaDeBloco());
             simboloAtualBlocoPara = this.simbolos[this.atual];
         }
         this.consumir(lexico_regular_1.default.FIM, '');
@@ -783,9 +782,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         para.resolverIncrementoEmExecucao = resolverIncrementoEmExecucao;
         return para;
     }
-    declaracaoEscolha() {
+    async declaracaoEscolha() {
         this.avancarEDevolverAnterior();
-        const condicao = this.expressao();
+        const condicao = await this.expressao();
         const caminhos = [];
         let caminhoPadrao = null;
         while (!this.verificarSeSimboloAtualEIgualA(lexico_regular_1.default.FIM)) {
@@ -798,7 +797,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                     throw excecao;
                 }
                 this.consumir(lexico_regular_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
-                const declaracoesPadrao = [this.resolverDeclaracaoForaDeBloco()];
+                const declaracoesPadrao = [await this.resolverDeclaracaoForaDeBloco()];
                 // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
                 /* const declaracoesPadrao = [];
                 do {
@@ -809,9 +808,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 };
                 continue;
             }
-            const caminhoCondicoes = [this.expressao()];
+            const caminhoCondicoes = [await this.expressao()];
             this.consumir(lexico_regular_1.default.SETA, "Esperado '=>' após palavra reservada 'caso'.");
-            const declaracoes = [this.resolverDeclaracaoForaDeBloco()];
+            const declaracoes = [await this.resolverDeclaracaoForaDeBloco()];
             // TODO: Verificar se Potigol admite bloco de escopo para `escolha`.
             /* const declaracoes = [];
             do {
@@ -833,9 +832,9 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      *
      * @returns Um construto do tipo `Classe`.
      */
-    declaracaoTipo() {
+    async declaracaoTipo() {
         const simboloTipo = this.avancarEDevolverAnterior();
-        const construto = this.primario();
+        const construto = await this.primario();
         // TODO: Verificar se Potigol trabalha com herança.
         /* let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.HERDA)) {
@@ -844,12 +843,12 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         } */
         const metodos = [];
         const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(lexico_regular_1.default.FIM) && !this.estaNoFinal()) {
+        while (!this.estaNoFinal() && !this.verificarTipoSimboloAtual(lexico_regular_1.default.FIM)) {
             const identificador = this.consumir(lexico_regular_1.default.IDENTIFICADOR, 'Esperado nome de propriedade ou método.');
             if (this.simbolos[this.atual].tipo === lexico_regular_1.default.PARENTESE_ESQUERDO) {
                 // Método
                 const construtoMetodo = new construtos_1.Constante(identificador.hashArquivo, identificador);
-                metodos.push(this.declaracaoDeFuncaoOuMetodo(construtoMetodo));
+                metodos.push(await this.declaracaoDeFuncaoOuMetodo(construtoMetodo));
             }
             else {
                 // Propriedade
@@ -875,23 +874,23 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         metodos.unshift(construtor);
         return new declaracoes_1.Classe(construto.simbolo, undefined, metodos, propriedades);
     }
-    atribuir() {
-        const expressao = this.ou();
+    async atribuir() {
+        const expressao = await this.ou();
         if (!this.estaNoFinal()) {
             let tipoVariavelOuConstante;
             if (expressao instanceof construtos_1.Constante) {
                 // Atribuição constante.
                 let tipoExplicito = false;
                 if (this.simbolos[this.atual].tipo === lexico_regular_1.default.DOIS_PONTOS) {
-                    tipoVariavelOuConstante = this.logicaAtribuicaoComDicaDeTipo(expressao);
+                    tipoVariavelOuConstante = this.logicaAtribuicaoComDicaDeTipo();
                     tipoExplicito = true;
                 }
                 switch (this.simbolos[this.atual].tipo) {
                     case lexico_regular_1.default.VIRGULA:
-                        return this.declaracaoDeConstantes(expressao);
+                        return await this.declaracaoDeConstantes(expressao);
                     case lexico_regular_1.default.IGUAL:
                         this.avancarEDevolverAnterior();
-                        const valorAtribuicao = this.ou();
+                        const valorAtribuicao = await this.ou();
                         return new declaracoes_1.Const(expressao.simbolo, valorAtribuicao, tipoVariavelOuConstante
                             ? this.tiposPotigolParaDelegua[tipoVariavelOuConstante.lexema]
                             : undefined, tipoExplicito);
@@ -901,10 +900,10 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 // Reatribuição de variável.
                 switch (this.simbolos[this.atual].tipo) {
                     case lexico_regular_1.default.VIRGULA:
-                        return this.declaracaoDeVariaveisPotigol(expressao);
+                        return await this.declaracaoDeVariaveisPotigol(expressao);
                     case lexico_regular_1.default.REATRIBUIR:
                         this.avancarEDevolverAnterior();
-                        const valorAtribuicao = this.ou();
+                        const valorAtribuicao = await this.ou();
                         return new declaracoes_2.ReatribuicaoVariavel(expressao.simbolo, valorAtribuicao, tipoVariavelOuConstante
                             ? this.tiposPotigolParaDelegua[tipoVariavelOuConstante.lexema]
                             : undefined);
@@ -918,7 +917,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * São eles: `leia_inteiro`, `leia_inteiros`, `leia_real`, `leia_reais`, `leia_texto` e
      * `leia_textos`.
      */
-    expressaoLeia() {
+    async expressaoLeia() {
         throw new Error('Método não implementado.');
     }
     /**
@@ -934,17 +933,17 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
      * Se o próximo símbolo for parênteses, ou é uma definiçao de função,
      * ou uma chamada de função.
      */
-    expressaoOuDefinicaoFuncao() {
+    async expressaoOuDefinicaoFuncao() {
         if (!this.estaNoFinal() && this.simbolos[this.atual].tipo === lexico_regular_1.default.IDENTIFICADOR) {
             if (this.atual + 1 < this.simbolos.length) {
                 switch (this.simbolos[this.atual + 1].tipo) {
                     case lexico_regular_1.default.PARENTESE_ESQUERDO:
-                        const construtoPrimario = this.primario();
+                        const construtoPrimario = await this.primario();
                         return this.declaracaoDeFuncaoOuMetodo(construtoPrimario);
                 }
             }
         }
-        return this.atribuir();
+        return await this.atribuir();
     }
     resolverDeclaracaoForaDeBloco() {
         const simboloAtual = this.simbolos[this.atual];
@@ -973,7 +972,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
                 return this.expressaoOuDefinicaoFuncao();
         }
     }
-    analisar(retornoLexador, hashArquivo) {
+    async analisar(retornoLexador, hashArquivo) {
         this.microAvaliadorSintatico = new micro_avaliador_sintatico_potigol_1.MicroAvaliadorSintaticoPotigol(hashArquivo);
         this.erros = [];
         this.atual = 0;
@@ -984,7 +983,7 @@ class AvaliadorSintaticoPotigol extends avaliador_sintatico_base_1.AvaliadorSint
         this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
         this.declaracoes = [];
         while (!this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 this.declaracoes = this.declaracoes.concat(retornoDeclaracao);
             }