@designliquido/delegua 0.2.0 → 0.2.3

package/{src → fontes}/avaliador-sintatico/index.js

@@ -1,25 +1,31 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = void 0;
-var tiposDeSimbolos_1 = require("../tiposDeSimbolos");
+exports.AvaliadorSintatico = void 0;
+var tiposDeSimbolos_1 = __importDefault(require("../tiposDeSimbolos"));
+var perf_hooks_1 = require("perf_hooks");
 var construtos_1 = require("../construtos");
-var erros_avaliador_1 = require("./erros-avaliador");
+var erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
 var declaracoes_1 = require("../declaracoes");
 /**
  * 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.
+ * Há dois grupos de estruturas de alto nível: Construtos e Declarações.
  */
-var Parser = /** @class */ (function () {
-    function Parser(Delegua, simbolos) {
-        this.simbolos = simbolos;
-        this.Delegua = Delegua;
+var AvaliadorSintatico = /** @class */ (function () {
+    function AvaliadorSintatico(performance) {
+        if (performance === void 0) { performance = false; }
         this.atual = 0;
         this.ciclos = 0;
+        this.erros = [];
+        this.performance = performance;
     }
-    Parser.prototype.sincronizar = function () {
-        this.avancar();
+    AvaliadorSintatico.prototype.sincronizar = function () {
+        this.avancarEDevolverAnterior();
         while (!this.estaNoFinal()) {
-            if (this.voltar().tipo === tiposDeSimbolos_1.default.PONTO_E_VIRGULA)
+            if (this.simboloAnterior().tipo === tiposDeSimbolos_1.default.PONTO_E_VIRGULA)
                 return;
             switch (this.simboloAtual().tipo) {
                 case tiposDeSimbolos_1.default.CLASSE:
@@ -33,89 +39,92 @@ var Parser = /** @class */ (function () {
                 case tiposDeSimbolos_1.default.RETORNA:
                     return;
             }
-            this.avancar();
+            this.avancarEDevolverAnterior();
         }
     };
-    Parser.prototype.erro = function (simbolo, mensagemDeErro) {
-        this.Delegua.erro(simbolo, mensagemDeErro);
-        return new erros_avaliador_1.ErroAvaliador();
+    AvaliadorSintatico.prototype.erro = function (simbolo, mensagemDeErro) {
+        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
+        this.erros.push(excecao);
+        return excecao;
     };
-    Parser.prototype.consumir = function (tipo, mensagemDeErro) {
-        if (this.verificar(tipo))
-            return this.avancar();
+    AvaliadorSintatico.prototype.consumir = function (tipo, mensagemDeErro) {
+        if (this.verificarTipoSimboloAtual(tipo))
+            return this.avancarEDevolverAnterior();
         throw this.erro(this.simboloAtual(), mensagemDeErro);
     };
-    Parser.prototype.verificar = function (tipo) {
+    AvaliadorSintatico.prototype.verificarTipoSimboloAtual = function (tipo) {
         if (this.estaNoFinal())
             return false;
         return this.simboloAtual().tipo === tipo;
     };
-    Parser.prototype.verificarProximo = function (tipo) {
+    AvaliadorSintatico.prototype.verificarTipoProximoSimbolo = function (tipo) {
         if (this.estaNoFinal())
             return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
     };
-    Parser.prototype.simboloAtual = function () {
+    AvaliadorSintatico.prototype.simboloAtual = function () {
         return this.simbolos[this.atual];
     };
-    Parser.prototype.voltar = function () {
+    AvaliadorSintatico.prototype.simboloAnterior = function () {
         return this.simbolos[this.atual - 1];
     };
-    Parser.prototype.procurar = function (posicao) {
+    AvaliadorSintatico.prototype.simboloNaPosicao = function (posicao) {
         return this.simbolos[this.atual + posicao];
     };
-    Parser.prototype.estaNoFinal = function () {
+    AvaliadorSintatico.prototype.estaNoFinal = function () {
         var simboloAtual = this.simboloAtual();
-        if (simboloAtual && simboloAtual.tipo === tiposDeSimbolos_1.default.PONTO_E_VIRGULA) {
+        if (simboloAtual &&
+            simboloAtual.tipo === tiposDeSimbolos_1.default.PONTO_E_VIRGULA) {
             return true;
         }
         return this.atual === this.simbolos.length;
     };
-    Parser.prototype.avancar = function () {
+    AvaliadorSintatico.prototype.avancarEDevolverAnterior = function () {
         if (!this.estaNoFinal())
             this.atual += 1;
-        return this.voltar();
+        return this.simboloAnterior();
     };
-    Parser.prototype.verificarSeSimboloAtualEIgualA = function () {
+    AvaliadorSintatico.prototype.verificarSeSimboloAtualEIgualA = function () {
         var argumentos = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             argumentos[_i] = arguments[_i];
         }
         for (var i = 0; i < argumentos.length; i++) {
             var tipoAtual = argumentos[i];
-            if (this.verificar(tipoAtual)) {
-                this.avancar();
+            if (this.verificarTipoSimboloAtual(tipoAtual)) {
+                this.avancarEDevolverAnterior();
                 return true;
             }
         }
         return false;
     };
-    Parser.prototype.primario = function () {
+    AvaliadorSintatico.prototype.primario = function () {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SUPER)) {
-            var palavraChave = this.voltar();
+            var palavraChave = this.simboloAnterior();
             this.consumir(tiposDeSimbolos_1.default.PONTO, "Esperado '.' após 'super'.");
-            var metodo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do método da SuperClasse.");
-            return new construtos_1.Super(palavraChave, metodo);
+            var metodo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, 'Esperado nome do método da SuperClasse.');
+            return new construtos_1.Super(0, palavraChave, metodo);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.COLCHETE_ESQUERDO)) {
             var valores = [];
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.COLCHETE_DIREITO)) {
-                return new construtos_1.Vetor([]);
+                return new construtos_1.Vetor(0, []);
             }
             while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.COLCHETE_DIREITO)) {
                 var valor = this.atribuir();
                 valores.push(valor);
-                if (this.simboloAtual().tipo !== tiposDeSimbolos_1.default.COLCHETE_DIREITO) {
-                    this.consumir(tiposDeSimbolos_1.default.VIRGULA, "Esperado vírgula antes da próxima expressão.");
+                if (this.simboloAtual().tipo !==
+                    tiposDeSimbolos_1.default.COLCHETE_DIREITO) {
+                    this.consumir(tiposDeSimbolos_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
-            return new construtos_1.Vetor(valores);
+            return new construtos_1.Vetor(0, valores);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CHAVE_ESQUERDA)) {
             var chaves = [];
             var valores = [];
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CHAVE_DIREITA)) {
-                return new construtos_1.Dicionario([], []);
+                return new construtos_1.Dicionario(0, [], []);
             }
             while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CHAVE_DIREITA)) {
                 var chave = this.atribuir();
@@ -124,44 +133,45 @@ var Parser = /** @class */ (function () {
                 chaves.push(chave);
                 valores.push(valor);
                 if (this.simboloAtual().tipo !== tiposDeSimbolos_1.default.CHAVE_DIREITA) {
-                    this.consumir(tiposDeSimbolos_1.default.VIRGULA, "Esperado vírgula antes da próxima expressão.");
+                    this.consumir(tiposDeSimbolos_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                 }
             }
-            return new construtos_1.Dicionario(chaves, valores);
+            return new construtos_1.Dicionario(0, chaves, valores);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.FUNÇÃO))
-            return this.corpoDaFuncao("função");
+            return this.corpoDaFuncao('função');
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.FUNCAO))
-            return this.corpoDaFuncao("funcao");
+            return this.corpoDaFuncao('funcao');
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.FALSO))
-            return new construtos_1.Literal(false);
+            return new construtos_1.Literal(0, false);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.VERDADEIRO))
-            return new construtos_1.Literal(true);
+            return new construtos_1.Literal(0, true);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.NULO))
-            return new construtos_1.Literal(null);
+            return new construtos_1.Literal(0, null);
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.ISTO))
-            return new construtos_1.Isto(this.voltar());
+            return new construtos_1.Isto(0, this.simboloAnterior());
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.NUMERO, tiposDeSimbolos_1.default.TEXTO)) {
-            return new construtos_1.Literal(this.voltar().literal);
+            var simboloAnterior = this.simboloAnterior();
+            return new construtos_1.Literal(Number(simboloAnterior.linha), simboloAnterior.literal);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
-            return new construtos_1.Variavel(this.voltar());
+            return new construtos_1.Variavel(this.simboloAnterior());
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO)) {
             var expr = this.expressao();
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-            return new construtos_1.Grouping(expr);
+            return new construtos_1.Agrupamento(0, expr);
         }
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.IMPORTAR))
             return this.declaracaoImportar();
