@designliquido/delegua 0.73.0 → 1.0.0

package/avaliador-sintatico/avaliador-sintatico.js

@@ -91,9 +91,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return tipoElementarResolvido;
     }
-    construtoAjuda() {
+    async construtoAjuda() {
         const simboloAjuda = this.avancarEDevolverAnterior();
-        if (this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
+        if (this.estaNoFinal() || this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
             return new construtos_1.AjudaComoConstruto(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, false);
         }
         this.avancarEDevolverAnterior(); // parêntese esquerdo
@@ -102,18 +102,18 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             return new construtos_1.AjudaComoConstruto(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, true);
         }
         this.emAjuda = true;
-        const expressaoAjuda = this.expressao();
+        const expressaoAjuda = await this.expressao();
         this.emAjuda = false;
         this.consumir(delegua_2.default.PARENTESE_DIREITO, `Esperado parêntese direito após expressão usada como argumento em ajuda(). Atual: ${this.simbolos[this.atual].lexema}.`);
         return new construtos_1.AjudaComoConstruto(simboloAjuda.hashArquivo, simboloAjuda.linha, expressaoAjuda);
     }
-    obterChaveDicionario() {
+    async obterChaveDicionario() {
         switch (this.simbolos[this.atual].tipo) {
             case delegua_2.default.NUMERO:
             case delegua_2.default.TEXTO:
             case delegua_2.default.FALSO:
             case delegua_2.default.VERDADEIRO:
-                return this.primario();
+                return await this.primario();
             case delegua_2.default.IDENTIFICADOR:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 let tipoOperando;
@@ -130,14 +130,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             case delegua_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
-                    return this.construtoTupla();
+                    return await this.construtoTupla();
                 }
                 throw this.erro(this.simbolos[this.atual], `Esperado parêntese esquerdo após colchete esquerdo para definição de chave de dicionário. Atual: ${this.simbolos[this.atual].tipo}.`);
             default:
                 throw this.erro(this.simbolos[this.atual], `Símbolo ${this.simbolos[this.atual].tipo} inesperado ou inválido como chave de dicionário.`);
         }
     }
-    construtoDicionario(simboloChaveEsquerda) {
+    async construtoDicionario(simboloChaveEsquerda) {
         this.avancarEDevolverAnterior();
         const chaves = [];
         const valores = [];
@@ -145,9 +145,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             return new construtos_1.Dicionario(this.hashArquivo, Number(simboloChaveEsquerda.linha), [], []);
         }
         while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
-            const chave = this.obterChaveDicionario();
+            const chave = await this.obterChaveDicionario();
             this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
-            const valor = this.atribuir();
+            const valor = await this.atribuir();
             chaves.push(chave);
             valores.push(valor);
             if (this.simbolos[this.atual].tipo !== delegua_2.default.CHAVE_DIREITA) {
@@ -156,68 +156,72 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return new construtos_1.Dicionario(this.hashArquivo, Number(simboloChaveEsquerda.linha), chaves, valores);
     }
-    construtoImportar() {
+    /**
+     * `delegua-node` e a extensão para VSCode precisam que este método seja assíncrono.
+     * @returns
+     */
+    async construtoImportar() {
         this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
-        const caminho = this.expressao();
+        const caminho = await this.expressao();
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
-        return new construtos_1.ImportarComoConstruto(caminho);
+        return Promise.resolve(new construtos_1.ImportarComoConstruto(caminho));
     }
-    construtoTupla() {
-        const expressao = this.expressao();
+    async construtoTupla() {
+        const expressao = await this.expressao();
         const argumentos = [expressao];
         while (this.simbolos[this.atual].tipo === delegua_2.default.VIRGULA) {
             this.avancarEDevolverAnterior();
-            argumentos.push(this.expressao());
+            argumentos.push(await this.expressao());
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
         this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
         return new tuplas_1.SeletorTuplas(...argumentos);
     }
-    enquantoComoConstruto() {
-        const { condicao, corpo } = this.logicaComumEnquanto();
+    async enquantoComoConstruto() {
+        const { condicao, corpo } = await this.logicaComumEnquanto();
         return new construtos_1.EnquantoComoConstruto(condicao, corpo);
     }
-    fazerComoConstruto(simboloFazer) {
+    async fazerComoConstruto(simboloFazer) {
         try {
             this.blocos += 1;
-            const { caminhoFazer, condicaoEnquanto } = this.logicaComumFazer();
+            const { caminhoFazer, condicaoEnquanto } = await this.logicaComumFazer();
             return new construtos_1.FazerComoConstruto(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    paraCadaComoConstrutoVetor(simboloPara) {
-        const { variavelIteracao, vetor, corpo } = this.logicaComumParaCadaVetor(simboloPara);
+    async paraCadaComoConstrutoVetor(simboloPara) {
+        const { variavelIteracao, vetor, corpo } = await this.logicaComumParaCadaVetor(simboloPara);
         return new construtos_1.ParaCadaComoConstruto(this.hashArquivo, Number(simboloPara.linha), variavelIteracao, vetor, corpo);
     }
-    paraCadaComoConstrutoDicionario(simboloPara) {
-        const { nomeVariavelChave, nomeVariavelValor, dicionario, corpo } = this.logicaParaCadaDicionario(simboloPara);
+    async paraCadaComoConstrutoDicionario(simboloPara) {
+        const { nomeVariavelChave, nomeVariavelValor, dicionario, corpo } = await this.logicaParaCadaDicionario(simboloPara);
         return new construtos_1.ParaCadaComoConstruto(this.hashArquivo, Number(simboloPara.linha), new tuplas_1.Dupla(new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), nomeVariavelChave.lexema), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), nomeVariavelValor.lexema)), dicionario, corpo);
     }
-    paraCadaComoConstruto(simboloPara) {
+    async paraCadaComoConstruto(simboloPara) {
         if (this.verificarTipoSimboloAtual(delegua_2.default.IDENTIFICADOR)) {
-            return this.paraCadaComoConstrutoVetor(simboloPara);
+            return await this.paraCadaComoConstrutoVetor(simboloPara);
         }
         if (this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA)) {
-            return this.paraCadaComoConstrutoDicionario(simboloPara);
+            return await this.paraCadaComoConstrutoDicionario(simboloPara);
         }
         throw this.erro(simboloPara, 'Identificador de iteração deve ser ou um par chave-valor, ou um nome de variável.');
     }
-    paraTradicionalComoConstruto(simboloPara) {
-        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara();
+    async paraTradicionalComoConstruto(simboloPara) {
+        const { inicializador, condicao, incrementar, corpo } = await this.logicaComumPara();
         return new construtos_1.ParaComoConstruto(simboloPara.hashArquivo, simboloPara.linha, inicializador, condicao, incrementar, corpo);
     }
     /**
      * Método que resolve `para` ou `para cada` como construto.
      */
-    paraComoConstruto(simboloPara) {
+    async paraComoConstruto(simboloPara) {
         try {
             this.blocos += 1;
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CADA)) {
-                return this.paraCadaComoConstruto(simboloPara);
+                return await this.paraCadaComoConstruto(simboloPara);
             }
-            return this.paraTradicionalComoConstruto(simboloPara);
+            return await this.paraTradicionalComoConstruto(simboloPara);
         }
         finally {
             this.blocos -= 1;
@@ -227,7 +231,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * Resolve uma lista de compreensão.
      * @returns {ListaCompreensao} A lista de compreensão resolvida.
      */
-    resolverCompreensaoDeLista(retornoExpressao) {
+    async resolverCompreensaoDeLista(retornoExpressao) {
         this.consumir(delegua_2.default.PARA, "Esperado instrução 'para' após identificado.");
         this.consumir(delegua_2.default.CADA, "Esperado instrução 'cada' após 'para'.");
         const simboloVariavelIteracao = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de variável após 'para cada'.");
@@ -235,10 +239,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução em lista de compreensão.");
         }
         const localizacaoVetor = this.simboloAnterior();
-        const vetor = this.ou();
+        const vetor = await this.ou();
         let condicao = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SE)) {
-            condicao = this.expressao();
+            condicao = await this.expressao();
         }
         else {
             condicao = new construtos_1.Literal(this.hashArquivo, Number(localizacaoVetor.linha), true);
@@ -256,14 +260,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         ])), 'qualquer[]' // TODO: Talvez um dia inferir o tipo aqui.
         );
     }
-    primario() {
+    async primario() {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
             case delegua_2.default.AJUDA:
-                return this.construtoAjuda();
+                return await this.construtoAjuda();
             case delegua_2.default.CHAVE_ESQUERDA:
-                return this.construtoDicionario(simboloAtual);
+                return await this.construtoDicionario(simboloAtual);
             case delegua_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 valores = [];
@@ -276,10 +280,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 // Ao resolver a expressão aqui, identificadores dentro da expressão de compreensão 
                 // de lista serão tratados como 'qualquer', para evitar erros de tipo.
                 this.intuirTipoQualquerParaIdentificadores = true;
-                const retornoExpressaoOuPrimeiroValor = this.seTernario();
+                const retornoExpressaoOuPrimeiroValor = await this.seTernario();
                 this.intuirTipoQualquerParaIdentificadores = false;
                 if (this.simbolos[this.atual].tipo === delegua_2.default.PARA) {
-                    return this.resolverCompreensaoDeLista(retornoExpressaoOuPrimeiroValor);
+                    return await this.resolverCompreensaoDeLista(retornoExpressaoOuPrimeiroValor);
                 }
                 // Aqui já sabemos que não é uma compreensão de lista.
                 valores.push(retornoExpressaoOuPrimeiroValor);
@@ -294,7 +298,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             valores.push(new construtos_1.ComentarioComoConstruto(simboloComentario));
                             break;
                         default:
-                            const valor = this.seTernario();
+                            const valor = await this.seTernario();
                             valores.push(valor);
                             break;
                     }
@@ -321,7 +325,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores, valores.length, tipoVetor);
             case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
-                return this.enquantoComoConstruto();
+                return await this.enquantoComoConstruto();
             case delegua_2.default.EXPRESSAO_REGULAR:
                 let valor = '';
                 let linhaAtual = this.simbolos[this.atual].linha;
@@ -342,11 +346,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false, 'lógico');
             case delegua_2.default.FAZER:
                 const simboloFazer = this.avancarEDevolverAnterior();
-                return this.fazerComoConstruto(simboloFazer);
+                return await this.fazerComoConstruto(simboloFazer);
             case delegua_2.default.FUNCAO:
             case delegua_2.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 delegua_2.default.IDENTIFICADOR:
@@ -381,12 +385,12 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando || 'qualquer');
             case delegua_2.default.IMPORTAR:
                 this.avancarEDevolverAnterior();
-                return this.construtoImportar();
+                return await this.construtoImportar();
             case delegua_2.default.ISTO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
             case delegua_2.default.LEIA:
-                return this.expressaoLeia();
+                return await this.expressaoLeia();
             case delegua_2.default.NULO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null, 'nulo');
@@ -399,10 +403,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal, tipoDadosElementar);
             case delegua_2.default.PARA:
                 const simboloPara = this.avancarEDevolverAnterior();
-                return this.paraComoConstruto(simboloPara);
+                return await this.paraComoConstruto(simboloPara);
             case delegua_2.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
-                const expressao = this.expressao();
+                const expressao = await this.expressao();
                 this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
                 return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
             case delegua_2.default.SUPER:
@@ -422,7 +426,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     construto = new construtos_1.ComponenteLinguagem(this.hashArquivo, this.simboloAnterior());
                 }
                 else {
-                    construto = this.expressao();
+                    construto = await this.expressao();
                 }
                 if (construto.constructor === construtos_1.AcessoMetodoOuPropriedade) {
                     const construtoTipado = construto;
@@ -479,6 +483,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
                 return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, construto);
         }
