@designliquido/delegua 0.2.0 → 0.2.3

package/{src → fontes}/interpretador/dialetos/egua-classico.js

@@ -1,13 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InterpretadorEguaClassico = void 0;
-var tiposDeSimbolos_1 = require("../../tiposDeSimbolos");
+var caminho = __importStar(require("path"));
+var fs = __importStar(require("fs"));
+var tiposDeSimbolos_1 = __importDefault(require("../../tiposDeSimbolos"));
 var ambiente_1 = require("../../ambiente");
 var delegua_1 = require("../../delegua");
-var biblioteca_global_1 = require("../../bibliotecas/biblioteca-global");
-var caminho = require("path");
-var fs = require("fs");
-var importar_biblioteca_1 = require("../../bibliotecas/importar-biblioteca");
+var biblioteca_global_1 = __importDefault(require("../../bibliotecas/biblioteca-global"));
+var importar_biblioteca_1 = __importDefault(require("../../bibliotecas/importar-biblioteca"));
 var chamavel_1 = require("../../estruturas/chamavel");
 var funcao_padrao_1 = require("../../estruturas/funcao-padrao");
 var classe_1 = require("../../estruturas/classe");
@@ -28,31 +54,28 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         this.locais = new Map();
         this.global = (0, biblioteca_global_1.default)(this, this.global);
     }