-        throw this.erro(this.simboloAtual(), "Esperado expressão.");
+        throw this.erro(this.simboloAtual(), 'Esperado expressão.');
     };
-    Parser.prototype.finalizarChamada = function (entidadeChamada) {
+    AvaliadorSintatico.prototype.finalizarChamada = function (entidadeChamada) {
         var argumentos = [];
-        if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
-                    throw this.erro(this.simboloAtual(), "Não pode haver mais de 255 argumentos.");
+                    throw this.erro(this.simboloAtual(), 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
             } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.VIRGULA));
@@ -169,200 +179,201 @@ var Parser = /** @class */ (function () {
         var parenteseDireito = this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(entidadeChamada, parenteseDireito, argumentos);
     };
-    Parser.prototype.chamar = function () {
-        var expr = this.primario();
+    AvaliadorSintatico.prototype.chamar = function () {
+        var expressao = this.primario();
         while (true) {
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO)) {
-                expr = this.finalizarChamada(expr);
+                expressao = this.finalizarChamada(expressao);
             }
             else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PONTO)) {
                 var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
-                expr = new construtos_1.Get(expr, nome);
+                expressao = new construtos_1.AcessoMetodo(expressao, nome);
             }
             else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.COLCHETE_ESQUERDO)) {
                 var indice = this.expressao();
-                var closeBracket = this.consumir(tiposDeSimbolos_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
-                expr = new construtos_1.Subscript(expr, indice, closeBracket);
+                var simboloFechamento = this.consumir(tiposDeSimbolos_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                expressao = new construtos_1.AcessoIndiceVariavel(expressao, indice, simboloFechamento);
             }
             else {
                 break;
             }
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.unario = function () {
+    AvaliadorSintatico.prototype.unario = function () {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.NEGACAO, tiposDeSimbolos_1.default.SUBTRACAO, tiposDeSimbolos_1.default.BIT_NOT)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.unario();
             return new construtos_1.Unario(operador, direito);
         }
         return this.chamar();
     };
-    Parser.prototype.exponenciacao = function () {
-        var expr = this.unario();
+    AvaliadorSintatico.prototype.exponenciacao = function () {
+        var expressao = this.unario();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.EXPONENCIACAO)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.unario();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.multiplicar = function () {
-        var expr = this.exponenciacao();
+    AvaliadorSintatico.prototype.multiplicar = function () {
+        var expressao = this.exponenciacao();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.DIVISAO, tiposDeSimbolos_1.default.MULTIPLICACAO, tiposDeSimbolos_1.default.MODULO)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.exponenciacao();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.adicionar = function () {
-        var expr = this.multiplicar();
+    AvaliadorSintatico.prototype.adicionar = function () {
+        var expressao = this.multiplicar();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SUBTRACAO, tiposDeSimbolos_1.default.ADICAO)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.multiplicar();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.bitFill = function () {
-        var expr = this.adicionar();
+    AvaliadorSintatico.prototype.bitFill = function () {
+        var expressao = this.adicionar();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.MENOR_MENOR, tiposDeSimbolos_1.default.MAIOR_MAIOR)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.adicionar();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.bitE = function () {
-        var expr = this.bitFill();
+    AvaliadorSintatico.prototype.bitE = function () {
+        var expressao = this.bitFill();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.BIT_AND)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.bitFill();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.bitOu = function () {
-        var expr = this.bitE();
+    AvaliadorSintatico.prototype.bitOu = function () {
+        var expressao = this.bitE();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.BIT_OR, tiposDeSimbolos_1.default.BIT_XOR)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.bitE();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.comparar = function () {
-        var expr = this.bitOu();
+    AvaliadorSintatico.prototype.comparar = function () {
+        var expressao = this.bitOu();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.MAIOR, tiposDeSimbolos_1.default.MAIOR_IGUAL, tiposDeSimbolos_1.default.MENOR, tiposDeSimbolos_1.default.MENOR_IGUAL)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.bitOu();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.comparacaoIgualdade = function () {
-        var expr = this.comparar();
+    AvaliadorSintatico.prototype.comparacaoIgualdade = function () {
+        var expressao = this.comparar();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.DIFERENTE, tiposDeSimbolos_1.default.IGUAL_IGUAL)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.comparar();
-            expr = new construtos_1.Binario(expr, operador, direito);
+            expressao = new construtos_1.Binario(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.em = function () {
-        var expr = this.comparacaoIgualdade();
+    AvaliadorSintatico.prototype.em = function () {
+        var expressao = this.comparacaoIgualdade();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.EM)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.comparacaoIgualdade();
-            expr = new construtos_1.Logical(expr, operador, direito);
+            expressao = new construtos_1.Logico(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.e = function () {
-        var expr = this.em();
+    AvaliadorSintatico.prototype.e = function () {
+        var expressao = this.em();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.E)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.em();
-            expr = new construtos_1.Logical(expr, operador, direito);
+            expressao = new construtos_1.Logico(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.ou = function () {
-        var expr = this.e();
+    AvaliadorSintatico.prototype.ou = function () {
+        var expressao = this.e();
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.OU)) {
-            var operador = this.voltar();
+            var operador = this.simboloAnterior();
             var direito = this.e();
-            expr = new construtos_1.Logical(expr, operador, direito);
+            expressao = new construtos_1.Logico(expressao, operador, direito);
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.atribuir = function () {
-        var expr = this.ou();
+    AvaliadorSintatico.prototype.atribuir = function () {
+        var expressao = this.ou();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.MAIS_IGUAL)) {
-            var igual = this.voltar();
+            var igual = this.simboloAnterior();
             var valor = this.atribuir();
-            if (expr instanceof construtos_1.Variavel) {
-                var nome = expr.nome;
-                return new construtos_1.Atribuir(nome, valor);
+            if (expressao instanceof construtos_1.Variavel) {
+                var simbolo = expressao.simbolo;
+                return new construtos_1.Atribuir(simbolo, valor);
             }
-            else if (expr instanceof construtos_1.Get) {
-                var get = expr;
-                return new construtos_1.Conjunto(get.objeto, get.nome, valor);
+            else if (expressao instanceof construtos_1.AcessoMetodo) {
+                var get = expressao;
+                return new construtos_1.Conjunto(0, get.objeto, get.simbolo, valor);
             }
-            else if (expr instanceof construtos_1.Subscript) {
-                return new construtos_1.AtribuicaoSobrescrita(expr.entidadeChamada, expr.indice, valor);
+            else if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
+                return new construtos_1.AtribuicaoSobrescrita(0, expressao.entidadeChamada, expressao.indice, valor);
             }
-            this.erro(igual, "Tarefa de atribuição inválida");
+            this.erro(igual, 'Tarefa de atribuição inválida');
         }
-        return expr;
+        return expressao;
     };
-    Parser.prototype.expressao = function () {
+    AvaliadorSintatico.prototype.expressao = function () {
         return this.atribuir();
     };
-    Parser.prototype.declaracaoMostrar = function () {
+    AvaliadorSintatico.prototype.declaracaoEscreva = function () {
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
-        var valor = this.expressao();
+        var simbolo = this.expressao();
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
-        return new declaracoes_1.Escreva(valor);
+        return new declaracoes_1.Escreva(simbolo);
     };
-    Parser.prototype.declaracaoExpressao = function () {
-        var expr = this.expressao();
-        return new declaracoes_1.Expressao(expr);
+    AvaliadorSintatico.prototype.declaracaoExpressao = function () {
+        var expressao = this.expressao();
+        return new declaracoes_1.Expressao(expressao);
     };
-    Parser.prototype.blocoEscopo = function () {
+    AvaliadorSintatico.prototype.blocoEscopo = function () {
         var declaracoes = [];
-        while (!this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
             !this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
         this.consumir(tiposDeSimbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
         return declaracoes;
     };
-    Parser.prototype.declaracaoSe = function () {
+    AvaliadorSintatico.prototype.declaracaoSe = function () {
+        var simboloSe = this.simboloAnterior();
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'se'.");
         var condicao = this.expressao();
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após condição do se.");
-        var thenBranch = this.resolverDeclaracao();
-        var elifBranches = [];
+        var caminhoEntao = this.resolverDeclaracao();
+        var caminhosSeSenao = [];
         while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SENAOSE, tiposDeSimbolos_1.default.SENÃOSE)) {
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'senaose' ou 'senãose'.");
-            var elifCondition = this.expressao();
+            var condicaoSeSenao = this.expressao();
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após codição do 'senaose' ou 'senãose'.");
-            var branch = this.resolverDeclaracao();
-            elifBranches.push({
-                condition: elifCondition,
-                branch: branch,
+            var caminho = this.resolverDeclaracao();
+            caminhosSeSenao.push({
+                condicao: condicaoSeSenao,
+                caminho: caminho,
             });
         }
-        var elseBranch = null;
+        var caminhoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SENAO, tiposDeSimbolos_1.default.SENÃO)) {
-            elseBranch = this.resolverDeclaracao();
+            caminhoSenao = this.resolverDeclaracao();
         }
-        return new declaracoes_1.Se(condicao, thenBranch, elifBranches, elseBranch);
+        return new declaracoes_1.Se(Number(simboloSe.linha), condicao, caminhoEntao, caminhosSeSenao, caminhoSenao);
     };
-    Parser.prototype.declaracaoEnquanto = function () {
+    AvaliadorSintatico.prototype.declaracaoEnquanto = function () {
         try {
             this.ciclos += 1;
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'enquanto'.");
@@ -375,8 +386,9 @@ var Parser = /** @class */ (function () {
             this.ciclos -= 1;
         }
     };
-    Parser.prototype.declaracaoPara = function () {
+    AvaliadorSintatico.prototype.declaracaoPara = function () {
         try {
+            var simboloPara = this.simboloAnterior();
             this.ciclos += 1;
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após 'para'.");
             var inicializador = void 0;
@@ -390,137 +402,140 @@ var Parser = /** @class */ (function () {
                 inicializador = this.declaracaoExpressao();
             }
             var condicao = null;
-            if (!this.verificar(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
                 condicao = this.expressao();
             }
             var incrementar = null;
-            if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+            if (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
                 incrementar = this.expressao();
             }
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas");
             var corpo = this.resolverDeclaracao();
-            return new declaracoes_1.Para(inicializador, condicao, incrementar, corpo);
+            return new declaracoes_1.Para(Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
         }
         finally {
             this.ciclos -= 1;
         }
     };
-    Parser.prototype.declaracaoInterromper = function () {
+    AvaliadorSintatico.prototype.declaracaoSustar = function () {
         if (this.ciclos < 1) {
-            this.erro(this.voltar(), "'pausa' deve estar dentro de um loop.");
+            this.erro(this.simboloAnterior(), "'sustar' ou 'pausa' deve estar dentro de um loop.");
         }
-        return new declaracoes_1.Pausa();
+        return new declaracoes_1.Sustar();
     };
-    Parser.prototype.declaracaoContinua = function () {
+    AvaliadorSintatico.prototype.declaracaoContinua = function () {
         if (this.ciclos < 1) {
-            this.erro(this.voltar(), "'continua' precisa estar em um laço de repetição.");
+            this.erro(this.simboloAnterior(), "'continua' precisa estar em um laço de repetição.");
         }
         return new declaracoes_1.Continua();
     };
-    Parser.prototype.declaracaoRetorna = function () {
-        var palavraChave = this.voltar();
+    AvaliadorSintatico.prototype.declaracaoRetorna = function () {
+        var palavraChave = this.simboloAnterior();
         var valor = null;
-        if (!this.verificar(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PONTO_E_VIRGULA)) {
             valor = this.expressao();
         }
         return new declaracoes_1.Retorna(palavraChave, valor);
     };
-    Parser.prototype.declaracaoEscolha = function () {
+    AvaliadorSintatico.prototype.declaracaoEscolha = function () {
         try {
             this.ciclos += 1;
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '{' após 'escolha'.");
             var condicao = this.expressao();
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado '}' após a condição de 'escolha'.");
             this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
-            var branches = [];
-            var defaultBranch = null;
+            var caminhos = [];
+            var caminhoPadrao = null;
             while (!this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
                 !this.estaNoFinal()) {
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CASO)) {
                     var branchConditions = [this.expressao()];
                     this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
-                    while (this.verificar(tiposDeSimbolos_1.default.CASO)) {
+                    while (this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CASO)) {
                         this.consumir(tiposDeSimbolos_1.default.CASO, null);
                         branchConditions.push(this.expressao());
                         this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
-                    var stmts = [];
+                    var declaracoes = [];
                     do {
-                        stmts.push(this.resolverDeclaracao());
-                    } while (!this.verificar(tiposDeSimbolos_1.default.CASO) &&
-                        !this.verificar(tiposDeSimbolos_1.default.PADRAO) &&
-                        !this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA));
-                    branches.push({
+                        declaracoes.push(this.resolverDeclaracao());
+                    } while (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CHAVE_DIREITA));
+                    caminhos.push({
                         conditions: branchConditions,
-                        stmts: stmts,
+                        declaracoes: declaracoes,
                     });
                 }
                 else if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PADRAO)) {
-                    if (defaultBranch !== null)
-                        throw new erros_avaliador_1.ErroAvaliador("Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                    if (caminhoPadrao !== null) {
+                        var excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simboloAtual(), "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
+                        this.erros.push(excecao);
+                        throw excecao;
+                    }
                     this.consumir(tiposDeSimbolos_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
-                    var stmts = [];
+                    var declaracoes = [];
                     do {
-                        stmts.push(this.resolverDeclaracao());
-                    } while (!this.verificar(tiposDeSimbolos_1.default.CASO) &&
-                        !this.verificar(tiposDeSimbolos_1.default.PADRAO) &&
-                        !this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA));
-                    defaultBranch = {
-                        stmts: stmts,
+                        declaracoes.push(this.resolverDeclaracao());
+                    } while (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CHAVE_DIREITA));
+                    caminhoPadrao = {
+                        declaracoes: declaracoes,
                     };
                 }
             }
-            return new declaracoes_1.Escolha(condicao, branches, defaultBranch);
+            return new declaracoes_1.Escolha(condicao, caminhos, caminhoPadrao);
         }
         finally {
             this.ciclos -= 1;
         }
     };
-    Parser.prototype.declaracaoImportar = function () {
+    AvaliadorSintatico.prototype.declaracaoImportar = function () {
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
         var caminho = this.expressao();
-        var closeBracket = this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
-        return new declaracoes_1.Importar(caminho, closeBracket);
+        var simboloFechamento = this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        return new declaracoes_1.Importar(caminho, simboloFechamento);
     };
-    Parser.prototype.declaracaoTentar = function () {
+    AvaliadorSintatico.prototype.declaracaoTente = function () {
         this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
-        var tryBlock = this.blocoEscopo();
-        var catchBlock = null;
+        var blocoTente = this.blocoEscopo();
+        var blocoPegue = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PEGUE)) {
             this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
-            catchBlock = this.blocoEscopo();
+            blocoPegue = this.blocoEscopo();
         }
-        var elseBlock = null;
+        var blocoSenao = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SENAO, tiposDeSimbolos_1.default.SENÃO)) {
             this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
-            elseBlock = this.blocoEscopo();
+            blocoSenao = this.blocoEscopo();
         }
-        var finallyBlock = null;
+        var blocoFinalmente = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.FINALMENTE)) {
             this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
-            finallyBlock = this.blocoEscopo();
+            blocoFinalmente = this.blocoEscopo();
         }
-        return new declaracoes_1.Tente(tryBlock, catchBlock, elseBlock, finallyBlock);
+        return new declaracoes_1.Tente(blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
     };
-    Parser.prototype.declaracaoFazer = function () {
+    AvaliadorSintatico.prototype.declaracaoFazer = function () {
         try {
             this.ciclos += 1;
-            var doBranch = this.resolverDeclaracao();
+            var caminhoFazer = this.resolverDeclaracao();
             this.consumir(tiposDeSimbolos_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração 'enquanto'.");
-            var whileCondition = this.expressao();
+            var condicaoEnquanto = this.expressao();
             this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração do 'enquanto'.");
-            return new declaracoes_1.Fazer(doBranch, whileCondition);
+            return new declaracoes_1.Fazer(caminhoFazer, condicaoEnquanto);
         }
         finally {
             this.ciclos -= 1;
         }
     };
-    Parser.prototype.resolverDeclaracao = function () {
+    AvaliadorSintatico.prototype.resolverDeclaracao = function () {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.FAZER))
             return this.declaracaoFazer();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.TENTE))
-            return this.declaracaoTentar();
+            return this.declaracaoTente();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.ESCOLHA))
             return this.declaracaoEscolha();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.RETORNA))
@@ -528,7 +543,7 @@ var Parser = /** @class */ (function () {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CONTINUA))
             return this.declaracaoContinua();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PAUSA))
-            return this.declaracaoInterromper();
+            return this.declaracaoSustar();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.PARA))
             return this.declaracaoPara();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.ENQUANTO))
@@ -536,81 +551,81 @@ var Parser = /** @class */ (function () {
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.SE))
             return this.declaracaoSe();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.ESCREVA))
-            return this.declaracaoMostrar();
+            return this.declaracaoEscreva();
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.CHAVE_ESQUERDA))
             return new declaracoes_1.Bloco(this.blocoEscopo());
         return this.declaracaoExpressao();
     };
-    Parser.prototype.declaracaoDeVariavel = function () {
-        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome de variável.");
+    AvaliadorSintatico.prototype.declaracaoDeVariavel = function () {
+        var simbolo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, 'Esperado nome de variável.');
         var inicializador = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.IGUAL) ||
             this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.MAIS_IGUAL)) {
             inicializador = this.expressao();
         }
-        return new declaracoes_1.Var(nome, inicializador);
+        return new declaracoes_1.Var(simbolo, inicializador);
     };
-    Parser.prototype.funcao = function (tipo) {
-        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome ".concat(tipo, "."));
-        return new declaracoes_1.Funcao(nome, this.corpoDaFuncao(tipo));
+    AvaliadorSintatico.prototype.funcao = function (tipo) {
+        var simbolo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome ".concat(tipo, "."));
+        return new declaracoes_1.Funcao(simbolo, this.corpoDaFuncao(tipo));
     };
-    Parser.prototype.corpoDaFuncao = function (tipo) {
+    AvaliadorSintatico.prototype.corpoDaFuncao = function (tipo) {
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_ESQUERDO, "Esperado '(' ap\u00F3s o nome ".concat(tipo, "."));
         var parametros = [];
-        if (!this.verificar(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.PARENTESE_DIREITO)) {
             do {
                 if (parametros.length >= 255) {
-                    this.erro(this.simboloAtual(), "Não pode haver mais de 255 parâmetros");
+                    this.erro(this.simboloAtual(), 'Não pode haver mais de 255 parâmetros');
                 }
                 var paramObj = {};
                 if (this.simboloAtual().tipo === tiposDeSimbolos_1.default.MULTIPLICACAO) {
                     this.consumir(tiposDeSimbolos_1.default.MULTIPLICACAO, null);
-                    paramObj["tipo"] = "wildcard";
+                    paramObj['tipo'] = 'wildcard';
                 }
                 else {
-                    paramObj["tipo"] = "standard";
+                    paramObj['tipo'] = 'standard';
                 }
-                paramObj["nome"] = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome do parâmetro.");
+                paramObj['nome'] = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
                 if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.IGUAL)) {
-                    paramObj["default"] = this.primario();
+                    paramObj['default'] = this.primario();
                 }
                 parametros.push(paramObj);
-                if (paramObj["tipo"] === "wildcard")
+                if (paramObj['tipo'] === 'wildcard')
                     break;
             } while (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.VIRGULA));
         }
         this.consumir(tiposDeSimbolos_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do ".concat(tipo, "."));
         var corpo = this.blocoEscopo();
-        return new construtos_1.Funcao(parametros, corpo);
+        return new construtos_1.Funcao(0, parametros, corpo);
     };
-    Parser.prototype.declaracaoDeClasse = function () {
-        var nome = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome da classe.");
+    AvaliadorSintatico.prototype.declaracaoDeClasse = function () {
+        var simbolo = this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
         var superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.HERDA)) {
-            this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, "Esperado nome da SuperClasse.");
-            superClasse = new construtos_1.Variavel(this.voltar());
+            this.consumir(tiposDeSimbolos_1.default.IDENTIFICADOR, 'Esperado nome da SuperClasse.');
+            superClasse = new construtos_1.Variavel(this.simboloAnterior());
         }
         this.consumir(tiposDeSimbolos_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
         var metodos = [];
-        while (!this.verificar(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
+        while (!this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.CHAVE_DIREITA) &&
             !this.estaNoFinal()) {
-            metodos.push(this.funcao("método"));
+            metodos.push(this.funcao('método'));
         }
         this.consumir(tiposDeSimbolos_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
-        return new declaracoes_1.Classe(nome, superClasse, metodos);
+        return new declaracoes_1.Classe(simbolo, superClasse, metodos);
     };
-    Parser.prototype.declaracao = function () {
+    AvaliadorSintatico.prototype.declaracao = function () {
         try {
-            if (this.verificar(tiposDeSimbolos_1.default.FUNÇÃO) &&
-                this.verificarProximo(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
+            if (this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.FUNÇÃO) &&
+                this.verificarTipoProximoSimbolo(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
                 this.consumir(tiposDeSimbolos_1.default.FUNÇÃO, null);
-                return this.funcao("função");
+                return this.funcao('função');
             }
-            if (this.verificar(tiposDeSimbolos_1.default.FUNCAO) &&
-                this.verificarProximo(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
+            if (this.verificarTipoSimboloAtual(tiposDeSimbolos_1.default.FUNCAO) &&
+                this.verificarTipoProximoSimbolo(tiposDeSimbolos_1.default.IDENTIFICADOR)) {
                 this.consumir(tiposDeSimbolos_1.default.FUNCAO, null);
-                return this.funcao("funcao");
+                return this.funcao('funcao');
             }
             if (this.verificarSeSimboloAtualEIgualA(tiposDeSimbolos_1.default.VARIAVEL))
                 return this.declaracaoDeVariavel();
@@ -623,7 +638,9 @@ var Parser = /** @class */ (function () {
             return null;
         }
     };
-    Parser.prototype.analisar = function (simbolos) {
+    AvaliadorSintatico.prototype.analisar = function (simbolos) {
+        var inicioAnalise = perf_hooks_1.performance.now();
+        this.erros = [];
         this.atual = 0;
         this.ciclos = 0;
         if (simbolos) {
@@ -633,9 +650,16 @@ var Parser = /** @class */ (function () {
         while (!this.estaNoFinal()) {
             declaracoes.push(this.declaracao());
         }
-        return declaracoes;
+        var fimAnalise = perf_hooks_1.performance.now();
+        if (this.performance) {
+            console.log("[Avaliador Sint\u00E1tico] Tempo para an\u00E1lise: ".concat(fimAnalise - inicioAnalise, "ms"));
+        }
+        return {
+            declaracoes: declaracoes,
+            erros: this.erros
+        };
     };
-    return Parser;
+    return AvaliadorSintatico;
 }());
-exports.Parser = Parser;
+exports.AvaliadorSintatico = AvaliadorSintatico;
 //# sourceMappingURL=index.js.map