+        // TODO: O correto seria emitir algum aviso aqui que este avaliador sintático não consegue 
+        // lidar com tópicos de ajuda neste ponto.
         if (this.emAjuda) {
             console.log(this.simbolos[this.atual]);
         }
@@ -515,15 +521,15 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return tipoAcesso;
     }
-    resolverCadeiaChamadas(expressaoAnterior, tipoAnterior = 'qualquer') {
+    async resolverCadeiaChamadas(expressaoAnterior, tipoAnterior = 'qualquer') {
         if (!this.simbolos[this.atual]) {
             return expressaoAnterior;
         }
         switch (this.simbolos[this.atual].tipo) {
             case delegua_2.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
-                const chamada = this.finalizarChamada(expressaoAnterior, tipoAnterior);
-                return this.resolverCadeiaChamadas(chamada);
+                const chamada = await this.finalizarChamada(expressaoAnterior, tipoAnterior);
+                return await this.resolverCadeiaChamadas(chamada);
             case delegua_2.default.PONTO:
                 this.avancarEDevolverAnterior();
                 this.verificarSeSimboloAtualEIgualA();
@@ -541,21 +547,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     }
                 }
                 const acesso = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressaoAnterior, nome, tipoInferido);
-                return this.resolverCadeiaChamadas(acesso, tipoInferido);
+                return await this.resolverCadeiaChamadas(acesso, tipoInferido);
             case delegua_2.default.COLCHETE_ESQUERDO:
                 const tipoAcesso = this.resolverTipoAcessoIndiceVariavel(expressaoAnterior);
                 this.avancarEDevolverAnterior();