-    InterpretadorEguaClassico.prototype.resolver = function (expr, depth) {
-        this.locais.set(expr, depth);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoLiteral = function (expr) {
-        return expr.valor;
+    InterpretadorEguaClassico.prototype.visitarExpressaoLiteral = function (expressao) {
+        return expressao.valor;
     };
-    InterpretadorEguaClassico.prototype.avaliar = function (expr) {
-        if (expr.aceitar) {
-            return expr.aceitar(this);
+    InterpretadorEguaClassico.prototype.avaliar = function (expressao) {
+        if (expressao.aceitar) {
+            return expressao.aceitar(this);
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAgrupamento = function (expr) {
-        return this.avaliar(expr.expressao);
+    InterpretadorEguaClassico.prototype.visitarExpressaoAgrupamento = function (expressao) {
+        return this.avaliar(expressao.expressao);
     };
     InterpretadorEguaClassico.prototype.eVerdadeiro = function (objeto) {
         if (objeto === null)
             return false;
-        if (typeof objeto === "boolean")
+        if (typeof objeto === 'boolean')
             return Boolean(objeto);
         return true;
     };
     InterpretadorEguaClassico.prototype.verificarOperandoNumero = function (operador, operand) {
-        if (typeof operand === "number")
+        if (typeof operand === 'number')
             return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, "Operador precisa ser um número.");
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operador precisa ser um número.', operador.linha);
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoUnaria = function (expr) {
         var direita = this.avaliar(expr.direita);
@@ -75,9 +98,9 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         return esquerda === direita;
     };
     InterpretadorEguaClassico.prototype.verificarOperandosNumeros = function (operador, direita, esquerda) {
-        if (typeof direita === "number" && typeof esquerda === "number")
+        if (typeof direita === 'number' && typeof esquerda === 'number')
             return;
-        throw new excecoes_1.ErroEmTempoDeExecucao(operador, "Operadores precisam ser números.");
+        throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
     };
     InterpretadorEguaClassico.prototype.visitarExpressaoBinaria = function (expr) {
         var esquerda = this.avaliar(expr.esquerda);
@@ -102,14 +125,15 @@ var InterpretadorEguaClassico = /** @class */ (function () {
                 this.verificarOperandosNumeros(expr.operador, esquerda, direita);
                 return Number(esquerda) - Number(direita);
             case tiposDeSimbolos_1.default.ADICAO:
-                if (typeof esquerda === "number" && typeof direita === "number") {
+                if (typeof esquerda === 'number' &&
+                    typeof direita === 'number') {
                     return Number(esquerda) + Number(direita);
                 }
-                else if (typeof esquerda === "string" &&
-                    typeof direita === "string") {
+                else if (typeof esquerda === 'string' &&
+                    typeof direita === 'string') {
                     return String(esquerda) + String(direita);
                 }
-                throw new excecoes_1.ErroEmTempoDeExecucao(expr.operador, "Operadores precisam ser dois números ou duas strings.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expr.operador, 'Operadores precisam ser dois números ou duas strings.');
             case tiposDeSimbolos_1.default.DIVISAO:
                 this.verificarOperandosNumeros(expr.operador, esquerda, direita);
                 return Number(esquerda) / Number(direita);
@@ -141,14 +165,14 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         }
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeChamada = function (expr) {
-        var entidadeChamada = this.avaliar(expr.entidadeChamada);
+    InterpretadorEguaClassico.prototype.visitarExpressaoDeChamada = function (expressao) {
+        var entidadeChamada = this.avaliar(expressao.entidadeChamada);
         var argumentos = [];
-        for (var i = 0; i < expr.argumentos.length; i++) {
-            argumentos.push(this.avaliar(expr.argumentos[i]));
+        for (var i = 0; i < expressao.argumentos.length; i++) {
+            argumentos.push(this.avaliar(expressao.argumentos[i]));
         }
         if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.parentese, "Só pode chamar função ou classe.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
         }
         var parametros;
         if (entidadeChamada instanceof funcao_1.DeleguaFuncao) {
@@ -172,150 +196,150 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         else {
             if (parametros &&
                 parametros.length > 0 &&
-                parametros[parametros.length - 1]["tipo"] === "wildcard") {
+                parametros[parametros.length - 1]['tipo'] === 'wildcard') {
                 var novosArgumentos = argumentos.slice(0, parametros.length - 1);
                 novosArgumentos.push(argumentos.slice(parametros.length - 1, argumentos.length));
                 argumentos = novosArgumentos;
             }
         }
         if (entidadeChamada instanceof funcao_padrao_1.FuncaoPadrao) {
-            return entidadeChamada.chamar(this, argumentos, expr.entidadeChamada.nome);
+            return entidadeChamada.chamar(this, argumentos, expressao.entidadeChamada.nome);
         }
         return entidadeChamada.chamar(this, argumentos);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeAtribuicao = function (expr) {
-        var valor = this.avaliar(expr.valor);
-        var distancia = this.locais.get(expr);
+    InterpretadorEguaClassico.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
+        var valor = this.avaliar(expressao.valor);
+        var distancia = this.locais.get(expressao);
         if (distancia !== undefined) {
-            this.ambiente.atribuirVariavelEm(distancia, expr.nome, valor);
+            this.ambiente.atribuirVariavelEm(distancia, expressao.simbolo, valor);
         }
         else {
-            this.ambiente.atribuirVariavel(expr.nome, valor);
+            this.ambiente.atribuirVariavel(expressao.simbolo, valor);
         }
         return valor;
     };
-    InterpretadorEguaClassico.prototype.procurarVariavel = function (nome, expr) {
+    InterpretadorEguaClassico.prototype.procurarVariavel = function (simbolo, expr) {
         var distancia = this.locais.get(expr);
         if (distancia !== undefined) {
-            return this.ambiente.obterVariavelEm(distancia, nome.lexema);
+            return this.ambiente.obterVariavelEm(distancia, simbolo.lexema);
         }
         else {
-            return this.global.obterVariavel(nome);
+            return this.global.obterVariavel(simbolo);
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeVariavel = function (expr) {
-        return this.procurarVariavel(expr.nome, expr);
+    InterpretadorEguaClassico.prototype.visitarExpressaoDeVariavel = function (expressao) {
+        return this.procurarVariavel(expressao.simbolo, expressao);
     };
-    InterpretadorEguaClassico.prototype.visitarDeclaracaoDeExpressao = function (stmt) {
-        return this.avaliar(stmt.expressao);
+    InterpretadorEguaClassico.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
+        return this.avaliar(declaracao.expressao);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoLogica = function (expr) {
-        var esquerda = this.avaliar(expr.esquerda);
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.EM) {
-            var direita = this.avaliar(expr.direita);
-            if (Array.isArray(direita) || typeof direita === "string") {
+    InterpretadorEguaClassico.prototype.visitarExpressaoLogica = function (expressao) {
+        var esquerda = this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.EM) {
+            var direita = this.avaliar(expressao.direita);
+            if (Array.isArray(direita) || typeof direita === 'string') {
                 return direita.includes(esquerda);
             }
             else if (direita.constructor === Object) {
                 return esquerda in direita;
             }
             else {
-                throw new excecoes_1.ErroEmTempoDeExecucao("Tipo de chamada inválida com 'em'.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
             }
         }
         // se um estado for verdadeiro, retorna verdadeiro
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.OU) {
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.OU) {
             if (this.eVerdadeiro(esquerda))
                 return esquerda;
         }
         // se um estado for falso, retorna falso
-        if (expr.operador.tipo === tiposDeSimbolos_1.default.E) {
+        if (expressao.operador.tipo === tiposDeSimbolos_1.default.E) {
             if (!this.eVerdadeiro(esquerda))
                 return esquerda;
         }
-        return this.avaliar(expr.direita);
+        return this.avaliar(expressao.direita);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoSe = function (stmt) {
-        if (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
-            this.executar(stmt.thenBranch);
+    InterpretadorEguaClassico.prototype.visitarExpressaoSe = function (declaracao) {
+        if (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
+            this.executar(declaracao.caminhoEntao);
             return null;
         }
-        for (var i = 0; i < stmt.elifBranches.length; i++) {
-            var atual = stmt.elifBranches[i];
+        for (var i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            var atual = declaracao.caminhosSeSenao[i];
             if (this.eVerdadeiro(this.avaliar(atual.condicao))) {
-                this.executar(atual.branch);
+                this.executar(atual.caminho);
                 return null;
             }
         }
-        if (stmt.elseBranch !== null) {
-            this.executar(stmt.elseBranch);
+        if (declaracao.caminhoSenao !== null) {
+            this.executar(declaracao.caminhoSenao);
         }
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoPara = function (stmt) {
-        if (stmt.inicializador !== null) {
-            this.avaliar(stmt.inicializador);
+    InterpretadorEguaClassico.prototype.visitarExpressaoPara = function (declaracao) {
+        if (declaracao.inicializador !== null) {
+            this.avaliar(declaracao.inicializador);
         }
         while (true) {
-            if (stmt.condicao !== null) {
-                if (!this.eVerdadeiro(this.avaliar(stmt.condicao))) {
+            if (declaracao.condicao !== null) {
+                if (!this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
                     break;
                 }
             }
             try {
-                this.executar(stmt.corpo);
+                this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
-                else if (erro instanceof excecoes_1.ContinueException) {
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
                 }
                 else {
                     throw erro;
                 }
             }
-            if (stmt.incrementar !== null) {
-                this.avaliar(stmt.incrementar);
+            if (declaracao.incrementar !== null) {
+                this.avaliar(declaracao.incrementar);
             }
         }
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoFazer = function (stmt) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoFazer = function (declaracao) {
         do {
             try {
-                this.executar(stmt.doBranch);
+                this.executar(declaracao.caminhoFazer);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
-                else if (erro instanceof excecoes_1.ContinueException) {
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
                 }
                 else {
                     throw erro;
                 }
             }
-        } while (this.eVerdadeiro(this.avaliar(stmt.whileCondition)));
+        } while (this.eVerdadeiro(this.avaliar(declaracao.condicaoEnquanto)));
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEscolha = function (stmt) {
-        var switchCondition = this.avaliar(stmt.condicao);
-        var branches = stmt.branches;
-        var defaultBranch = stmt.defaultBranch;
-        var matched = false;
+    InterpretadorEguaClassico.prototype.visitarExpressaoEscolha = function (declaracao) {
+        var condicaoEscolha = this.avaliar(declaracao.condicao);
+        var caminhos = declaracao.caminhos;
+        var caminhoPadrao = declaracao.caminhoPadrao;
+        var encontrado = false;
         try {
-            for (var i = 0; i < branches.length; i++) {
-                var branch = branches[i];
-                for (var j = 0; j < branch.conditions.length; j++) {
-                    if (this.avaliar(branch.conditions[j]) === switchCondition) {
-                        matched = true;
+            for (var i = 0; i < caminhos.length; i++) {
+                var caminho_1 = caminhos[i];
+                for (var j = 0; j < caminho_1.conditions.length; j++) {
+                    if (this.avaliar(caminho_1.conditions[j]) === condicaoEscolha) {
+                        encontrado = true;
                         try {
-                            for (var k = 0; k < branch.stmts.length; k++) {
-                                this.executar(branch.stmts[k]);
+                            for (var k = 0; k < caminho_1.declaracoes.length; k++) {
+                                this.executar(caminho_1.declaracoes[k]);
                             }
                         }
                         catch (erro) {
-                            if (erro instanceof excecoes_1.ContinueException) {
+                            if (erro instanceof excecoes_1.ExcecaoContinuar) {
                             }
                             else {
                                 throw erro;
@@ -324,51 +348,51 @@ var InterpretadorEguaClassico = /** @class */ (function () {
                     }
                 }
             }
-            if (defaultBranch !== null && matched === false) {
-                for (var i = 0; i < defaultBranch.stmts.length; i++) {
-                    this.executar(defaultBranch["stmts"][i]);
+            if (caminhoPadrao !== null && encontrado === false) {
+                for (var i = 0; i < caminhoPadrao.declaracoes.length; i++) {
+                    this.executar(caminhoPadrao['declaracoes'][i]);
                 }
             }
         }
         catch (erro) {
-            if (erro instanceof excecoes_1.BreakException) {
+            if (erro instanceof excecoes_1.ExcecaoSustar) {
             }
             else {
                 throw erro;
             }
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoTente = function (stmt) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoTente = function (declaracao) {
         try {
             var sucesso = true;
             try {
-                this.executarBloco(stmt.tryBranch, new ambiente_1.Ambiente(this.ambiente));
+                this.executarBloco(declaracao.caminhoTente, new ambiente_1.Ambiente(this.ambiente));
             }
             catch (erro) {
                 sucesso = false;
-                if (stmt.catchBranch !== null) {
-                    this.executarBloco(stmt.catchBranch, new ambiente_1.Ambiente(this.ambiente));
+                if (declaracao.caminhoPegue !== null) {
+                    this.executarBloco(declaracao.caminhoPegue, new ambiente_1.Ambiente(this.ambiente));
                 }
             }
-            if (sucesso && stmt.elseBranch !== null) {
-                this.executarBloco(stmt.elseBranch, new ambiente_1.Ambiente(this.ambiente));
+            if (sucesso && declaracao.caminhoSenao !== null) {
+                this.executarBloco(declaracao.caminhoSenao, new ambiente_1.Ambiente(this.ambiente));
             }
         }
         finally {
-            if (stmt.finallyBranch !== null)
-                this.executarBloco(stmt.finallyBranch, new ambiente_1.Ambiente(this.ambiente));
+            if (declaracao.caminhoFinalmente !== null)
+                this.executarBloco(declaracao.caminhoFinalmente, new ambiente_1.Ambiente(this.ambiente));
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEnquanto = function (stmt) {
-        while (this.eVerdadeiro(this.avaliar(stmt.condicao))) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoEnquanto = function (declaracao) {
+        while (this.eVerdadeiro(this.avaliar(declaracao.condicao))) {
             try {
-                this.executar(stmt.corpo);
+                this.executar(declaracao.corpo);
             }
             catch (erro) {
-                if (erro instanceof excecoes_1.BreakException) {
+                if (erro instanceof excecoes_1.ExcecaoSustar) {
                     break;
                 }
-                else if (erro instanceof excecoes_1.ContinueException) {
+                else if (erro instanceof excecoes_1.ExcecaoContinuar) {
                 }
                 else {
                     throw erro;
@@ -377,24 +401,23 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         }
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoImportar = function (stmt) {
-        var caminhoRelativo = this.avaliar(stmt.caminho);
+    InterpretadorEguaClassico.prototype.visitarExpressaoImportar = function (declaracao) {
+        var caminhoRelativo = this.avaliar(declaracao.caminho);
         var caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-        // const pastaTotal = caminho.dirname(caminhoTotal);
         var nomeArquivo = caminho.basename(caminhoTotal);
         var dados = (0, importar_biblioteca_1.default)(caminhoRelativo);
         if (dados)
             return dados;
         try {
             if (!fs.existsSync(caminhoTotal)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, "Não foi possível encontrar arquivo importado.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
             }
         }
         catch (erro) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(stmt.closeBracket, "Não foi possível ler o arquivo.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
         }
         dados = fs.readFileSync(caminhoTotal).toString();
-        var delegua = new delegua_1.Delegua(this.Delegua.dialeto, nomeArquivo);
+        var delegua = new delegua_1.Delegua(this.Delegua.dialeto, false, nomeArquivo);
         delegua.executar(dados);
         var exportar = delegua.interpretador.global.valores.exports;
         var eDicionario = function (objeto) { return objeto.constructor === Object; };
@@ -408,8 +431,8 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         }
         return exportar;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEscreva = function (stmt) {
-        var valor = this.avaliar(stmt.expressao);
+    InterpretadorEguaClassico.prototype.visitarExpressaoEscreva = function (declaracao) {
+        var valor = this.avaliar(declaracao.expressao);
         console.log(this.paraTexto(valor));
         return null;
     };
@@ -431,37 +454,37 @@ var InterpretadorEguaClassico = /** @class */ (function () {
             this.ambiente = anterior;
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoBloco = function (stmt) {
-        this.executarBloco(stmt.declaracoes, new ambiente_1.Ambiente(this.ambiente));
+    InterpretadorEguaClassico.prototype.visitarExpressaoBloco = function (declaracao) {
+        this.executarBloco(declaracao.declaracoes, new ambiente_1.Ambiente(this.ambiente));
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoVar = function (stmt) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoVar = function (declaracao) {
         var valor = null;
-        if (stmt.inicializador !== null) {
-            valor = this.avaliar(stmt.inicializador);
+        if (declaracao.inicializador !== null) {
+            valor = this.avaliar(declaracao.inicializador);
         }
-        this.ambiente.definirVariavel(stmt.nome.lexema, valor);
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, valor);
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoContinua = function (stmt) {
-        throw new excecoes_1.ContinueException();
+    InterpretadorEguaClassico.prototype.visitarExpressaoContinua = function (declaracao) {
+        throw new excecoes_1.ExcecaoContinuar();
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoPausa = function (stmt) {
-        throw new excecoes_1.BreakException();
+    InterpretadorEguaClassico.prototype.visitarExpressaoSustar = function (declaracao) {
+        throw new excecoes_1.ExcecaoSustar();
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoRetornar = function (stmt) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoRetornar = function (declaracao) {
         var valor = null;
-        if (stmt.valor != null)
-            valor = this.avaliar(stmt.valor);
-        throw new excecoes_1.ReturnException(valor);
+        if (declaracao.valor != null)
+            valor = this.avaliar(declaracao.valor);
+        throw new excecoes_1.ExcecaoRetornar(valor);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeleguaFuncao = function (expr) {
-        return new funcao_1.DeleguaFuncao(null, expr, this.ambiente, false);
+    InterpretadorEguaClassico.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
+        return new funcao_1.DeleguaFuncao(null, expressao, this.ambiente, false);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
-        var indice = this.avaliar(expr.indice);
-        var valor = this.avaliar(expr.valor);
+    InterpretadorEguaClassico.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
+        var indice = this.avaliar(expressao.indice);
+        var valor = this.avaliar(expressao.valor);
         if (Array.isArray(objeto)) {
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -481,15 +504,15 @@ var InterpretadorEguaClassico = /** @class */ (function () {
             objeto[indice] = valor;
         }
         else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, "Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoVetorIndice = function (expressao) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoAcessoIndiceVariavel = function (expressao) {
         var objeto = this.avaliar(expressao.entidadeChamada);
         var indice = this.avaliar(expressao.indice);
         if (Array.isArray(objeto)) {
             if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Somente inteiros podem ser usados para indexar um vetor.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
             }
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -497,7 +520,7 @@ var InterpretadorEguaClassico = /** @class */ (function () {
                 }
             }
             if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Índice do vetor fora do intervalo.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
             }
             return objeto[indice];
         }
@@ -508,9 +531,9 @@ var InterpretadorEguaClassico = /** @class */ (function () {
             objeto instanceof modulo_1.DeleguaModulo) {
             return objeto[indice] || null;
         }
-        else if (typeof objeto === "string") {
+        else if (typeof objeto === 'string') {
             if (!Number.isInteger(indice)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Somente inteiros podem ser usados para indexar um vetor.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha);
             }
             if (indice < 0 && objeto.length !== 0) {
                 while (indice < 0) {
@@ -518,125 +541,126 @@ var InterpretadorEguaClassico = /** @class */ (function () {
                 }
             }
             if (indice >= objeto.length) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.closeBracket, "Índice fora do tamanho.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
             }
             return objeto.charAt(indice);
         }
         else {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, "Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDefinir = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
+    InterpretadorEguaClassico.prototype.visitarExpressaoDefinir = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
         if (!(objeto instanceof instancia_1.DeleguaInstancia) &&
             objeto.constructor !== Object) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.objeto.nome, "Somente instâncias e dicionários podem possuir campos.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
         }
-        var valor = this.avaliar(expr.valor);
+        var valor = this.avaliar(expressao.valor);
         if (objeto instanceof instancia_1.DeleguaInstancia) {
-            objeto.set(expr.nome, valor);
+            objeto.set(expressao.nome, valor);
             return valor;
         }
         else if (objeto.constructor === Object) {
-            objeto[expr.nome.lexema] = valor;
+            objeto[expressao.simbolo.lexema] = valor;
         }
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoFuncao = function (stmt) {
-        var funcao = new funcao_1.DeleguaFuncao(stmt.nome.lexema, stmt.funcao, this.ambiente, false);
-        this.ambiente.definirVariavel(stmt.nome.lexema, funcao);
+    InterpretadorEguaClassico.prototype.visitarExpressaoFuncao = function (declaracao) {
+        var funcao = new funcao_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao, this.ambiente, false);
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, funcao);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoClasse = function (stmt) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoClasse = function (declaracao) {
         var superClasse = null;
-        if (stmt.superClasse !== null) {
-            superClasse = this.avaliar(stmt.superClasse);
+        if (declaracao.superClasse !== null) {
+            superClasse = this.avaliar(declaracao.superClasse);
             if (!(superClasse instanceof classe_1.DeleguaClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(stmt.superClasse.nome, "SuperClasse precisa ser uma classe.");
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
             }
         }
-        this.ambiente.definirVariavel(stmt.nome.lexema, null);
-        if (stmt.superClasse !== null) {
+        this.ambiente.definirVariavel(declaracao.simbolo.lexema, null);
+        if (declaracao.superClasse !== null) {
             this.ambiente = new ambiente_1.Ambiente(this.ambiente);
-            this.ambiente.definirVariavel("super", superClasse);
+            this.ambiente.definirVariavel('super', superClasse);
         }
         var metodos = {};
-        var definirMetodos = stmt.metodos;
-        for (var i = 0; i < stmt.metodos.length; i++) {
+        var definirMetodos = declaracao.metodos;
+        for (var i = 0; i < declaracao.metodos.length; i++) {
             var metodoAtual = definirMetodos[i];
-            var eInicializado = metodoAtual.nome.lexema === "construtor";
-            var funcao = new funcao_1.DeleguaFuncao(metodoAtual.nome.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
-            metodos[metodoAtual.nome.lexema] = funcao;
+            var eInicializado = metodoAtual.simbolo.lexema === 'construtor';
+            var funcao = new funcao_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, this.ambiente, eInicializado);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
         }
-        var criado = new classe_1.DeleguaClasse(stmt.nome.lexema, superClasse, metodos);
+        var criado = new classe_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
         if (superClasse !== null) {
             this.ambiente = this.ambiente.enclosing;
         }
-        this.ambiente.atribuirVariavel(stmt.nome, criado);
+        this.ambiente.atribuirVariavel(declaracao.simbolo, criado);
         return null;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoObter = function (expr) {
-        var objeto = this.avaliar(expr.objeto);
+    InterpretadorEguaClassico.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
+        var objeto = this.avaliar(expressao.objeto);
         if (objeto instanceof instancia_1.DeleguaInstancia) {
-            return objeto.get(expr.nome) || null;
+            return objeto.get(expressao.simbolo) || null;
         }
         else if (objeto.constructor === Object) {
-            return objeto[expr.nome.lexema] || null;
+            return objeto[expressao.simbolo.lexema] || null;
         }
         else if (objeto instanceof modulo_1.DeleguaModulo) {
-            return objeto[expr.nome.lexema] || null;
+            return objeto[expressao.simbolo.lexema] || null;
         }
-        throw new excecoes_1.ErroEmTempoDeExecucao(expr.nome, "Você só pode acessar métodos do objeto e dicionários.");
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoIsto = function (expr) {
-        return this.procurarVariavel(expr.palavraChave, expr);
+    InterpretadorEguaClassico.prototype.visitarExpressaoIsto = function (expressao) {
+        return this.procurarVariavel(expressao.palavraChave, expressao);
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDicionario = function (expr) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoDicionario = function (expressao) {
         var dicionario = {};
-        for (var i = 0; i < expr.chaves.length; i++) {
-            dicionario[this.avaliar(expr.chaves[i])] = this.avaliar(expr.valores[i]);
+        for (var i = 0; i < expressao.chaves.length; i++) {
+            dicionario[this.avaliar(expressao.chaves[i])] = this.avaliar(expressao.valores[i]);
         }
         return dicionario;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoVetor = function (expr) {
+    InterpretadorEguaClassico.prototype.visitarExpressaoVetor = function (expressao) {
         var valores = [];
-        for (var i = 0; i < expr.valores.length; i++) {
-            valores.push(this.avaliar(expr.valores[i]));
+        for (var i = 0; i < expressao.valores.length; i++) {
+            valores.push(this.avaliar(expressao.valores[i]));
         }
         return valores;
     };
-    InterpretadorEguaClassico.prototype.visitarExpressaoSuper = function (expr) {
-        var distancia = this.locais.get(expr);
-        var superClasse = this.ambiente.obterVariavelEm(distancia, "super");
-        var objeto = this.ambiente.obterVariavelEm(distancia - 1, "isto");
-        var metodo = superClasse.encontrarMetodo(expr.metodo.lexema);
+    InterpretadorEguaClassico.prototype.visitarExpressaoSuper = function (expressao) {
+        var distancia = this.locais.get(expressao);
+        var superClasse = this.ambiente.obterVariavelEm(distancia, 'super');
+        var objeto = this.ambiente.obterVariavelEm(distancia - 1, 'isto');
+        var metodo = superClasse.encontrarMetodo(expressao.metodo.lexema);
         if (metodo === undefined) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(expr.metodo, "Método chamado indefinido.");
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
         }
         return metodo.definirEscopo(objeto);
     };
     InterpretadorEguaClassico.prototype.paraTexto = function (objeto) {
         if (objeto === null)
-            return "nulo";
-        if (typeof objeto === "boolean") {
-            return objeto ? "verdadeiro" : "falso";
+            return 'nulo';
+        if (typeof objeto === 'boolean') {
+            return objeto ? 'verdadeiro' : 'falso';
         }
         if (objeto instanceof Date) {
-            var formato = Intl.DateTimeFormat("pt", {
-                dateStyle: "full",
-                timeStyle: "full",
+            var formato = Intl.DateTimeFormat('pt', {
+                dateStyle: 'full',
+                timeStyle: 'full',
             });
             return formato.format(objeto);
         }
         if (Array.isArray(objeto))
             return objeto;
-        if (typeof objeto === "object")
+        if (typeof objeto === 'object')
             return JSON.stringify(objeto);
         return objeto.toString();
     };
-    InterpretadorEguaClassico.prototype.executar = function (stmt, mostrarResultado) {
+    InterpretadorEguaClassico.prototype.executar = function (declaracao, mostrarResultado) {
         if (mostrarResultado === void 0) { mostrarResultado = false; }
-        stmt.aceitar(this);
+        declaracao.aceitar(this);
     };
-    InterpretadorEguaClassico.prototype.interpretar = function (declaracoes) {
+    InterpretadorEguaClassico.prototype.interpretar = function (declaracoes, locais) {
+        this.locais = locais;
         try {
             for (var i = 0; i < declaracoes.length; i++) {
                 this.executar(declaracoes[i], false);