@designliquido/delegua 0.50.2 → 0.52.0

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

@@ -13,12 +13,13 @@ const inferenciador_1 = require("../../inferenciador");
 const pilha_escopos_1 = require("../pilha-escopos");
 const informacao_escopo_1 = require("../informacao-escopo");
 const informacao_variavel_ou_constante_1 = require("../../informacao-variavel-ou-constante");
-const pitugues_1 = __importDefault(require("../../tipos-de-simbolos/pitugues"));
+const comum_1 = require("../comum");
+const pitugues_1 = __importDefault(require("../../tipos-de-dados/dialetos/pitugues"));
+const pitugues_2 = __importDefault(require("../../tipos-de-simbolos/pitugues"));
 const primitivas_dicionario_1 = __importDefault(require("../../bibliotecas/primitivas-dicionario"));
 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 comum_1 = require("../comum");
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -113,12 +114,12 @@ class AvaliadorSintaticoPitugues {
     }
     expressaoLeia() {
         const simboloLeia = this.avancarEDevolverAnterior();
-        this.consumir(pitugues_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
+        this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em leia.");
         const argumentos = [];
         do {
             argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
-        this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em leia.");
+        } 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);
     }
     declaracaoDeConstantes() {
@@ -131,19 +132,19 @@ class AvaliadorSintaticoPitugues {
             return this.declaracaoDesestruturacaoConstante();
         } */
         do {
-            identificadores.push(this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da constante.'));
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
+            identificadores.push(this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome da constante.'));
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         // TODO: Discutir com comunidade como seria melhor fazer
         // dicas de tipos.
         /* if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         } */
-        this.consumir(pitugues_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+        this.consumir(pitugues_2.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         // TODO: Muito provavelmente, com desestruturação, essa validação
         // não será necessária.
         /* if (identificadores.length !== inicializadores.length) {
@@ -173,20 +174,20 @@ class AvaliadorSintaticoPitugues {
         let retorno = [];
         let tipo = 'qualquer';
         do {
-            identificadores.push(this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome de variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
-        if (!this.verificarSeSimboloAtualEIgualA(pitugues_1.default.IGUAL)) {
+            identificadores.push(this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome de variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
+        if (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL)) {
             // Inicialização de variáveis sem valor.
             for (let [indice, identificador] of identificadores.entries()) {
                 retorno.push(new declaracoes_1.Var(identificador, null));
             }
-            this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PONTO_E_VIRGULA);
+            this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO_E_VIRGULA);
             return retorno;
         }
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
         }
@@ -202,15 +203,15 @@ class AvaliadorSintaticoPitugues {
         this.avancarEDevolverAnterior();
         while (!this.estaNoFinal()) {
             switch (this.simboloAtual().tipo) {
-                case pitugues_1.default.CLASSE:
-                case pitugues_1.default.FUNCAO:
-                case pitugues_1.default.FUNÇÃO:
-                case pitugues_1.default.VARIAVEL:
-                case pitugues_1.default.PARA:
-                case pitugues_1.default.SE:
-                case pitugues_1.default.ENQUANTO:
-                case pitugues_1.default.ESCREVA:
-                case pitugues_1.default.RETORNA:
+                case pitugues_2.default.CLASSE:
+                case pitugues_2.default.FUNCAO:
+                case pitugues_2.default.FUNÇÃO:
+                case pitugues_2.default.VARIAVEL:
+                case pitugues_2.default.PARA:
+                case pitugues_2.default.SE:
+                case pitugues_2.default.ENQUANTO:
+                case pitugues_2.default.ESCREVA:
+                case pitugues_2.default.RETORNA:
                     return;
             }
             this.avancarEDevolverAnterior();
@@ -267,64 +268,64 @@ class AvaliadorSintaticoPitugues {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
-            case pitugues_1.default.COLCHETE_ESQUERDO:
+            case pitugues_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
-                if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.COLCHETE_DIREITO)) {
+                if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, [], 0, 'qualquer[]');
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(pitugues_1.default.COLCHETE_DIREITO)) {
+                while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_DIREITO)) {
                     const valor = this.atribuir();
                     valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== pitugues_1.default.COLCHETE_DIREITO) {
-                        this.consumir(pitugues_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    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.');
                     }
                 }
                 const tipoVetor = (0, inferenciador_1.inferirTipoVariavel)(valores);
                 return new construtos_1.Vetor(this.hashArquivo, simboloAtual.linha, valores, valores.length, tipoVetor);
-            case pitugues_1.default.CHAVE_ESQUERDA:
+            case pitugues_2.default.CHAVE_ESQUERDA:
                 this.avancarEDevolverAnterior();
                 const chaves = [];
-                if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CHAVE_DIREITA)) {
+                if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CHAVE_DIREITA)) {
                     return new construtos_1.Dicionario(this.hashArquivo, simboloAtual.linha, [], []);
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CHAVE_DIREITA)) {
+                while (!this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CHAVE_DIREITA)) {
                     const chave = this.atribuir();
-                    this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                    this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                     const valor = this.atribuir();
                     chaves.push(chave);
                     valores.push(valor);
-                    if (this.simboloAtual().tipo !== pitugues_1.default.CHAVE_DIREITA) {
-                        this.consumir(pitugues_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    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, valores);
-            case pitugues_1.default.FALSO:
-            case pitugues_1.default.VERDADEIRO:
+            case pitugues_2.default.FALSO:
+            case pitugues_2.default.VERDADEIRO:
                 const simboloLogico = this.avancarEDevolverAnterior();
-                return new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, simboloLogico.tipo === pitugues_1.default.VERDADEIRO, 'lógico');
-            case pitugues_1.default.FUNCAO:
-            case pitugues_1.default.FUNÇÃO:
+                return new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, simboloLogico.tipo === pitugues_2.default.VERDADEIRO, 'lógico');
+            case pitugues_2.default.FUNCAO:
+            case pitugues_2.default.FUNÇÃO:
                 const simboloFuncao = this.avancarEDevolverAnterior();
                 const corpoDaFuncao = this.corpoDaFuncao(simboloFuncao.lexema);
                 this.pilhaEscopos.definirInformacoesVariavel(simboloFuncao.lexema, new informacao_variavel_ou_constante_1.InformacaoVariavelOuConstante(simboloFuncao.lexema, 'função'));
                 return corpoDaFuncao;
-            case pitugues_1.default.IMPORTAR:
+            case pitugues_2.default.IMPORTAR:
                 return this.declaracaoImportar();
-            case pitugues_1.default.NULO:
+            case pitugues_2.default.NULO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, simboloAtual.linha, null);
-            case pitugues_1.default.ISTO:
+            case pitugues_2.default.ISTO:
                 const simboloIsto = this.avancarEDevolverAnterior();
                 return new construtos_1.Isto(this.hashArquivo, simboloAtual.linha, simboloIsto);
-            case pitugues_1.default.LEIA:
+            case pitugues_2.default.LEIA:
                 return this.expressaoLeia();
-            case pitugues_1.default.NUMERO:
-            case pitugues_1.default.TEXTO:
+            case pitugues_2.default.NUMERO:
+            case pitugues_2.default.TEXTO:
                 const simboloLiteral = this.avancarEDevolverAnterior();
                 const tipoInferido = (0, inferenciador_1.inferirTipoVariavel)(simboloLiteral.literal);
                 const tipoDadosElementar = (0, inferenciador_1.tipoInferenciaParaTipoDadosElementar)(tipoInferido);
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloLiteral.linha), simboloLiteral.literal, tipoDadosElementar);
-            case pitugues_1.default.IDENTIFICADOR:
+            case pitugues_2.default.IDENTIFICADOR:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 let tipoOperando;
                 if (simboloIdentificador.lexema in this.tiposDefinidosEmCodigo) {
@@ -339,12 +340,12 @@ class AvaliadorSintaticoPitugues {
                     }
                 }
                 return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador, tipoOperando);
-            case pitugues_1.default.PARENTESE_ESQUERDO:
+            case pitugues_2.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 const expressao = this.expressao();
-                this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
                 return new construtos_1.Agrupamento(this.hashArquivo, simboloAtual.linha, expressao);
-            case pitugues_1.default.SUPER:
+            case pitugues_2.default.SUPER:
                 const simboloSuper = this.avancarEDevolverAnterior();
                 return new construtos_1.Super(this.hashArquivo, simboloSuper, this.superclasseAtual);
         }
@@ -352,30 +353,30 @@ class AvaliadorSintaticoPitugues {
     }
     finalizarChamada(entidadeChamada) {
         const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(pitugues_1.default.PARENTESE_DIREITO)) {
+        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());
-            } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         }
-        this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, argumentos);
     }
     chamar() {
         let expressao = this.primario();
         while (true) {
-            if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PARENTESE_ESQUERDO)) {
+            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PONTO)) {
-                const nome = this.consumir(pitugues_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+            else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO)) {
+                const nome = this.consumir(pitugues_2.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.COLCHETE_ESQUERDO)) {
+            else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
-                const simboloFechamento = this.consumir(pitugues_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                const simboloFechamento = this.consumir(pitugues_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             }
             else {
@@ -385,7 +386,7 @@ class AvaliadorSintaticoPitugues {
         return expressao;
     }
     unario() {
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.NEGACAO, pitugues_1.default.SUBTRACAO, pitugues_1.default.BIT_NOT)) {
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.NEGACAO, pitugues_2.default.SUBTRACAO, pitugues_2.default.BIT_NOT)) {
             const operador = this.simboloAnterior();
             const direito = this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito);
@@ -394,7 +395,7 @@ class AvaliadorSintaticoPitugues {
     }
     exponenciacao() {
         let expressao = this.unario();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.EXPONENCIACAO)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EXPONENCIACAO)) {
             const operador = this.simboloAnterior();
             const direito = this.unario();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -403,7 +404,7 @@ class AvaliadorSintaticoPitugues {
     }
     multiplicar() {
         let expressao = this.exponenciacao();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.DIVISAO, pitugues_1.default.DIVISAO_INTEIRA, pitugues_1.default.MULTIPLICACAO, pitugues_1.default.MODULO)) {
+        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();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -412,7 +413,7 @@ class AvaliadorSintaticoPitugues {
     }
     adicaoOuSubtracao() {
         let expressao = this.multiplicar();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.SUBTRACAO, pitugues_1.default.ADICAO)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SUBTRACAO, pitugues_2.default.ADICAO)) {
             const operador = this.simboloAnterior();
             const direito = this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -421,7 +422,7 @@ class AvaliadorSintaticoPitugues {
     }
     bitShift() {
         let expressao = this.adicaoOuSubtracao();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.MENOR_MENOR, pitugues_1.default.MAIOR_MAIOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MENOR_MENOR, pitugues_2.default.MAIOR_MAIOR)) {
             const operador = this.simboloAnterior();
             const direito = this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -430,7 +431,7 @@ class AvaliadorSintaticoPitugues {
     }
     bitE() {
         let expressao = this.bitShift();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.BIT_AND)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.BIT_AND)) {
             const operador = this.simboloAnterior();
             const direito = this.bitShift();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -439,7 +440,7 @@ class AvaliadorSintaticoPitugues {
     }
     bitOu() {
         let expressao = this.bitE();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.BIT_OR, pitugues_1.default.BIT_XOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.BIT_OR, pitugues_2.default.BIT_XOR)) {
             const operador = this.simboloAnterior();
             const direito = this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -448,7 +449,7 @@ class AvaliadorSintaticoPitugues {
     }
     comparar() {
         let expressao = this.bitOu();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.MAIOR, pitugues_1.default.MAIOR_IGUAL, pitugues_1.default.MENOR, pitugues_1.default.MENOR_IGUAL)) {
+        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();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -457,7 +458,7 @@ class AvaliadorSintaticoPitugues {
     }
     comparacaoIgualdade() {
         let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.DIFERENTE, pitugues_1.default.IGUAL_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.DIFERENTE, pitugues_2.default.IGUAL_IGUAL)) {
             const operador = this.simboloAnterior();
             const direito = this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -466,7 +467,7 @@ class AvaliadorSintaticoPitugues {
     }
     em() {
         let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.EM)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.EM)) {
             const operador = this.simboloAnterior();
             const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -475,7 +476,7 @@ class AvaliadorSintaticoPitugues {
     }
     e() {
         let expressao = this.em();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.E)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.E)) {
             const operador = this.simboloAnterior();
             const direito = this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -484,7 +485,7 @@ class AvaliadorSintaticoPitugues {
     }
     ou() {
         let expressao = this.e();
-        while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.OU)) {
+        while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.OU)) {
             const operador = this.simboloAnterior();
             const direito = this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -493,8 +494,8 @@ class AvaliadorSintaticoPitugues {
     }
     atribuir() {
         const expressao = this.ou();
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.IGUAL) ||
-            this.verificarSeSimboloAtualEIgualA(pitugues_1.default.MAIS_IGUAL)) {
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL) ||
+            this.verificarSeSimboloAtualEIgualA(pitugues_2.default.MAIS_IGUAL)) {
             const igual = this.simboloAnterior();
             const valor = this.atribuir();
             if (expressao instanceof construtos_1.Variavel) {
@@ -516,12 +517,12 @@ class AvaliadorSintaticoPitugues {
     }
     declaracaoEscreva() {
         const simboloAtual = this.simboloAtual();
-        this.consumir(pitugues_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
         do {
             argumentos.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
-        this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
+        this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
     declaracaoExpressao() {
@@ -591,18 +592,18 @@ class AvaliadorSintaticoPitugues {
         try {
             this.blocos += 1;
             const condicao = this.expressao();
-            this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
+            this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após 'escolha'.");
             const caminhos = [];
             let caminhoPadrao = null;
             while (!this.estaNoFinal() &&
-                [pitugues_1.default.CASO, pitugues_1.default.PADRAO].includes(this.simbolos[this.atual].tipo)) {
-                if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CASO)) {
+                [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()];
-                    this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
-                    while (this.verificarTipoSimboloAtual(pitugues_1.default.CASO)) {
-                        this.consumir(pitugues_1.default.CASO, null);
+                    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());
-                        this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                        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,
                     // não podemos simplesmente chamar `this.resolverDeclaracao()` porque o dois-pontos já
@@ -615,13 +616,13 @@ class AvaliadorSintaticoPitugues {
                         declaracoes,
                     });
                 }
-                else if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PADRAO)) {
+                else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simboloAtual(), "Você só pode ter um caminho padrão em cada declaração de 'escolha'.");
                         this.erros.push(excecao);
                         throw excecao;
                     }
-                    this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+                    this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
                     // Como dois-pontos é um símbolo usado para conferir se há um início de bloco,
                     // não podemos simplesmente chamar `this.resolverDeclaracao()` porque o dois-pontos já
                     // foi consumido na verificação.
@@ -640,8 +641,8 @@ class AvaliadorSintaticoPitugues {
         }
     }
     declaracaoParaCada(simboloPara) {
-        const nomeVariavelIteracao = this.consumir(pitugues_1.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        if (!this.verificarSeSimboloAtualEIgualA(pitugues_1.default.DE, pitugues_1.default.EM)) {
+        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 = this.expressao();
@@ -659,21 +660,21 @@ class AvaliadorSintaticoPitugues {
     }
     declaracaoParaTradicional(simboloPara) {
         let inicializador;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PONTO_E_VIRGULA)) {
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PONTO_E_VIRGULA)) {
             inicializador = null;
         }
-        else if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VARIAVEL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VARIAVEL)) {
             inicializador = this.declaracaoDeVariaveis();
         }
         else {
             inicializador = this.declaracaoExpressao();
         }
         let condicao = null;
-        if (!this.verificarTipoSimboloAtual(pitugues_1.default.PONTO_E_VIRGULA)) {
+        if (!this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
             condicao = this.expressao();
         }
         let incrementar = null;
-        if (this.simbolos[this.atual].tipo !== pitugues_1.default.DOIS_PONTOS) {
+        if (this.simbolos[this.atual].tipo !== pitugues_2.default.DOIS_PONTOS) {
             incrementar = this.expressao();
         }
         const corpo = this.resolverDeclaracao();
@@ -683,7 +684,7 @@ class AvaliadorSintaticoPitugues {
         try {
             const simboloPara = this.simboloAnterior();
             this.blocos += 1;
-            if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CADA)) {
+            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CADA)) {
                 return this.declaracaoParaCada(simboloPara);
             }
             return this.declaracaoParaTradicional(simboloPara);
@@ -699,7 +700,7 @@ class AvaliadorSintaticoPitugues {
         const condicao = this.expressao();
         const caminhoEntao = this.resolverDeclaracao();
         let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.SENAO, pitugues_1.default.SENÃO)) {
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SENAO, pitugues_2.default.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
@@ -719,35 +720,35 @@ class AvaliadorSintaticoPitugues {
     declaracaoRetorna() {
         const palavraChave = this.simboloAnterior();
         let valor = null;
-        if (!this.verificarTipoSimboloAtual(pitugues_1.default.PONTO_E_VIRGULA)) {
+        if (!this.verificarTipoSimboloAtual(pitugues_2.default.PONTO_E_VIRGULA)) {
             valor = this.expressao();
         }
         return new declaracoes_1.Retorna(palavraChave, valor);
     }
     declaracaoImportar() {
         this.avancarEDevolverAnterior();
-        this.consumir(pitugues_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        this.consumir(pitugues_2.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
         const caminho = this.expressao();
-        this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new declaracoes_1.Importar(caminho);
     }
     declaracaoTente() {
         const simboloTente = this.simboloAnterior();
-        this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'tente'.");
+        this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'tente'.");
         const blocoTente = this.blocoEscopo();
         let blocoPegue = null;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PEGUE)) {
-            this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.PEGUE)) {
+            this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
             blocoPegue = this.blocoEscopo();
         }
         let blocoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.SENAO, pitugues_1.default.SENÃO)) {
-            this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'senão'.");
+        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();
         }
         let blocoFinalmente = null;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.FINALMENTE)) {
-            this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.FINALMENTE)) {
+            this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' após a declaração 'pegue'.");
             blocoFinalmente = this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
@@ -757,7 +758,7 @@ class AvaliadorSintaticoPitugues {
         try {
             this.blocos += 1;
             const declaracaoOuBlocoFazer = this.resolverDeclaracao();
-            this.consumir(pitugues_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
+            this.consumir(pitugues_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo da declaração 'fazer'.");
             const condicaoEnquanto = this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), declaracaoOuBlocoFazer, condicaoEnquanto);
         }
@@ -767,48 +768,48 @@ class AvaliadorSintaticoPitugues {
     }
     resolverDeclaracao() {
         switch (this.simbolos[this.atual].tipo) {
-            case pitugues_1.default.CONSTANTE:
+            case pitugues_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeConstantes();
-            case pitugues_1.default.CONTINUA:
+            case pitugues_2.default.CONTINUA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoContinua();
-            case pitugues_1.default.DOIS_PONTOS:
+            case pitugues_2.default.DOIS_PONTOS:
                 this.avancarEDevolverAnterior();
                 const simboloInicioBloco = this.simboloAnterior();
                 return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-            case pitugues_1.default.ENQUANTO:
+            case pitugues_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEnquanto();
-            case pitugues_1.default.ESCOLHA:
+            case pitugues_2.default.ESCOLHA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscolha();
-            case pitugues_1.default.IMPRIMA:
-            case pitugues_1.default.ESCREVA:
+            case pitugues_2.default.IMPRIMA:
+            case pitugues_2.default.ESCREVA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscreva();
-            case pitugues_1.default.FALHAR:
+            case pitugues_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFalhar();
-            case pitugues_1.default.FAZER:
+            case pitugues_2.default.FAZER:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFazer();
-            case pitugues_1.default.PARA:
+            case pitugues_2.default.PARA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoPara();
-            case pitugues_1.default.SUSTAR:
+            case pitugues_2.default.SUSTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSustar();
-            case pitugues_1.default.SE:
+            case pitugues_2.default.SE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSe();
-            case pitugues_1.default.RETORNA:
+            case pitugues_2.default.RETORNA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoRetorna();
-            case pitugues_1.default.TENTE:
+            case pitugues_2.default.TENTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTente();
-            case pitugues_1.default.VARIAVEL:
+            case pitugues_2.default.VARIAVEL:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeVariaveis();
         }
@@ -816,8 +817,8 @@ class AvaliadorSintaticoPitugues {
     }
     funcao(tipo, construtor) {
         const simbolo = !construtor
-            ? this.consumir(pitugues_1.default.IDENTIFICADOR, `Esperado nome ${tipo}.`)
-            : new lexador_1.Simbolo(pitugues_1.default.CONSTRUTOR, 'construtor', null, -1, -1);
+            ? 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_variavel_ou_constante_1.InformacaoVariavelOuConstante(simbolo.lexema, 'qualquer'));
@@ -835,55 +836,94 @@ class AvaliadorSintaticoPitugues {
                 throw this.erro(this.simboloAtual(), 'Função não pode ter mais de 255 parâmetros.');
             }
             const parametro = {};
-            if (this.simboloAtual().tipo === pitugues_1.default.MULTIPLICACAO) {
-                this.consumir(pitugues_1.default.MULTIPLICACAO, null);
+            if (this.simboloAtual().tipo === pitugues_2.default.MULTIPLICACAO) {
+                this.consumir(pitugues_2.default.MULTIPLICACAO, null);
                 parametro.abrangencia = 'multiplo';
             }
             else {
                 parametro.abrangencia = 'padrao';
             }
-            parametro.nome = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
-            if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.IGUAL)) {
+            parametro.nome = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.IGUAL)) {
                 parametro.valorPadrao = this.primario();
             }
             this.pilhaEscopos.definirInformacoesVariavel(parametro.nome.lexema, new informacao_variavel_ou_constante_1.InformacaoVariavelOuConstante(parametro.nome.lexema, parametro.tipoDado || 'qualquer'));
             parametros.push(parametro);
             if (parametro.abrangencia === 'multiplo')
                 break;
-        } while (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.VIRGULA));
         return parametros;
     }
+    verificarDefinicaoTipoAtual() {
+        const tipos = [...Object.values(pitugues_1.default)];
+        if (this.simbolos[this.atual].lexema in this.tiposDefinidosEmCodigo) {
+            return this.simbolos[this.atual].lexema;
+        }
+        const lexemaElementar = this.simbolos[this.atual].lexema.toLowerCase();
+        const tipoElementarResolvido = tipos.find((tipo) => tipo === lexemaElementar);
+        if (!tipoElementarResolvido) {
+            throw this.erro(this.simbolos[this.atual], `Tipo de dados desconhecido: '${this.simbolos[this.atual].lexema}'.`);
+        }
+        if (this.verificarTipoProximoSimbolo(pitugues_2.default.COLCHETE_ESQUERDO)) {
+            const tiposVetores = [
+                'inteiro[]',
+                'numero[]',
+                'número[]',
+                'qualquer[]',
+                'real[]',
+                'texto[]',
+            ];
+            this.avancarEDevolverAnterior();
+            if (!this.verificarTipoProximoSimbolo(pitugues_2.default.COLCHETE_DIREITO)) {
+                throw this.erro(this.simbolos[this.atual], `Esperado símbolo de fechamento do vetor: ']'. Atual: ${this.simbolos[this.atual].lexema}`);
+            }
+            const tipoVetor = tiposVetores.find((tipo) => tipo === `${lexemaElementar}[]`);
+            this.avancarEDevolverAnterior();
+            return tipoVetor;
+        }
+        return tipoElementarResolvido;
+    }
     corpoDaFuncao(tipo) {
-        this.consumir(pitugues_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${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_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(pitugues_2.default.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
-        this.consumir(pitugues_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
-        this.consumir(pitugues_1.default.DOIS_PONTOS, `Esperado ':' antes do escopo do ${tipo}.`);
+        this.consumir(pitugues_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        let tipoRetorno = 'qualquer';
+        let definicaoExplicitaDeTipo = false;
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.SETA)) {
+            tipoRetorno = this.verificarDefinicaoTipoAtual();
+            this.avancarEDevolverAnterior();
+            definicaoExplicitaDeTipo = true;
+        }
+        this.consumir(pitugues_2.default.DOIS_PONTOS, `Esperado ':' antes do escopo do ${tipo}.`);
         const corpo = this.blocoEscopo();
-        return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo);
+        tipoRetorno = (0, comum_1.logicaDescobertaRetornoFuncao)(this, corpo, tipoRetorno, definicaoExplicitaDeTipo, parenteseEsquerdo);
+        return new construtos_1.FuncaoConstruto(this.hashArquivo, 0, parametros, corpo, tipoRetorno, definicaoExplicitaDeTipo);
     }
     declaracaoDeClasse() {
-        const simbolo = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        const simbolo = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
-        if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.HERDA)) {
-            const simboloSuperclasse = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+        if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.HERDA)) {
+            const simboloSuperclasse = this.consumir(pitugues_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             this.superclasseAtual = simboloSuperclasse.lexema;
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
         }
-        this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
+        this.consumir(pitugues_2.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
         const metodos = [];
         while (!this.estaNoFinal() &&
-            this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CONSTRUTOR, pitugues_1.default.FUNCAO, pitugues_1.default.FUNÇÃO)) {
-            metodos.push(this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_1.default.CONSTRUTOR));
+            this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CONSTRUTOR, pitugues_2.default.FUNCAO, pitugues_2.default.FUNÇÃO)) {
+            metodos.push(this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_2.default.CONSTRUTOR));
         }
         this.superclasseAtual = undefined;
         return new declaracoes_1.Classe(simbolo, superClasse, metodos);
     }
     declaracaoFalhar() {
         const simboloFalha = this.simbolos[this.atual - 1];
-        const textoFalha = this.consumir(pitugues_1.default.TEXTO, 'Esperado texto para explicar falha.');
+        const textoFalha = this.consumir(pitugues_2.default.TEXTO, 'Esperado texto para explicar falha.');
         return new declaracoes_1.Falhar(simboloFalha, textoFalha.literal);
     }
     /**
@@ -893,13 +933,13 @@ class AvaliadorSintaticoPitugues {
      */
     resolverDeclaracaoForaDeBloco() {
         try {
-            if ((this.verificarTipoSimboloAtual(pitugues_1.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(pitugues_1.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(pitugues_1.default.IDENTIFICADOR)) {
+            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');
             }
-            if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CLASSE))
+            if (this.verificarSeSimboloAtualEIgualA(pitugues_2.default.CLASSE))
                 return this.declaracaoDeClasse();
             return this.resolverDeclaracao();
         }