-                const indice = this.expressao();
+                const indice = await this.expressao();
                 const simboloFechamento = this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 const acessoVariavel = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressaoAnterior, indice, simboloFechamento, tipoAcesso);
-                return this.resolverCadeiaChamadas(acessoVariavel);
+                return await this.resolverCadeiaChamadas(acessoVariavel);
             default:
                 return expressaoAnterior;
         }
     }
-    chamar() {
-        let expressao = this.primario();
-        return this.resolverCadeiaChamadas(expressao);
+    async chamar() {
+        let expressao = await this.primario();
+        return await this.resolverCadeiaChamadas(expressao);
     }
     /**
      * `AcessoMetodoOuPropriedade` é um construto intermediário em Delégua, e deve ser resolvido como outro
@@ -699,7 +705,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return entidadeChamada;
     }
-    finalizarChamada(entidadeChamada, tipoPrimitiva = undefined) {
+    async finalizarChamada(entidadeChamada, tipoPrimitiva = undefined) {
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
@@ -707,7 +713,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 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(delegua_2.default.VIRGULA));
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
@@ -720,24 +726,24 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         construtoChamada.tipo = 'qualquer';
         return construtoChamada;
     }
-    unario() {
+    async unario() {
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NAO, delegua_2.default.NEGACAO, delegua_2.default.ADICAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.unario();
+            const direito = await this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
         }
-        return this.chamar();
+        return await this.chamar();
     }
     /**
      * A exponenciacão é uma exceção na ordem de avaliação (resolve primeiro à direita).
      * Por isso `direito` chama `exponenciacao()`, e não `unario()`.
      * @returns {Binario} A expressão binária na forma do construto `Binario`.
      */
-    exponenciacao() {
-        let expressao = this.unario();
+    async exponenciacao() {
+        let expressao = await this.unario();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EXPONENCIACAO)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.exponenciacao();
+            const direito = await this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
@@ -789,11 +795,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             }
         }
     }
