@designliquido/delegua 0.72.0 → 1.0.0

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

@@ -20,6 +20,7 @@ const primitivas_dicionario_1 = __importDefault(require("../../bibliotecas/primi
 const primitivas_numero_1 = __importDefault(require("../../bibliotecas/primitivas-numero"));
 const primitivas_texto_1 = __importDefault(require("../../bibliotecas/primitivas-texto"));
 const primitivas_vetor_1 = __importDefault(require("../../bibliotecas/primitivas-vetor"));
+const primitivas_tupla_1 = __importDefault(require("../../bibliotecas/dialetos/pitugues/primitivas-tupla"));
 const micro_lexador_pitugues_1 = require("../../lexador/micro-lexador-pitugues");
 const micro_avaliador_sintatico_pitugues_1 = require("./micro-avaliador-sintatico-pitugues");
 /**
@@ -43,6 +44,7 @@ class AvaliadorSintaticoPitugues {
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'número', primitivas_numero_1.default);
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'texto', primitivas_texto_1.default);
         (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'vetor', primitivas_vetor_1.default);
+        (0, comum_1.registrarPrimitiva)(this.primitivasConhecidas, 'tupla', primitivas_tupla_1.default);
     }
     logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipoPrevio) {
         if (tipoPrevio !== 'qualquer') {
@@ -115,12 +117,12 @@ class AvaliadorSintaticoPitugues {
                 return inicializador.tipo;
         }
     }
-    expressaoLeia() {
+    async expressaoLeia() {
         const simboloLeia = this.avancarEDevolverAnterior();
         this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
         const argumentos = [];
         do {
-            argumentos.push(this.expressao());
+            argumentos.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
         return new construtos_1.Leia(simboloLeia, argumentos);
@@ -137,13 +139,13 @@ class AvaliadorSintaticoPitugues {
             return false;
         }
     }
-    declaracaoImplicitaVariaveis() {
+    async declaracaoImplicitaVariaveis() {
         const identificador = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome de variável.');
         this.consumir(pitugues_2.default.IGUAL, "Esperado '=' após identificador.");
         if (this.estaNoFinal()) {
             throw this.erro(this.simboloAnterior(), 'Esperado valor após o símbolo de igual.');
         }
-        const valor = this.expressao();
+        const valor = await this.expressao();
         const tipo = this.logicaComumInferenciaTiposVariaveisEConstantes(valor, 'qualquer');
         this.pilhaEscopos.definirInformacoesVariavel(identificador.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(identificador.lexema, tipo));
         return new declaracoes_1.Var(identificador, valor, tipo);
@@ -231,13 +233,13 @@ class AvaliadorSintaticoPitugues {
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         return { simbolos: identificadores, indexResto };
     }
-    consumirInicializadores() {
+    async consumirInicializadores() {
         const inicializadores = [];
         do {
             if (this.estaNoFinal()) {
                 throw this.erro(this.simboloAtual(), 'Esperado inicializador após vírgula.');
             }
-            inicializadores.push(this.expressao());
+            inicializadores.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         return inicializadores;
     }
@@ -249,10 +251,10 @@ class AvaliadorSintaticoPitugues {
         const falha = new declaracoes_1.Falhar(new lexador_1.Simbolo(pitugues_2.default.FALHAR, "falhar", null, linha, -1), new construtos_1.Literal(this.hashArquivo, linha, mensagem, 'texto'));
         return new declaracoes_1.Se(condicaoErro, new declaracoes_1.Bloco(this.hashArquivo, linha, [falha]), [], null);
     }
-    declaracaoDeVariaveis() {
+    async declaracaoDeVariaveis() {
         const { simbolos: identificadores, indexResto } = this.consumirIdentificadores();
         this.consumir(pitugues_2.default.IGUAL, 'Esperado o símbolo igual(=) após identificador.');
-        const inicializadores = this.consumirInicializadores();
+        const inicializadores = await this.consumirInicializadores();
         const qtdIdentificadores = identificadores.length;
         const qtdValores = inicializadores.length;
         const ehDesempacotamento = qtdIdentificadores > 1 && qtdValores === 1;
@@ -387,27 +389,38 @@ class AvaliadorSintaticoPitugues {
         }
         return false;
     }
-    primario() {
+    async primario() {
         const simboloAtual = this.simbolos[this.atual];
         switch (simboloAtual.tipo) {
             case pitugues_2.default.CHAVE_ESQUERDA:
                 this.avancarEDevolverAnterior();
                 const chaves = [];
                 const valoresDicionario = [];
+                const esSpread = [];
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CHAVE_DIREITA)) {
-                    return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, [], []);
+                    return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, [], [], []);
                 }
                 while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CHAVE_DIREITA)) {
-                    const chave = this.atribuir();
-                    this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
-                    const valor = this.atribuir();
-                    chaves.push(chave);
-                    valoresDicionario.push(valor);
+                    // Verificar se é spread (**expressao)
+                    if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EXPONENCIACAO)) {
+                        const expressaoDicionario = await this.atribuir();
+                        chaves.push(null);
+                        valoresDicionario.push(expressaoDicionario);
+                        esSpread.push(true);
+                    }
+                    else {
+                        const chave = await this.atribuir();
+                        this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                        const valor = await this.atribuir();
+                        chaves.push(chave);
+                        valoresDicionario.push(valor);
+                        esSpread.push(false);
+                    }
                     if (this.simboloAtual().tipo !== pitugues_2.default.CHAVE_DIREITA) {
                         this.consumir(pitugues_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                     }
                 }
-                return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, chaves, valoresDicionario);
+                return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, chaves, valoresDicionario, esSpread);
             case pitugues_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
@@ -419,7 +432,7 @@ class AvaliadorSintaticoPitugues {
                 }
                 const valoresVetor = [];
                 while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
-                    const valor = this.atribuir();
+                    const valor = await this.atribuir();
                     valoresVetor.push(valor);
                     if (this.simbolos[this.atual].tipo !== pitugues_2.default.COLCHETE_DIREITO) {
                         this.consumir(pitugues_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
@@ -437,7 +450,7 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.FUNCAO:
             case pitugues_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 pitugues_2.default.IMPORTAR:
@@ -449,7 +462,7 @@ class AvaliadorSintaticoPitugues {
                 const simboloIsto = this.avancarEDevolverAnterior();
                 return new construtos_1.Isto(this.hashArquivo, simboloAtual.linha, simboloIsto);
             case pitugues_2.default.LEIA:
-                return this.expressaoLeia();
+                return await this.expressaoLeia();
             case pitugues_2.default.NUMERO:
             case pitugues_2.default.TEXTO:
                 const simboloLiteral = this.avancarEDevolverAnterior();
@@ -503,7 +516,7 @@ class AvaliadorSintaticoPitugues {
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PARENTESE_DIREITO)) {
                     return new construtos_1.TuplaN(this.hashArquivo, simboloAtual.linha, []);
                 }
-                const expressao = this.tupla();
+                const expressao = await this.tupla();
                 // Se a expressão já é uma tupla (com vírgulas), retorna ela
                 if (expressao instanceof construtos_1.TuplaN) {
                     this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após itens da tupla.");
@@ -517,14 +530,14 @@ class AvaliadorSintaticoPitugues {
         }
         throw this.erro(this.simboloAtual(), 'Esperado expressão.');
     }
-    finalizarChamada(entidadeChamada) {
+    async finalizarChamada(entidadeChamada) {
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(pitugues_2.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
                     throw this.erro(this.simboloAtual(), 'Não pode haver mais de 255 argumentos.');
                 }
-                argumentos.push(this.expressao());
+                argumentos.push(await this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         }
         this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
@@ -532,11 +545,11 @@ class AvaliadorSintaticoPitugues {
         chamada.tipo = entidadeChamada.tipo;
         return chamada;
     }
-    chamar() {
-        let expressao = this.primario();
+    async chamar() {
+        let expressao = await this.primario();
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PARENTESE_ESQUERDO)) {
-                expressao = this.finalizarChamada(expressao);
+                expressao = await this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO)) {
                 const nome = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
@@ -547,14 +560,14 @@ class AvaliadorSintaticoPitugues {
                 let indiceInicio = null;
                 let indiceFim = null;
                 if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS)) {
-                    indiceInicio = this.expressao();
+                    indiceInicio = await this.expressao();
                 }
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DOIS_PONTOS)) {
                     ehFatiamento = true;
                     // Se o próximo não é ':', nem ']', então é o índice fim
                     if (!this.verificarTipoSimboloAtual(pitugues_2.default.DOIS_PONTOS) &&
                         !this.verificarTipoSimboloAtual(pitugues_2.default.COLCHETE_DIREITO)) {
-                        indiceFim = this.expressao();
+                        indiceFim = await this.expressao();
                     }
                 }
                 const simboloFechamento = this.consumir(pitugues_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
@@ -571,88 +584,88 @@ class AvaliadorSintaticoPitugues {
         }
         return expressao;
     }
-    unario() {
+    async unario() {
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.NEGACAO, pitugues_2.default.SUBTRACAO, pitugues_2.default.BIT_NOT)) {
             const operador = this.simboloAnterior();
-            const direito = this.unario();
+            const direito = await this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito);
         }
-        return this.chamar();
+        return await this.chamar();
     }
-    exponenciacao() {
-        let expressao = this.unario();
+    async exponenciacao() {
+        let expressao = await this.unario();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EXPONENCIACAO)) {
             const operador = this.simboloAnterior();
-            const direito = this.exponenciacao();
+            const direito = await this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    multiplicar() {
-        let expressao = this.exponenciacao();
+    async multiplicar() {
+        let expressao = await this.exponenciacao();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DIVISAO, pitugues_2.default.DIVISAO_INTEIRA, pitugues_2.default.MULTIPLICACAO, pitugues_2.default.MODULO)) {
             const operador = this.simboloAnterior();
-            const direito = this.exponenciacao();
+            const direito = await this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    adicaoOuSubtracao() {
-        let expressao = this.multiplicar();
+    async adicaoOuSubtracao() {
+        let expressao = await this.multiplicar();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SUBTRACAO, pitugues_2.default.ADICAO)) {
             const operador = this.simboloAnterior();
-            const direito = this.multiplicar();
+            const direito = await this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitShift() {
-        let expressao = this.adicaoOuSubtracao();
+    async bitShift() {
+        let expressao = await this.adicaoOuSubtracao();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MENOR_MENOR, pitugues_2.default.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
-            const direito = this.adicaoOuSubtracao();
+            const direito = await this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitE() {
-        let expressao = this.bitShift();
+    async bitE() {
+        let expressao = await this.bitShift();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.BIT_AND)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitShift();
+            const direito = await this.bitShift();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    bitOu() {
-        let expressao = this.bitE();
+    async bitOu() {
+        let expressao = await this.bitE();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.BIT_OR, pitugues_2.default.BIT_XOR)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitE();
+            const direito = await this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    comparar() {
-        let expressao = this.bitOu();
+    async comparar() {
+        let expressao = await this.bitOu();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MAIOR, pitugues_2.default.MAIOR_IGUAL, pitugues_2.default.MENOR, pitugues_2.default.MENOR_IGUAL)) {
             const operador = this.simboloAnterior();
-            const direito = this.bitOu();
+            const direito = await this.bitOu();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    comparacaoIgualdade() {
-        let expressao = this.comparar();
+    async comparacaoIgualdade() {
+        let expressao = await this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DIFERENTE, pitugues_2.default.IGUAL_IGUAL)) {
             const operador = this.simboloAnterior();
-            const direito = this.comparar();
+            const direito = await this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    em() {
-        let expressao = this.comparacaoIgualdade();
+    async em() {
+        let expressao = await this.comparacaoIgualdade();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EM, pitugues_2.default.CONTEM, pitugues_2.default.NAO)) {
             let operador = this.simboloAnterior();
             let negado = false;
@@ -660,46 +673,46 @@ class AvaliadorSintaticoPitugues {
                 operador = this.consumir(pitugues_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(pitugues_2.default.E)) {
             const operador = this.simboloAnterior();
-            const direito = this.em();
+            const direito = await this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    ou() {
-        let expressao = this.e();
+    async ou() {
+        let expressao = await this.e();
         while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.OU)) {
             const operador = this.simboloAnterior();
-            const direito = this.e();
+            const direito = await this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
         }
         return expressao;
     }
-    seTernario() {
-        let expressaoEntao = this.ou();
+    async seTernario() {
+        let expressaoEntao = await this.ou();
         if (this.simbolos[this.atual] && this.simbolos[this.atual].tipo === pitugues_2.default.SE && expressaoEntao.linha === this.simbolos[this.atual].linha) {
             while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SE)) {
                 const operador = this.simbolos[this.atual - 1];
-                const expressaoOuCondicao = this.seTernario();
+                const expressaoOuCondicao = await this.seTernario();
                 this.consumir(pitugues_2.default.SENAO, `Esperado 'senão' ou 'senao' após caminho positivo em se ternário. Atual:
                     ${this.simbolos[this.atual].lexema}.`);
-                const expressaoSenao = this.seTernario();
+                const expressaoSenao = await this.seTernario();
                 expressaoEntao = new construtos_1.SeTernario(this.hashArquivo, expressaoOuCondicao, expressaoEntao, operador, expressaoSenao);
             }
         }
         return expressaoEntao;
     }
-    tupla() {
-        let expressao = this.seTernario();
+    async tupla() {
+        let expressao = await this.seTernario();
         // Se não há vírgula, retorna a expressão simples
         if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA)) {
             return expressao;
@@ -710,49 +723,80 @@ class AvaliadorSintaticoPitugues {
             if (this.verificarTipoSimboloAtual(pitugues_2.default.PARENTESE_DIREITO)) {
                 break;
             }
-            elementos.push(this.seTernario());
+            elementos.push(await this.seTernario());
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         return new construtos_1.TuplaN(this.hashArquivo, expressao.linha, elementos);
     }
-    atribuir() {
-        const expressao = this.seTernario();
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL) ||
-            this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MAIS_IGUAL)) {
-            const igual = this.simboloAnterior();
-            const valor = this.atribuir();
+    async atribuir() {
+        const expressao = await this.seTernario();
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL, pitugues_2.default.MAIS_IGUAL, pitugues_2.default.MENOS_IGUAL, pitugues_2.default.MULTIPLICACAO_IGUAL, pitugues_2.default.DIVISAO_IGUAL)) {
+            const operadorAtribuicao = this.simboloAnterior();
+            const valor = await this.atribuir();
+            // Se for apenas '=', é uma atribuição padrão
+            if (operadorAtribuicao.tipo === pitugues_2.default.IGUAL) {
+                if (expressao instanceof construtos_1.Variavel) {
+                    return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
+                }
+                if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
+                    return new construtos_1.DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
+                }
+                if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                    return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
+                }
+                throw this.erro(operadorAtribuicao, 'Tarefa de atribuição inválida');
+            }
+            // Se for +=, -=, *=, /=
+            // Transforma 'a += 1' em 'a = a + 1'
+            let tipoOperadorMatematico;
+            switch (operadorAtribuicao.tipo) {
+                case pitugues_2.default.MAIS_IGUAL:
+                    tipoOperadorMatematico = pitugues_2.default.ADICAO;
+                    break;
+                case pitugues_2.default.MENOS_IGUAL:
+                    tipoOperadorMatematico = pitugues_2.default.SUBTRACAO;
+                    break;
+                case pitugues_2.default.MULTIPLICACAO_IGUAL:
+                    tipoOperadorMatematico = pitugues_2.default.MULTIPLICACAO;
+                    break;
+                case pitugues_2.default.DIVISAO_IGUAL:
+                    tipoOperadorMatematico = pitugues_2.default.DIVISAO;
+                    break;
+            }
+            const simboloOperador = new lexador_1.Simbolo(tipoOperadorMatematico, operadorAtribuicao.lexema.charAt(0), null, operadorAtribuicao.linha, operadorAtribuicao.hashArquivo);
+            const operacaoBinaria = new construtos_1.Binario(this.hashArquivo, expressao, simboloOperador, valor);
             if (expressao instanceof construtos_1.Variavel) {
-                return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
+                return new construtos_1.Atribuir(this.hashArquivo, expressao, operacaoBinaria);
             }
             if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
-                return new construtos_1.DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, valor);
+                return new construtos_1.DefinirValor(this.hashArquivo, 0, expressao.objeto, expressao.simbolo, operacaoBinaria);
             }
             if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
-                return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, valor);
+                return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, 0, expressao.entidadeChamada, expressao.indice, operacaoBinaria);
             }
-            throw this.erro(igual, 'Tarefa de atribuição inválida');
+            throw this.erro(operadorAtribuicao, 'Tarefa de atribuição inválida');
         }
         return expressao;
     }
     // TODO: Depreciar.
-    expressao() {
-        return this.atribuir();
+    async expressao() {
+        return await this.atribuir();
     }
-    declaracaoEscreva(simboloEscreva) {
+    async declaracaoEscreva(simboloEscreva) {
         this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
         do {
-            argumentos.push(this.expressao());
+            argumentos.push(await this.expressao());
         } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
         const declaracaoEscreva = new declaracoes_1.Escreva(Number(simboloEscreva.linha), simboloEscreva.hashArquivo, argumentos);
         declaracaoEscreva.simboloEscreva = simboloEscreva;
         return declaracaoEscreva;
     }
-    declaracaoExpressao() {
-        const expressao = this.expressao();
+    async declaracaoExpressao() {
+        const expressao = await this.expressao();
         return new declaracoes_1.Expressao(expressao);
     }
-    blocoEscopo() {
+    async blocoEscopo() {
         this.pilhaEscopos.empilhar(new informacao_escopo_1.InformacaoEscopo());
         let declaracoes = [];
         let simboloAtual = this.simboloAtual();
@@ -762,7 +806,13 @@ class AvaliadorSintaticoPitugues {
         // Exemplo: `se verdadeiro: escreva('Alguma coisa')`.
         // Neste caso, linha do símbolo atual é igual à linha do símbolo anterior.
         if (simboloAtual.linha === simboloAnterior.linha) {
-            declaracoes.push(this.resolverDeclaracaoForaDeBloco());
+            const declaracoesBloco = await this.resolverDeclaracaoForaDeBloco();
+            if (Array.isArray(declaracoesBloco)) {
+                declaracoes = declaracoes.concat(declaracoesBloco);
+            }
+            else {
+                declaracoes.push(declaracoesBloco);
+            }
         }
         else {
             // Situação 2: símbolo atual fica na próxima linha.
@@ -784,7 +834,7 @@ class AvaliadorSintaticoPitugues {
             // Significa que o código acabou, então o bloco também acabou.
             const espacosIndentacaoBloco = espacosIndentacaoLinhaAtual;
             while (espacosIndentacaoLinhaAtual === espacosIndentacaoBloco) {
-                const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+                const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
                 if (Array.isArray(retornoDeclaracao)) {
                     declaracoes = declaracoes.concat(retornoDeclaracao);
                 }
@@ -800,32 +850,32 @@ class AvaliadorSintaticoPitugues {
         this.pilhaEscopos.removerUltimo();
         return declaracoes;
     }
-    declaracaoEnquanto() {
+    async declaracaoEnquanto() {
         try {
             this.blocos += 1;
-            const condicao = this.expressao();
-            const bloco = this.resolverDeclaracao();
+            const condicao = await this.expressao();
+            const bloco = await this.resolverDeclaracao();
             return new declaracoes_1.Enquanto(condicao, bloco);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    declaracaoEscolha() {
+    async declaracaoEscolha() {
         try {
             this.blocos += 1;
-            const condicao = this.expressao();
+            const condicao = await this.expressao();
             this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
             const caminhos = [];
             let caminhoPadrao = null;
             while (!this.estaNoFinal() &&
                 [pitugues_2.default.CASO, pitugues_2.default.PADRAO].includes(this.simbolos[this.atual].tipo)) {
                 if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CASO)) {
-                    const caminhoCondicoes = [this.expressao()];
+                    const caminhoCondicoes = [await this.expressao()];
                     this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
                     while (this.verificarTipoSimboloAtual(pitugues_2.default.CASO)) {
                         this.consumir(pitugues_2.default.CASO, null);
-                        caminhoCondicoes.push(this.expressao());
+                        caminhoCondicoes.push(await this.expressao());
                         this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
                     // Como dois-pontos é um símbolo usado para conferir se há um início de bloco,
@@ -833,7 +883,7 @@ class AvaliadorSintaticoPitugues {
                     // foi consumido na verificação.
                     // Outro problema é que, aparentemente, o Interpretador não espera um Bloco, e sim
                     // um vetor de Declaracao, o qual obtemos com `this.blocoEscopo()`.
-                    const declaracoes = this.blocoEscopo();
+                    const declaracoes = await this.blocoEscopo();
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
@@ -851,7 +901,7 @@ class AvaliadorSintaticoPitugues {
                     // foi consumido na verificação.
                     // Outro problema é que, aparentemente, o Interpretador não espera um Bloco, e sim
                     // um vetor de Declaracao, o qual obtemos com `this.blocoEscopo()`.
-                    const declaracoes = this.blocoEscopo();
+                    const declaracoes = await this.blocoEscopo();
                     caminhoPadrao = {
                         declaracoes,
                     };
@@ -863,7 +913,25 @@ class AvaliadorSintaticoPitugues {
             this.blocos -= 1;
         }
     }
-    declaracaoPara() {
+    async declaracaoParaCada(simboloPara) {
+        const nomeVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+        if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DE, pitugues_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 vetor = await this.expressao();
+        if (!vetor.hasOwnProperty('tipo')) {
+            throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece possuir um tipo iterável.`);
+        }
+        const tipoVetor = vetor.tipo;
+        if (!tipoVetor.endsWith('[]') && !['qualquer', 'vetor'].includes(tipoVetor)) {
+            throw this.erro(simboloPara, `Variável ou constante em 'para cada' não é iterável. Tipo resolvido: ${tipoVetor}.`);
+        }
+        this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
+        // TODO: Talvez não seja uma ideia melhor chamar o método de `Bloco` aqui?
+        const corpo = await this.resolverDeclaracao();
+        return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
+    }
+    async declaracaoPara() {
         try {
             const simboloPara = this.simboloAnterior();
             this.blocos += 1;
@@ -872,7 +940,7 @@ class AvaliadorSintaticoPitugues {
             if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DE, pitugues_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 vetor = this.expressao();
+            const vetor = await this.expressao();
             if (!vetor.hasOwnProperty('tipo')) {
                 throw this.erro(simboloPara, `Variável ou constante em 'para cada' não parece possuir um tipo iterável.`);
             }
@@ -882,7 +950,7 @@ class AvaliadorSintaticoPitugues {
             }
             this.pilhaEscopos.definirInformacoesVariavel(nomeVariavelIteracao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeVariavelIteracao.lexema, tipoVetor.slice(0, -2)));
             // 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 new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), new construtos_1.Variavel(this.hashArquivo, nomeVariavelIteracao), vetor, corpo);
         }
         catch (erro) {
@@ -892,12 +960,12 @@ class AvaliadorSintaticoPitugues {
             this.blocos -= 1;
         }
     }
-    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(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
-            caminhoSenao = this.resolverDeclaracao();
+            caminhoSenao = await this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
     }
@@ -917,25 +985,25 @@ class AvaliadorSintaticoPitugues {
         }
         return new declaracoes_1.Continua(this.simboloAtual());
     }
-    declaracaoRetorna() {
+    async declaracaoRetorna() {
         const palavraChave = this.simboloAnterior();
         let valor = null;
         if (!this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
-            valor = this.expressao();
+            valor = await this.expressao();
         }
         return new declaracoes_1.Retorna(palavraChave, valor);
     }
-    declaracaoImportar() {
+    async declaracaoImportar() {
         this.avancarEDevolverAnterior();
         this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
-        const caminho = this.expressao();
+        const caminho = await this.expressao();
         this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new construtos_1.ImportarComoConstruto(caminho);
     }
-    declaracaoTente() {
+    async declaracaoTente() {
         const simboloTente = this.simboloAnterior();
         this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'tente'.");
-        const blocoTente = this.blocoEscopo();
+        const blocoTente = await this.blocoEscopo();
         let blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PEGUE)) {
             if (this.verificarTipoSimboloAtual(pitugues_2.default.COMO)) {
@@ -945,7 +1013,7 @@ class AvaliadorSintaticoPitugues {
                 // `pegue` recebe um `FuncaoConstruto`.
                 this.consumir(pitugues_2.default.DOIS_PONTOS, `Esperado ':' antes do escopo do bloco 'pegue'.`);
                 this.pilhaEscopos.definirInformacoesVariavel(variavelExcecao.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(variavelExcecao.lexema, 'qualquer'));
-                const corpo = this.blocoEscopo();
+                const corpo = await this.blocoEscopo();
                 blocoPegue = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloTente.linha, [{
                         abrangencia: "padrao",
                         nome: variavelExcecao,
@@ -956,49 +1024,49 @@ class AvaliadorSintaticoPitugues {
                 // Caso 2: sem parâmetro de erro.
                 // `pegue` recebe um bloco.
                 this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
-                blocoPegue = this.blocoEscopo();
+                blocoPegue = await this.blocoEscopo();
             }
         }
         let blocoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
             this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'senão'.");
-            blocoSenao = this.blocoEscopo();
+            blocoSenao = await this.blocoEscopo();
         }
         let blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.FINALMENTE)) {
             this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
-            blocoFinalmente = this.blocoEscopo();
+            blocoFinalmente = await this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
     }
-    declaracaoFazer() {
+    async declaracaoFazer() {
         const simboloFazer = this.simboloAnterior();
         try {
             this.blocos += 1;
-            const declaracaoOuBlocoFazer = this.resolverDeclaracao();
+            const declaracaoOuBlocoFazer = await this.resolverDeclaracao();
             this.consumir(pitugues_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
-            const condicaoEnquanto = this.expressao();
+            const condicaoEnquanto = await this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), declaracaoOuBlocoFazer, condicaoEnquanto);
         }
         finally {
             this.blocos -= 1;
         }
     }
-    funcao(tipo, construtor) {
+    async funcao(tipo, construtor) {
         const simbolo = !construtor
             ? this.consumir(pitugues_2.default.IDENTIFICADOR, `Esperado nome ${tipo}.`)
             : new lexador_1.Simbolo(pitugues_2.default.CONSTRUTOR, 'construtor', null, -1, -1);
         // 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);
         this.pilhaEscopos.registrarReferenciaFuncao(simbolo.lexema, funcaoDeclaracao);
         return funcaoDeclaracao;
     }
-    logicaComumParametros() {
+    async logicaComumParametros() {
         const parametros = [];
         do {
             if (parametros.length >= 255) {
@@ -1019,7 +1087,7 @@ class AvaliadorSintaticoPitugues {
                 this.avancarEDevolverAnterior();
             }
             if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL)) {
-                parametro.valorPadrao = this.primario();
+                parametro.valorPadrao = await this.primario();
             }
             this.pilhaEscopos.definirInformacoesVariavel(parametro.nome.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer'));
             parametros.push(parametro);
@@ -1032,7 +1100,7 @@ class AvaliadorSintaticoPitugues {
      * Resolve uma lista de compreensão.
      * @returns {ListaCompreensao} A lista de compreensão resolvida.
      */
-    resolverCompreensaoDeLista() {
+    async resolverCompreensaoDeLista() {
         // TODO: Se expressão não começar com um identificador, por exemplo `3 * x`, como faríamos para
         // aceitar o `x` na avaliação da expressão?
         if (this.simbolos[this.atual].tipo === pitugues_2.default.IDENTIFICADOR) {
@@ -1042,7 +1110,7 @@ class AvaliadorSintaticoPitugues {
             );
         }
         // TODO: Reavaliar a precedência do se ternário.
-        const retornoExpressao = this.ou();
+        const retornoExpressao = await this.ou();
         this.consumir(pitugues_2.default.PARA, "Esperado instrução 'para' após identificado.");
         this.consumir(pitugues_2.default.CADA, "Esperado instrução 'cada' após 'para'.");
         const simboloVariavelIteracao = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado identificador de variável após 'para cada'.");
@@ -1058,9 +1126,9 @@ class AvaliadorSintaticoPitugues {
         }
         const localizacaoVetor = this.simboloAnterior();
         // TODO: Reavaliar a precedência do se ternário.
-        const vetor = this.ou();
+        const vetor = await this.ou();
         this.consumir(pitugues_2.default.SE, "Esperado condição 'se' após vetor.");
-        const condicao = this.expressao();
+        const condicao = await this.expressao();
         this.consumir(pitugues_2.default.COLCHETE_DIREITO, 'Espero fechamento de colchetes após condição.');
         const tipoVetor = vetor.tipo;
         if (!tipoVetor.endsWith('[]') && !['qualquer', 'vetor'].includes(tipoVetor)) {
@@ -1109,13 +1177,13 @@ class AvaliadorSintaticoPitugues {
             return new declaracoes_1.TextoDocumentacao(this.hashArquivo, Number(simboloTexto.linha), simboloTexto.lexema);
         }
     }
-    corpoDaFuncao(tipo) {
+    async corpoDaFuncao(tipo) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de localização.
         const parenteseEsquerdo = this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
         let parametros = [];
         if (!this.verificarTipoSimboloAtual(pitugues_2.default.PARENTESE_DIREITO)) {
-            parametros = this.logicaComumParametros();
+            parametros = await this.logicaComumParametros();
         }
         this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = 'qualquer';
@@ -1127,11 +1195,11 @@ class AvaliadorSintaticoPitugues {
         }
         this.consumir(pitugues_2.default.DOIS_PONTOS, `Esperado ':' antes do escopo do ${tipo}.`);
         const documentacao = this.declaracaoTextoDeDocumentacao();
-        const corpo = this.blocoEscopo();
+        const corpo = await this.blocoEscopo();
         tipoRetorno = (0, comum_1.logicaDescobertaRetornoFuncao)(this, corpo, tipoRetorno, definicaoExplicitaDeTipo, parenteseEsquerdo);
         return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo, tipoRetorno, definicaoExplicitaDeTipo, documentacao);
     }
-    declaracaoDeClasse() {
+    async declaracaoDeClasse() {
         const simbolo = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PARENTESE_ESQUERDO)) {
@@ -1156,7 +1224,7 @@ class AvaliadorSintaticoPitugues {
                 propriedades.push(propriedade);
             }
             else {
-                metodos.push(this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_2.default.CONSTRUTOR));
+                metodos.push(await this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_2.default.CONSTRUTOR));
             }
         }
         this.superclasseAtual = undefined;
@@ -1205,24 +1273,24 @@ class AvaliadorSintaticoPitugues {
      * ou uma expressão.
      * @returns Objeto do tipo `Declaracao`.
      */
-    resolverDeclaracaoForaDeBloco() {
+    async resolverDeclaracaoForaDeBloco() {
         try {
             if ((this.verificarTipoSimboloAtual(pitugues_2.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(pitugues_2.default.FUNÇÃO)) &&
                 this.verificarTipoProximoSimbolo(pitugues_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
-                return this.funcao('funcao');
+                return await this.funcao('funcao');
             }
             if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CLASSE))
-                return this.declaracaoDeClasse();
-            return this.resolverDeclaracao();
+                return await this.declaracaoDeClasse();
+            return await this.resolverDeclaracao();
         }
         catch (erro) {
             this.sincronizar();
             return null;
         }
     }
-    resolverDeclaracao() {
+    async resolverDeclaracao() {
         // Detecção de declaração implícita ou múltipla atribuição (pode começar com * ou identificador)
         const simboloAtual = this.simbolos[this.atual];
         // Bloqueio explícito do uso de "var"
@@ -1254,7 +1322,7 @@ class AvaliadorSintaticoPitugues {
             case pitugues_2.default.DOIS_PONTOS:
                 this.avancarEDevolverAnterior();
                 const simboloInicioBloco = this.simboloAnterior();
-                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 pitugues_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEnquanto();
@@ -1283,7 +1351,7 @@ class AvaliadorSintaticoPitugues {
                 return this.declaracaoSe();
             case pitugues_2.default.RETORNA:
                 this.avancarEDevolverAnterior();
-                return this.declaracaoRetorna();
+                return await this.declaracaoRetorna();
             case pitugues_2.default.TENTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTente();
@@ -1385,7 +1453,7 @@ class AvaliadorSintaticoPitugues {
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
     }
-    analisar(retornoLexador, hashArquivo) {
+    async analisar(retornoLexador, hashArquivo) {
         const inicioAnalise = (0, browser_process_hrtime_1.default)();
         this.erros = [];
         this.atual = 0;
@@ -1399,7 +1467,7 @@ class AvaliadorSintaticoPitugues {
         this.verificarPontosEVirgulasInvalidos();
         let declaracoes = [];
         while (!this.estaNoFinal()) {
-            const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
+            const retornoDeclaracao = await this.resolverDeclaracaoForaDeBloco();
             if (retornoDeclaracao === null) {
                 continue;
             }