-    multiplicar() {
-        let expressao = this.exponenciacao();
+    async multiplicar() {
+        let expressao = await this.exponenciacao();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DIVISAO, delegua_2.default.DIVISAO_IGUAL, delegua_2.default.DIVISAO_INTEIRA, delegua_2.default.DIVISAO_INTEIRA_IGUAL, delegua_2.default.MODULO, delegua_2.default.MODULO_IGUAL, delegua_2.default.MULTIPLICACAO, delegua_2.default.MULTIPLICACAO_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.exponenciacao();
+            const direito = await this.exponenciacao();
             this.verificacaoOperacoesBinariasIlegais(expressao, direito, operador);
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
@@ -804,68 +810,68 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * ser avaliado pelo Interpretador.
      * @returns Um Construto, normalmente um `Binario`, ou `Unario` se houver alguma operação unária para ser avaliada.
      */
-    adicaoOuSubtracao() {
-        let expressao = this.multiplicar();
+    async adicaoOuSubtracao() {
+        let expressao = await this.multiplicar();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SUBTRACAO, delegua_2.default.ADICAO, delegua_2.default.MENOS_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.multiplicar();
+            const direito = await this.multiplicar();
             this.verificacaoOperacoesBinariasIlegais(expressao, direito, operador);
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MAIS_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.atribuir();
+            const direito = await this.ou();
             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(delegua_2.default.MENOR_MENOR, delegua_2.default.MAIOR_MAIOR)) {
             const operador = this.simbolos[this.atual - 1];
-            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(delegua_2.default.BIT_AND)) {
             const operador = this.simbolos[this.atual - 1];
-            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(delegua_2.default.BIT_OR, delegua_2.default.BIT_XOR)) {
             const operador = this.simbolos[this.atual - 1];
-            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(delegua_2.default.MAIOR, delegua_2.default.MAIOR_IGUAL, delegua_2.default.MENOR, delegua_2.default.MENOR_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
-            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(delegua_2.default.DIFERENTE, delegua_2.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;
     }
-    em() {
-        let expressao = this.comparacaoIgualdade();
+    async em() {
+        let expressao = await this.comparacaoIgualdade();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EM, delegua_2.default.CONTEM, delegua_2.default.NAO)) {
             let operador = this.simbolos[this.atual - 1];
             let negado = false;
@@ -873,36 +879,36 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 operador = this.consumir(delegua_2.default.CONTEM, `Esperado palavra reservada 'contém' ou 'contem' após palavra reservada ${operador.lexema}.`);
                 negado = true;
             }
-            const direito = this.comparacaoIgualdade();
+            const direito = await this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
             expressao.negado = negado;
         }
         return expressao;
     }
-    e() {
-        let expressao = this.em();
+    async e() {
+        let expressao = await this.em();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.E)) {
             const operador = this.simbolos[this.atual - 1];
-            const direito = this.em();
+            const direito = await this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    elvis() {
-        let expressao = this.ou();
+    async elvis() {
+        let expressao = await this.ou();
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ELVIS)) {
-            const direito = this.ou();
+            const direito = await this.ou();
             return new construtos_1.Elvis(this.hashArquivo, expressao, direito);
         }
         return expressao;
     }
-    seTernario() {
-        let expressaoOuCondicao = this.elvis();
+    async seTernario() {
+        let expressaoOuCondicao = await this.elvis();
         while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.INTERROGACAO)) {
             const operador = this.simbolos[this.atual - 1];
-            const expressaoEntao = this.seTernario();
+            const expressaoEntao = await this.seTernario();
             this.consumir(delegua_2.default.DOIS_PONTOS, `Esperado dois-pontos após caminho positivo em se ternário. Atual: ${this.simbolos[this.atual].lexema}.`);
-            const expressaoSenao = this.seTernario();
+            const expressaoSenao = await this.seTernario();
             expressaoOuCondicao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
         }
         return expressaoOuCondicao;
@@ -911,8 +917,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * Método que resolve atribuições.
      * @returns Um construto do tipo `Atribuir`, `Conjunto` ou `AtribuicaoPorIndice`.
      */
-    atribuir() {
-        const expressao = this.seTernario();
+    async atribuir() {
+        const expressao = await this.seTernario();
         if (expressao instanceof construtos_1.Binario &&
             [
                 delegua_2.default.MAIS_IGUAL,
@@ -928,9 +934,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             }
             return new construtos_1.Atribuir(this.hashArquivo, expressao.esquerda, expressao, undefined, expressao.operador);
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
             const igual = this.simbolos[this.atual - 1];
-            const valor = this.seTernario();
+            const valor = await this.seTernario();
             switch (expressao.constructor) {
                 case construtos_1.Variavel:
                     return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
@@ -949,7 +955,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * Declaração para comando `leia`, para ler dados de entrada do usuário.
      * @returns Um objeto da classe `Leia`.
      */
-    expressaoLeia() {
+    async expressaoLeia() {
         const simboloLeia = this.avancarEDevolverAnterior();
         if (this.emAjuda && this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
             return new construtos_1.Leia(simboloLeia, []);
@@ -958,22 +964,22 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const argumentos = [];
         if (this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_DIREITO) {
             do {
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos em instrução `leia`.");
         return new construtos_1.Leia(simboloLeia, argumentos);
     }
     // TODO: Depreciar.
-    expressao() {
-        return this.atribuir();
+    async expressao() {
+        return await this.atribuir();
     }
-    blocoEscopo() {
+    async blocoEscopo() {
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
         let declaracoes = [];
         while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
             !this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
@@ -1007,45 +1013,45 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Continua(this.simbolos[this.atual - 1]);
     }
-    logicaComumEnquanto() {
-        const condicao = this.expressao();
+    async logicaComumEnquanto() {
+        const condicao = await this.expressao();
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = this.resolverDeclaracao();
+        const corpo = await this.resolverDeclaracao();
         return {
             condicao,
             corpo,
         };
     }
-    declaracaoEnquanto() {
+    async declaracaoEnquanto() {
         try {
             this.blocos += 1;
-            const { condicao, corpo } = this.logicaComumEnquanto();
+            const { condicao, corpo } = await this.logicaComumEnquanto();
             return new declaracoes_1.Enquanto(condicao, corpo);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    declaracaoEscolha() {
+    async declaracaoEscolha() {
         try {
             this.blocos += 1;
-            const condicao = this.expressao();
+            const condicao = await this.expressao();
             this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
             const caminhos = [];
             let caminhoPadrao = null;
             while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA) &&
                 !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CASO)) {
-                    const caminhoCondicoes = [this.expressao()];
+                    const caminhoCondicoes = [await this.expressao()];
                     this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
                     while (this.verificarTipoSimboloAtual(delegua_2.default.CASO)) {
                         this.consumir(delegua_2.default.CASO, null);
-                        caminhoCondicoes.push(this.expressao());
+                        caminhoCondicoes.push(await this.expressao());
                         this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
                     let declaracoes = [];
                     do {
-                        const retornoDeclaracao = this.resolverDeclaracao();
+                        const retornoDeclaracao = await this.resolverDeclaracao();
                         if (Array.isArray(retornoDeclaracao)) {
                             declaracoes = declaracoes.concat(retornoDeclaracao);
                         }
@@ -1069,7 +1075,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
                     const declaracoes = [];
                     do {
-                        declaracoes.push(this.resolverDeclaracao());
+                        declaracoes.push(await this.resolverDeclaracao());
                     } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
                         !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
                         !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
@@ -1084,13 +1090,13 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.blocos -= 1;
         }
     }
-    declaracaoEscreva() {
+    async declaracaoEscreva() {
         const simboloAtual = this.simbolos[this.atual];
         this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
@@ -1098,33 +1104,34 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
-    declaracaoExpressao() {
+    async declaracaoExpressao() {
         // Se há decoradores a serem adicionados aqui, obtemo-los agora,
         // para evitar que outros passos recursivos peguem-los antes.
         const decoradores = Array.from(this.pilhaDecoradores);
         this.pilhaDecoradores = [];
-        const expressao = this.expressao();
+        const expressao = await this.expressao();
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Expressao(expressao, decoradores);
     }
-    declaracaoFalhar() {
+    async declaracaoFalhar() {
         const simboloFalha = this.simbolos[this.atual - 1];
-        return new declaracoes_1.Falhar(simboloFalha, this.declaracaoExpressao().expressao);
+        const expressaoFalha = await this.expressao();
+        return new declaracoes_1.Falhar(simboloFalha, expressaoFalha);
     }
-    logicaComumFazer() {
-        const caminhoFazer = this.resolverDeclaracao();
+    async logicaComumFazer() {
+        const caminhoFazer = await this.resolverDeclaracao();
         this.consumir(delegua_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
-        const condicaoEnquanto = this.expressao();
+        const condicaoEnquanto = await this.expressao();
         return {
             caminhoFazer,
             condicaoEnquanto,
         };
     }
-    declaracaoFazer(simboloFazer) {
+    async declaracaoFazer(simboloFazer) {
         try {
             this.blocos += 1;
-            const { caminhoFazer, condicaoEnquanto } = this.logicaComumFazer();
+            const { caminhoFazer, condicaoEnquanto } = await this.logicaComumFazer();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, // TODO: Aqui pode ser um `Bloco`?
             condicaoEnquanto);
         }
@@ -1178,20 +1185,20 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return importar;
     }
-    declaracaoPara() {
+    async declaracaoPara() {
         try {
             const simboloPara = this.simbolos[this.atual - 1];
             this.blocos += 1;
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CADA)) {
-                return this.declaracaoParaCada(simboloPara);
+                return await this.declaracaoParaCada(simboloPara);
             }
-            return this.declaracaoParaTradicional(simboloPara);
+            return await this.declaracaoParaTradicional(simboloPara);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    logicaParaCadaDicionario(simboloPara) {
+    async logicaParaCadaDicionario(simboloPara) {
         this.avancarEDevolverAnterior(); // chave esquerda
         const nomeVariavelChave = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de variável para chave de iteração, em instrução 'para cada'.");
         this.consumir(delegua_2.default.VIRGULA, "Esperado vírgula após nome de variável para chave de iteração, em instrução 'para cada'.");
@@ -1200,7 +1207,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.DE, delegua_2.default.EM)) {
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
         }
-        const dicionario = this.expressao();
+        const dicionario = await this.expressao();
         if (!dicionario.hasOwnProperty('tipo')) {
             throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece ser um dicionário.`);
         }
@@ -1211,7 +1218,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelChave.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelChave.lexema, 'qualquer'));
         this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelValor.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelValor.lexema, 'qualquer'));
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = this.resolverDeclaracao();
+        const corpo = await this.resolverDeclaracao();
         return {
             nomeVariavelChave,
             nomeVariavelValor,
@@ -1219,17 +1226,17 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             corpo,
         };
     }
-    declaracaoParaCadaDicionario(simboloPara) {
-        const { nomeVariavelChave, nomeVariavelValor, dicionario, corpo } = this.logicaParaCadaDicionario(simboloPara);
+    async declaracaoParaCadaDicionario(simboloPara) {
+        const { nomeVariavelChave, nomeVariavelValor, dicionario, corpo } = await this.logicaParaCadaDicionario(simboloPara);
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new tuplas_1.Dupla(new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), nomeVariavelChave.lexema), new construtos_1.Literal(this.hashArquivo, Number(simboloPara.linha), nomeVariavelValor.lexema)), dicionario, corpo);
     }
-    logicaComumParaCadaVetor(simboloPara) {
+    async logicaComumParaCadaVetor(simboloPara) {
         const nomeVariavelIteracao = this.avancarEDevolverAnterior();
         const variavelIteracao = new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao);
         if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.DE, delegua_2.default.EM)) {
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
         }
-        let vetorOuDicionario = this.expressao();
+        let vetorOuDicionario = await this.expressao();
         if (vetorOuDicionario.constructor === construtos_1.AcessoIndiceVariavel) {
             const construtoAcessoIndiceVariavel = vetorOuDicionario;
             if (construtoAcessoIndiceVariavel.entidadeChamada.tipo === 'dicionário') {
@@ -1250,57 +1257,57 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVariavelIteracao));
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = this.resolverDeclaracao();
+        const corpo = await this.resolverDeclaracao();
         return {
             variavelIteracao,
             vetor: vetorOuDicionario,
             corpo,
         };
     }
-    declaracaoParaCadaVetor(simboloPara) {
-        const { variavelIteracao, vetor, corpo } = this.logicaComumParaCadaVetor(simboloPara);
+    async declaracaoParaCadaVetor(simboloPara) {
+        const { variavelIteracao, vetor, corpo } = await this.logicaComumParaCadaVetor(simboloPara);
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), variavelIteracao, vetor, corpo);
     }
-    declaracaoParaCada(simboloPara) {
+    async declaracaoParaCada(simboloPara) {
         if (this.verificarTipoSimboloAtual(delegua_2.default.IDENTIFICADOR)) {
-            return this.declaracaoParaCadaVetor(simboloPara);
+            return await this.declaracaoParaCadaVetor(simboloPara);
         }
         if (this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA)) {
-            return this.declaracaoParaCadaDicionario(simboloPara);
+            return await this.declaracaoParaCadaDicionario(simboloPara);
         }
         throw this.erro(simboloPara, 'Identificador de iteração deve ser ou um par chave-valor, ou um nome de variável.');
     }
-    logicaComumPara() {
+    async logicaComumPara() {
         const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
         let inicializador;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA)) {
             inicializador = null;
         }
         else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VARIAVEL)) {
-            inicializador = this.declaracaoDeVariaveis();
+            inicializador = await this.declaracaoDeVariaveis();
         }
         else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CONSTANTE)) {
-            inicializador = this.declaracaoDeConstantes();
+            inicializador = await this.declaracaoDeConstantes();
         }
         else {
-            inicializador = this.declaracaoExpressao();
+            inicializador = await this.declaracaoExpressao();
         }
         let condicao = null;
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PONTO_E_VIRGULA)) {
-            condicao = this.expressao();
+            condicao = await this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         let incrementar = null;
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
-            incrementar = this.expressao();
+            incrementar = await this.expressao();
             this.verificarSeSimboloAtualEIgualA(delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR);
         }
         if (comParenteses) {
             this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas de inicialização, condição e incremento.");
         }
         // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
-        const corpo = this.resolverDeclaracao();
+        const corpo = await this.resolverDeclaracao();
         return {
             inicializador,
             condicao,
@@ -1308,11 +1315,11 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             corpo,
         };
     }
-    declaracaoParaTradicional(simboloPara) {
-        const { inicializador, condicao, incrementar, corpo } = this.logicaComumPara();
+    async declaracaoParaTradicional(simboloPara) {
+        const { inicializador, condicao, incrementar, corpo } = await this.logicaComumPara();
         return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
     }
-    declaracaoRetorna() {
+    async declaracaoRetorna() {
         const simboloChave = this.simbolos[this.atual - 1];
         let valor = null;
         if ([
@@ -1332,18 +1339,18 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             delegua_2.default.TEXTO,
             delegua_2.default.VERDADEIRO,
         ].includes(this.simbolos[this.atual].tipo)) {
-            valor = this.expressao();
+            valor = await this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Retorna(simboloChave, valor);
     }
-    declaracaoSe() {
-        const condicao = this.expressao();
-        const caminhoEntao = this.resolverDeclaracao();
+    async declaracaoSe() {
+        const condicao = await this.expressao();
+        const caminhoEntao = await this.resolverDeclaracao();
         let caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
-            caminhoSenao = this.resolverDeclaracao();
+            caminhoSenao = await this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
     }
@@ -1355,69 +1362,68 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Sustar(this.simbolos[this.atual - 1]);
     }
-    declaracaoTente() {
+    async declaracaoTente() {
         const simboloTente = this.simbolos[this.atual - 1];
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
-        const blocoTente = this.blocoEscopo();
+        const blocoTente = await this.blocoEscopo();
         let blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PEGUE)) {
             if (this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_ESQUERDO)) {
                 // Caso 1: com parâmetro de erro.
                 // `pegue` recebe um `FuncaoConstruto`.
-                blocoPegue = this.corpoDaFuncao('bloco `pegue`');
+                blocoPegue = await this.corpoDaFuncao('bloco `pegue`');
             }
             else {
                 // Caso 2: sem parâmetro de erro.
                 // `pegue` recebe um bloco.
                 this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
-                blocoPegue = this.blocoEscopo();
+                blocoPegue = await this.blocoEscopo();
             }
         }
         let blocoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
             this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'senão'.");
-            blocoSenao = this.blocoEscopo();
+            blocoSenao = await this.blocoEscopo();
         }
         let blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.FINALMENTE)) {
             this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'finalmente'.");
-            blocoFinalmente = this.blocoEscopo();
+            blocoFinalmente = await this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
     }
-    resolverDecorador() {
+    async resolverDecoradores() {
         while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
-            let nomeDecorador = '';
+            this.avancarEDevolverAnterior(); // Arroba
+            let nomeDecorador = '@';
             let linha;
             let parametros = [];
-            let parenteseEsquerdo = false;
-            linha = this.simbolos[this.atual].linha;
-            let simbolosLinhaAtual = this.simbolos.filter((l) => l.linha === linha);
-            for (let simbolo of simbolosLinhaAtual) {
-                parenteseEsquerdo = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
-                if (parenteseEsquerdo) {
-                    if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
-                        parametros = this.logicaComumParametros();
-                    }
-                    this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-                    break;
-                }
-                this.avancarEDevolverAnterior();
-                nomeDecorador += simbolo.lexema || '.';
-            }
             const atributos = {};
-            for (const parametro of parametros) {
-                if (parametro.nome.lexema in atributos) {
-                    throw this.erro(parametro.nome, `Atributo de decorador declarado duas ou mais vezes: ${parametro.nome.lexema}`);
+            const primeiraParteNomeDecorador = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de decorador após '@'.");
+            linha = Number(primeiraParteNomeDecorador.linha);
+            nomeDecorador += primeiraParteNomeDecorador.lexema;
+            while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO)) {
+                const parteNomeDecorador = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de decorador após '.'.");
+                nomeDecorador += '.' + parteNomeDecorador.lexema;
+            }
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
+                if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
+                    parametros = await this.logicaComumParametros();
                 }
-                atributos[parametro.nome.lexema] = parametro.valorPadrao;
+                for (const parametro of parametros) {
+                    if (parametro.nome.lexema in atributos) {
+                        throw this.erro(parametro.nome, `Atributo de decorador declarado duas ou mais vezes: ${parametro.nome.lexema}`);
+                    }
+                    atributos[parametro.nome.lexema] = parametro.valorPadrao;
+                }
+                this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após nome de decorador.");
             }
             this.pilhaDecoradores.push(new construtos_1.Decorador(this.hashArquivo, linha, nomeDecorador, atributos));
         }
     }
-    declaracaoTendoComo() {
+    async declaracaoTendoComo() {
         const simboloTendo = this.simbolos[this.atual - 1];
-        const expressaoInicializacao = this.expressao();
+        const expressaoInicializacao = await this.expressao();
         this.consumir(delegua_2.default.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
         const simboloNomeVariavel = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
@@ -1440,17 +1446,19 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 break;
         }
         this.pilhaEscopos.definirInformacoesVariavel(simboloNomeVariavel.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(simboloNomeVariavel.lexema, tipoInicializacao));
-        const blocoCorpo = this.blocoEscopo();
+        const blocoCorpo = await this.blocoEscopo();
         return new declaracoes_1.TendoComo(simboloTendo.linha, simboloTendo.hashArquivo, simboloNomeVariavel, expressaoInicializacao, new declaracoes_1.Bloco(simboloTendo.linha, simboloTendo.hashArquivo, blocoCorpo));
     }
-    declaracaoDesestruturacaoVariavel() {
+    async declaracaoDesestruturacaoVariavel() {
         const identificadores = [];
         do {
             identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
-        const inicializador = this.expressao();
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado igual ou seta esquerda após relação de propriedades da desestruturação.');
+        }
+        const inicializador = await this.expressao();
         const retornos = [];
         for (let identificador of identificadores) {
             this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, this.logicaComumInferenciaTiposVariaveisEConstantes(inicializador, 'qualquer')));
@@ -1559,7 +1567,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     resolverValorConstruto(construto) {
         if (construto instanceof construtos_1.Literal) {
-            return construto.valor;
+            return String(construto.valor);
         }
         throw this.erro({ hashArquivo: construto.hashArquivo, linha: construto.linha }, `Construto do tipo ${construto.constructor} não possui um mapeamento de valor.`);
     }
@@ -1587,13 +1595,13 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * Caso símbolo atual seja `var`, devolve uma declaração de variável.
      * @returns Um Construto do tipo Var.
      */
-    declaracaoDeVariaveis() {
+    async declaracaoDeVariaveis() {
         const simboloVariavel = this.simboloAnterior();
         const identificadores = [];
         const retorno = [];
         let tipo = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
-            return this.declaracaoDesestruturacaoVariavel();
+            return await this.declaracaoDesestruturacaoVariavel();
         }
         do {
             identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
@@ -1604,7 +1612,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             tipoExplicito = true;
             this.avancarEDevolverAnterior();
         }
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
             // Inicialização de variáveis sem valor.
             for (let identificador of identificadores.values()) {
                 this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
@@ -1616,7 +1624,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         const inicializadores = [];
         do {
-            inicializadores.push(this.expressao());
+            inicializadores.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(simboloVariavel, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
@@ -1636,14 +1644,16 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaDecoradores = [];
         return retorno;
     }
-    declaracaoDesestruturacaoConstante() {
+    async declaracaoDesestruturacaoConstante() {
         const identificadores = [];
         do {
             identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
-        const inicializador = this.expressao();
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
+            throw this.erro(this.simbolos[this.atual], 'Esperado igual ou seta esquerda após relação de propriedades da desestruturação.');
+        }
+        const inicializador = await this.expressao();
         const retornos = [];
         for (let identificador of identificadores) {
             // TODO: Melhorar dicionário para intuir o tipo de cada propriedade.
@@ -1658,12 +1668,12 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * Caso símbolo atual seja `const, constante ou fixo`, devolve uma declaração de const.
      * @returns Um Construto do tipo Const.
      */
-    declaracaoDeConstantes() {
+    async declaracaoDeConstantes() {
         const simboloConstante = this.simboloAnterior();
         const identificadores = [];
         let tipo = 'qualquer';
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
-            return this.declaracaoDesestruturacaoConstante();
+            return await this.declaracaoDesestruturacaoConstante();
         }
         do {
             identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da constante.'));
@@ -1674,10 +1684,12 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             tipoExplicito = true;
             this.avancarEDevolverAnterior();
         }
-        this.consumir(delegua_2.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL, delegua_2.default.SETA_ESQUERDA)) {
+            throw this.erro(this.simbolos[this.atual], "Esperado '=' ou '<-' após identificador em instrução 'constante'.");
+        }
         const inicializadores = [];
         do {
-            inicializadores.push(this.expressao());
+            inicializadores.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(simboloConstante, 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
@@ -1699,7 +1711,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return retorno;
     }
-    funcao(tipo) {
+    async funcao(tipo) {
         let simbolo;
         switch (this.simbolos[this.atual].tipo) {
             case delegua_2.default.CONSTRUTOR:
@@ -1714,14 +1726,14 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // Se houver chamadas recursivas à função, precisamos definir um tipo
         // para ela. Vai ser atualizado após avaliação do corpo da função.
         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, decoradores);
         this.pilhaEscopos.registrarReferenciaFuncao(simbolo.lexema, funcaoDeclaracao);
         return funcaoDeclaracao;
     }
-    logicaComumParametros() {
+    async logicaComumParametros() {
         const parametros = [];
         do {
             const parametro = {};
@@ -1733,13 +1745,22 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 parametro.abrangencia = 'padrao';
             }
             parametro.nome = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
+                try {
+                    const valorPadrao = await this.primario();
+                    parametro.valorPadrao = valorPadrao;
+                }
+                catch (erro) {
+                    throw this.erro(this.simbolos[this.atual], `Valor padrão do parâmetro '${parametro.nome.lexema}' é inválido.`);
+                }
+            }
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
                 let tipoDadoParametro = this.verificarDefinicaoTipoAtual();
                 parametro.tipoDado = tipoDadoParametro;
                 this.avancarEDevolverAnterior();
             }
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
-                const valorPadrao = this.primario();
+                const valorPadrao = await this.primario();
                 parametro.valorPadrao = valorPadrao;
             }
             this.pilhaEscopos.definirInformacoesVariavel(parametro.nome.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer'));
@@ -1749,13 +1770,13 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         return parametros;
     }
-    corpoDaFuncao(tipo) {
+    async corpoDaFuncao(tipo) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de localização.
         const parenteseEsquerdo = this.consumir(delegua_2.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
         let parametros = [];
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
-            parametros = this.logicaComumParametros();
+            parametros = await this.logicaComumParametros();
         }
         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = 'qualquer';
@@ -1766,7 +1787,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             definicaoExplicitaDeTipo = true;
         }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
-        const corpo = this.blocoEscopo();
+        const corpo = await this.blocoEscopo();
         let expressoesRetorna = [];
         for (const declaracao of corpo) {
             expressoesRetorna = expressoesRetorna.concat((0, comum_1.buscarRetornos)(declaracao));
@@ -1801,7 +1822,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno, definicaoExplicitaDeTipo);
     }
-    declaracaoDeClasse() {
+    async declaracaoDeClasse() {
         const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         const pilhaDecoradoresClasse = Array.from(this.pilhaDecoradores);
         let superClasse = null;
@@ -1821,7 +1842,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             // Se o símbolo atual é arroba, é um decorador.
             // Caso contrário, verificamos o próximo símbolo.
             if (this.simbolos[this.atual].tipo === delegua_2.default.ARROBA) {
-                this.resolverDecorador();
+                await this.resolverDecoradores();
                 continue;
             }
             // Se o próximo símbolo ao atual for um parênteses, é um método.
@@ -1829,7 +1850,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             const proximoSimbolo = this.simbolos[this.atual + 1];
             switch (proximoSimbolo.tipo) {
                 case delegua_2.default.PARENTESE_ESQUERDO:
-                    metodos.push(this.funcao('método'));
+                    metodos.push(await this.funcao('método'));
                     break;
                 case delegua_2.default.DOIS_PONTOS:
                     const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
@@ -1859,23 +1880,23 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * @returns Uma função ou classe se o símbolo atual resolver aqui.
      *          O retorno de `resolverDeclaracao()` em caso contrário.
      * @see resolverDeclaracao
-     * @see resolverDecorador
+     * @see resolverDecoradores
      */
-    resolverDeclaracaoForaDeBloco() {
+    async resolverDeclaracaoForaDeBloco() {
         try {
             while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
-                this.resolverDecorador();
+                await this.resolverDecoradores();
             }
             if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
                 this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
-                return this.funcao('funcao');
+                return await this.funcao('funcao');
             }
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CLASSE)) {
-                return this.declaracaoDeClasse();
+                return await this.declaracaoDeClasse();
             }
-            return this.resolverDeclaracao();
+            return await this.resolverDeclaracao();
         }
         catch (erro) {
             this.sincronizar();
@@ -1915,36 +1936,36 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * @see resolverDeclaracaoForaDeBloco para as declarações que não podem
      * ocorrer em blocos de escopo elementares.
      */
-    resolverDeclaracao() {
+    async resolverDeclaracao() {
         switch (this.simbolos[this.atual].tipo) {
             case delegua_2.default.AJUDA:
-                return this.declaracaoAjuda();
+                return await this.declaracaoAjuda();
             case delegua_2.default.CHAVE_ESQUERDA:
                 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 delegua_2.default.COMENTARIO:
                 return this.declaracaoComentarioUmaLinha();
             case delegua_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoDeConstantes();
+                return await this.declaracaoDeConstantes();
             case delegua_2.default.CONTINUA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoContinua();
             case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoEnquanto();
+                return await this.declaracaoEnquanto();
             case delegua_2.default.ESCOLHA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoEscolha();
+                return await this.declaracaoEscolha();
             case delegua_2.default.ESCREVA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoEscreva();
+                return await this.declaracaoEscreva();
             case delegua_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoFalhar();
+                return await this.declaracaoFalhar();
             case delegua_2.default.FAZER:
                 const simboloFazer = this.avancarEDevolverAnterior();
-                return this.declaracaoFazer(simboloFazer);
+                return await this.declaracaoFazer(simboloFazer);
             case delegua_2.default.IMPORTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoImportar();
@@ -1952,25 +1973,25 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return this.declaracaoComentarioMultilinha();
             case delegua_2.default.PARA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoPara();
+                return await this.declaracaoPara();
             case delegua_2.default.SUSTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSustar();
             case delegua_2.default.SE:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoSe();
+                return await this.declaracaoSe();
             case delegua_2.default.RETORNA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoRetorna();
+                return await this.declaracaoRetorna();
             case delegua_2.default.TENDO:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoTendoComo();
+                return await this.declaracaoTendoComo();
             case delegua_2.default.TENTE:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoTente();
+                return await this.declaracaoTente();
             case delegua_2.default.VARIAVEL:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoDeVariaveis();
+                return await this.declaracaoDeVariaveis();
         }
         const simboloAtual = this.simbolos[this.atual];
         if (simboloAtual.tipo === delegua_2.default.IDENTIFICADOR) {
@@ -1984,9 +2005,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 throw this.erro(this.simbolos[this.atual], 'Não é permitido ter dois identificadores seguidos na mesma linha.');
             }
         }
-        return this.declaracaoExpressao();
+        return await this.declaracaoExpressao();
     }
-    declaracaoAjuda() {
+    async declaracaoAjuda() {
         const simboloAjuda = this.avancarEDevolverAnterior();
         if (this.estaNoFinal() || this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_ESQUERDO) {
             return new declaracoes_1.Ajuda(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, false);
@@ -1996,7 +2017,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.avancarEDevolverAnterior();
             return new declaracoes_1.Ajuda(simboloAjuda.hashArquivo, simboloAjuda.linha, undefined, true);
         }
-        const expressaoAjuda = this.expressao();
+        const expressaoAjuda = await this.expressao();
         this.consumir(delegua_2.default.PARENTESE_DIREITO, `Esperado parêntese direito após expressão usada como argumento em ajuda(). Atual: ${this.simbolos[this.atual].lexema}.`);
         return new declaracoes_1.Ajuda(simboloAjuda.hashArquivo, simboloAjuda.linha, expressaoAjuda);
     }
@@ -2102,7 +2123,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             }
         }
     }
-    analisar(retornoLexador, hashArquivo) {
+    async analisar(retornoLexador, hashArquivo) {
         const inicioAnalise = (0, browser_process_hrtime_1.default)();
         this.erros = [];
         this.atual = 0;
@@ -2115,8 +2136,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.inicializarPilhaEscopos();
         let declaracoes = [];
         while (!this.estaNoFinal()) {
-            this.resolverDecorador();
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            await this.resolverDecoradores();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }