@designliquido/delegua 0.9.3 → 0.9.4

package/fontes/interpretador/dialetos/egua-classico.js

@@ -22,70 +22,34 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 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 caminho = __importStar(require("path"));
-var fs = __importStar(require("fs"));
-var espaco_variaveis_1 = require("../../espaco-variaveis");
-var delegua_1 = require("../../delegua");
-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 delegua_classe_1 = require("../../estruturas/delegua-classe");
-var delegua_funcao_1 = require("../../estruturas/delegua-funcao");
-var objeto_delegua_classe_1 = require("../../estruturas/objeto-delegua-classe");
-var modulo_1 = require("../../estruturas/modulo");
-var excecoes_1 = require("../../excecoes");
-var pilha_escopos_execucao_1 = require("../pilha-escopos-execucao");
-var quebras_1 = require("../../quebras");
-var inferenciador_1 = require("../inferenciador");
-var egua_classico_1 = __importDefault(require("../../tipos-de-simbolos/egua-classico"));
+const caminho = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const espaco_variaveis_1 = require("../../espaco-variaveis");
+const delegua_1 = require("../../delegua");
+const biblioteca_global_1 = __importDefault(require("../../bibliotecas/biblioteca-global"));
+const importar_biblioteca_1 = __importDefault(require("../../bibliotecas/importar-biblioteca"));
+const chamavel_1 = require("../../estruturas/chamavel");
+const funcao_padrao_1 = require("../../estruturas/funcao-padrao");
+const delegua_classe_1 = require("../../estruturas/delegua-classe");
+const delegua_funcao_1 = require("../../estruturas/delegua-funcao");
+const objeto_delegua_classe_1 = require("../../estruturas/objeto-delegua-classe");
+const modulo_1 = require("../../estruturas/modulo");
+const excecoes_1 = require("../../excecoes");
+const pilha_escopos_execucao_1 = require("../pilha-escopos-execucao");
+const quebras_1 = require("../../quebras");
+const inferenciador_1 = require("../inferenciador");
+const egua_classico_1 = __importDefault(require("../../tipos-de-simbolos/egua-classico"));
 /**
  * O Interpretador visita todos os elementos complexos gerados pelo analisador sintático (Parser)
  * e de fato executa a lógica de programação descrita no código.
  */
-var InterpretadorEguaClassico = /** @class */ (function () {
-    function InterpretadorEguaClassico(Delegua, resolvedor, diretorioBase) {
+class InterpretadorEguaClassico {
+    constructor(Delegua, resolvedor, diretorioBase) {
         this.interfaceEntradaSaida = null;
         this.Delegua = Delegua;
         this.resolvedor = resolvedor;
@@ -94,7 +58,7 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         this.locais = new Map();
         this.erros = [];
         this.pilhaEscoposExecucao = new pilha_escopos_execucao_1.PilhaEscoposExecucao();
-        var escopoExecucao = {
+        const escopoExecucao = {
             declaracoes: [],
             declaracaoAtual: 0,
             ambiente: new espaco_variaveis_1.EspacoVariaveis(),
@@ -102,56 +66,47 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
         (0, biblioteca_global_1.default)(this, this.pilhaEscoposExecucao);
     }
-    InterpretadorEguaClassico.prototype.visitarExpressaoLeia = function (expressao) {
+    visitarExpressaoLeia(expressao) {
         throw new Error('Método não implementado.');
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoLiteral = function (expressao) {
+    }
+    visitarExpressaoLiteral(expressao) {
         return expressao.valor;
-    };
-    InterpretadorEguaClassico.prototype.avaliar = function (expressao) {
+    }
+    avaliar(expressao) {
         return expressao.aceitar(this);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAgrupamento = function (expressao) {
+    }
+    visitarExpressaoAgrupamento(expressao) {
         return this.avaliar(expressao.expressao);
-    };
-    InterpretadorEguaClassico.prototype.eVerdadeiro = function (objeto) {
+    }
+    eVerdadeiro(objeto) {
         if (objeto === null)
             return false;
         if (typeof objeto === 'boolean')
             return Boolean(objeto);
         return true;
-    };
-    InterpretadorEguaClassico.prototype.verificarOperandoNumero = function (operador, operando) {
+    }
+    verificarOperandoNumero(operador, operando) {
         if (typeof operando === 'number' || operando.tipo === 'número')
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operador precisa ser um número.', operador.linha);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoUnaria = function (expr) {
-        return __awaiter(this, void 0, void 0, function () {
-            var direita, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expr.direita)];
-                    case 1:
-                        direita = _a.sent();
-                        valor = direita.hasOwnProperty('valor') ?
-                            direita.valor :
-                            direita;
-                        switch (expr.operador.tipo) {
-                            case egua_classico_1.default.SUBTRACAO:
-                                this.verificarOperandoNumero(expr.operador, valor);
-                                return [2 /*return*/, -valor];
-                            case egua_classico_1.default.NEGACAO:
-                                return [2 /*return*/, !this.eVerdadeiro(valor)];
-                            case egua_classico_1.default.BIT_NOT:
-                                return [2 /*return*/, ~valor];
-                        }
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.eIgual = function (esquerda, direita) {
+    }
+    async visitarExpressaoUnaria(expr) {
+        const direita = await this.avaliar(expr.direita);
+        const valor = direita.hasOwnProperty('valor') ?
+            direita.valor :
+            direita;
+        switch (expr.operador.tipo) {
+            case egua_classico_1.default.SUBTRACAO:
+                this.verificarOperandoNumero(expr.operador, valor);
+                return -valor;
+            case egua_classico_1.default.NEGACAO:
+                return !this.eVerdadeiro(valor);
+            case egua_classico_1.default.BIT_NOT:
+                return ~valor;
+        }
+        return null;
+    }
+    eIgual(esquerda, direita) {
         if (esquerda.tipo) {
             if (esquerda.tipo === 'nulo' &&
                 direita.tipo &&
@@ -166,14 +121,14 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         if (esquerda === null)
             return false;
         return esquerda === direita;
-    };
-    InterpretadorEguaClassico.prototype.verificarOperandosNumeros = function (operador, direita, esquerda) {
-        var tipoDireita = direita.tipo
+    }
+    verificarOperandosNumeros(operador, direita, esquerda) {
+        const tipoDireita = direita.tipo
             ? direita.tipo
             : typeof direita === 'number'
                 ? 'número'
                 : String(NaN);
-        var tipoEsquerda = esquerda.tipo
+        const tipoEsquerda = esquerda.tipo
             ? esquerda.tipo
             : typeof esquerda === 'number'
                 ? 'número'
@@ -181,537 +136,325 @@ var InterpretadorEguaClassico = /** @class */ (function () {
         if (tipoDireita === 'número' && tipoEsquerda === 'número')
             return;
         throw new excecoes_1.ErroEmTempoDeExecucao(operador, 'Operadores precisam ser números.', operador.linha);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoBinaria = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var esquerda, direita, valorEsquerdo, valorDireito, tipoEsquerdo, tipoDireito, erro_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 3, , 4]);
-                        return [4 /*yield*/, this.avaliar(expressao.esquerda)];
-                    case 1:
-                        esquerda = _a.sent();
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 2:
-                        direita = _a.sent();
-                        valorEsquerdo = esquerda.hasOwnProperty('valor')
-                            ? esquerda.valor
-                            : esquerda;
-                        valorDireito = direita.hasOwnProperty('valor')
-                            ? direita.valor
-                            : direita;
-                        tipoEsquerdo = esquerda.hasOwnProperty('tipo')
-                            ? esquerda.tipo
-                            : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
-                        tipoDireito = direita.hasOwnProperty('tipo')
-                            ? direita.tipo
-                            : (0, inferenciador_1.inferirTipoVariavel)(direita);
-                        switch (expressao.operador.tipo) {
-                            case egua_classico_1.default.EXPONENCIACAO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Math.pow(valorEsquerdo, valorDireito)];
-                            case egua_classico_1.default.MAIOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) > Number(valorDireito)];
-                            case egua_classico_1.default.MAIOR_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) >= Number(valorDireito)];
-                            case egua_classico_1.default.MENOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) < Number(valorDireito)];
-                            case egua_classico_1.default.MENOR_IGUAL:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) <= Number(valorDireito)];
-                            case egua_classico_1.default.SUBTRACAO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) - Number(valorDireito)];
-                            case egua_classico_1.default.ADICAO:
-                                if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
-                                    return [2 /*return*/, Number(esquerda) + Number(direita)];
-                                }
-                                else if (tipoEsquerdo === 'texto' &&
-                                    tipoDireito === 'texto') {
-                                    return [2 /*return*/, String(esquerda) + String(direita)];
-                                }
-                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Operadores precisam ser dois números ou duas strings.');
-                            case egua_classico_1.default.DIVISAO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) / Number(valorDireito)];
-                            case egua_classico_1.default.MULTIPLICACAO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) * Number(valorDireito)];
-                            case egua_classico_1.default.MODULO:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) % Number(valorDireito)];
-                            case egua_classico_1.default.BIT_AND:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) & Number(valorDireito)];
-                            case egua_classico_1.default.BIT_XOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) ^ Number(valorDireito)];
-                            case egua_classico_1.default.BIT_OR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) | Number(valorDireito)];
-                            case egua_classico_1.default.MENOR_MENOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) << Number(valorDireito)];
-                            case egua_classico_1.default.MAIOR_MAIOR:
-                                this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
-                                return [2 /*return*/, Number(valorEsquerdo) >> Number(valorDireito)];
-                            case egua_classico_1.default.DIFERENTE:
-                                return [2 /*return*/, !this.eIgual(valorEsquerdo, valorDireito)];
-                            case egua_classico_1.default.IGUAL_IGUAL:
-                                return [2 /*return*/, this.eIgual(valorEsquerdo, valorDireito)];
-                        }
-                        return [2 /*return*/, null];
-                    case 3:
-                        erro_1 = _a.sent();
-                        return [2 /*return*/, Promise.reject(erro_1)];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeChamada = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelEntidadeChamada, entidadeChamada, argumentos, i, _a, _b, parametros, diferenca, i, novosArgumentos;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.entidadeChamada)];
-                    case 1:
-                        variavelEntidadeChamada = _c.sent();
-                        entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
-                            ? variavelEntidadeChamada.valor
-                            : variavelEntidadeChamada;
-                        argumentos = [];
-                        i = 0;
-                        _c.label = 2;
-                    case 2:
-                        if (!(i < expressao.argumentos.length)) return [3 /*break*/, 5];
-                        _b = (_a = argumentos).push;
-                        return [4 /*yield*/, this.avaliar(expressao.argumentos[i])];
-                    case 3:
-                        _b.apply(_a, [_c.sent()]);
-                        _c.label = 4;
-                    case 4:
-                        i++;
-                        return [3 /*break*/, 2];
-                    case 5:
-                        if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
-                        }
-                        if (entidadeChamada instanceof delegua_funcao_1.DeleguaFuncao) {
-                            parametros = entidadeChamada.declaracao.parametros;
-                        }
-                        else if (entidadeChamada instanceof delegua_classe_1.DeleguaClasse) {
-                            parametros = entidadeChamada.metodos.inicializacao
-                                ? entidadeChamada.metodos.inicializacao.declaracao.parametros
-                                : [];
-                        }
-                        else {
-                            parametros = [];
-                        }
-                        // Isso aqui completa os parâmetros não preenchidos com nulos.
-                        if (argumentos.length < entidadeChamada.aridade()) {
-                            diferenca = entidadeChamada.aridade() - argumentos.length;
-                            for (i = 0; i < diferenca; i++) {
-                                argumentos.push(null);
-                            }
-                        }
-                        else {
-                            if (parametros &&
-                                parametros.length > 0 &&
-                                parametros[parametros.length - 1]['tipo'] === 'estrela') {
-                                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 [2 /*return*/, entidadeChamada.chamar(argumentos, expressao.entidadeChamada.nome)];
-                        }
-                        return [2 /*return*/, entidadeChamada.chamar(this, argumentos)];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeAtribuicao = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.valor)];
-                    case 1:
-                        valor = _a.sent();
-                        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
-                        return [2 /*return*/, valor];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.procurarVariavel = function (simbolo, expressao) {
+    }
+    async visitarExpressaoBinaria(expressao) {
+        try {
+            const esquerda = await this.avaliar(expressao.esquerda);
+            const direita = await this.avaliar(expressao.direita);
+            const valorEsquerdo = esquerda.hasOwnProperty('valor')
+                ? esquerda.valor
+                : esquerda;
+            const valorDireito = direita.hasOwnProperty('valor')
+                ? direita.valor
+                : direita;
+            const tipoEsquerdo = esquerda.hasOwnProperty('tipo')
+                ? esquerda.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
+            const tipoDireito = direita.hasOwnProperty('tipo')
+                ? direita.tipo
+                : (0, inferenciador_1.inferirTipoVariavel)(direita);
+            switch (expressao.operador.tipo) {
+                case egua_classico_1.default.EXPONENCIACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Math.pow(valorEsquerdo, valorDireito);
+                case egua_classico_1.default.MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) > Number(valorDireito);
+                case egua_classico_1.default.MAIOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >= Number(valorDireito);
+                case egua_classico_1.default.MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) < Number(valorDireito);
+                case egua_classico_1.default.MENOR_IGUAL:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) <= Number(valorDireito);
+                case egua_classico_1.default.SUBTRACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) - Number(valorDireito);
+                case egua_classico_1.default.ADICAO:
+                    if (tipoEsquerdo === 'número' && tipoDireito === 'número') {
+                        return Number(esquerda) + Number(direita);
+                    }
+                    else if (tipoEsquerdo === 'texto' &&
+                        tipoDireito === 'texto') {
+                        return String(esquerda) + String(direita);
+                    }
+                    throw new excecoes_1.ErroEmTempoDeExecucao(expressao.operador, 'Operadores precisam ser dois números ou duas strings.');
+                case egua_classico_1.default.DIVISAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) / Number(valorDireito);
+                case egua_classico_1.default.MULTIPLICACAO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) * Number(valorDireito);
+                case egua_classico_1.default.MODULO:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) % Number(valorDireito);
+                case egua_classico_1.default.BIT_AND:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) & Number(valorDireito);
+                case egua_classico_1.default.BIT_XOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) ^ Number(valorDireito);
+                case egua_classico_1.default.BIT_OR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) | Number(valorDireito);
+                case egua_classico_1.default.MENOR_MENOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) << Number(valorDireito);
+                case egua_classico_1.default.MAIOR_MAIOR:
+                    this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
+                    return Number(valorEsquerdo) >> Number(valorDireito);
+                case egua_classico_1.default.DIFERENTE:
+                    return !this.eIgual(valorEsquerdo, valorDireito);
+                case egua_classico_1.default.IGUAL_IGUAL:
+                    return this.eIgual(valorEsquerdo, valorDireito);
+            }
+            return null;
+        }
+        catch (erro) {
+            return Promise.reject(erro);
+        }
+    }
+    async visitarExpressaoDeChamada(expressao) {
+        const variavelEntidadeChamada = await this.avaliar(expressao.entidadeChamada);
+        const entidadeChamada = variavelEntidadeChamada.hasOwnProperty('valor')
+            ? variavelEntidadeChamada.valor
+            : variavelEntidadeChamada;
+        let argumentos = [];
+        for (let i = 0; i < expressao.argumentos.length; i++) {
+            argumentos.push(await this.avaliar(expressao.argumentos[i]));
+        }
+        if (!(entidadeChamada instanceof chamavel_1.Chamavel)) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.parentese, 'Só pode chamar função ou classe.', expressao.linha);
+        }
+        let parametros;
+        if (entidadeChamada instanceof delegua_funcao_1.DeleguaFuncao) {
+            parametros = entidadeChamada.declaracao.parametros;
+        }
+        else if (entidadeChamada instanceof delegua_classe_1.DeleguaClasse) {
+            parametros = entidadeChamada.metodos.inicializacao
+                ? entidadeChamada.metodos.inicializacao.declaracao.parametros
+                : [];
+        }
+        else {
+            parametros = [];
+        }
+        // Isso aqui completa os parâmetros não preenchidos com nulos.
+        if (argumentos.length < entidadeChamada.aridade()) {
+            const diferenca = entidadeChamada.aridade() - argumentos.length;
+            for (let i = 0; i < diferenca; i++) {
+                argumentos.push(null);
+            }
+        }
+        else {
+            if (parametros &&
+                parametros.length > 0 &&
+                parametros[parametros.length - 1]['tipo'] === 'estrela') {
+                const 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(argumentos, expressao.entidadeChamada.nome);
+        }
+        return entidadeChamada.chamar(this, argumentos);
+    }
+    async visitarExpressaoDeAtribuicao(expressao) {
+        const valor = await this.avaliar(expressao.valor);
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valor);
+        return valor;
+    }
+    procurarVariavel(simbolo, expressao) {
         return this.pilhaEscoposExecucao.obterVariavel(simbolo);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeVariavel = function (expressao) {
+    }
+    visitarExpressaoDeVariavel(expressao) {
         return this.procurarVariavel(expressao.simbolo, expressao);
-    };
-    InterpretadorEguaClassico.prototype.visitarDeclaracaoDeExpressao = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.expressao)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoLogica = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var esquerda, direita;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.esquerda)];
-                    case 1:
-                        esquerda = _a.sent();
-                        if (!(expressao.operador.tipo === egua_classico_1.default.EM)) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 2:
-                        direita = _a.sent();
-                        if (Array.isArray(direita) || typeof direita === 'string') {
-                            return [2 /*return*/, direita.includes(esquerda)];
-                        }
-                        else if (direita.constructor === Object) {
-                            return [2 /*return*/, esquerda in direita];
-                        }
-                        else {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
-                        }
-                        _a.label = 3;
-                    case 3:
-                        // se um estado for verdadeiro, retorna verdadeiro
-                        if (expressao.operador.tipo === egua_classico_1.default.OU) {
-                            if (this.eVerdadeiro(esquerda))
-                                return [2 /*return*/, esquerda];
-                        }
-                        // se um estado for falso, retorna falso
-                        if (expressao.operador.tipo === egua_classico_1.default.E) {
-                            if (!this.eVerdadeiro(esquerda))
-                                return [2 /*return*/, esquerda];
-                        }
-                        return [4 /*yield*/, this.avaliar(expressao.direita)];
-                    case 4: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoSe = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, i, atual, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _a = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 1:
-                        if (!_a.apply(this, [_c.sent()])) return [3 /*break*/, 3];
-                        return [4 /*yield*/, this.executar(declaracao.caminhoEntao)];
-                    case 2: return [2 /*return*/, _c.sent()];
-                    case 3:
-                        i = 0;
-                        _c.label = 4;
-                    case 4:
-                        if (!(i < declaracao.caminhosSeSenao.length)) return [3 /*break*/, 8];
-                        atual = declaracao.caminhosSeSenao[i];
-                        _b = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(atual.condicao)];
-                    case 5:
-                        if (!_b.apply(this, [_c.sent()])) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.executar(atual.caminho)];
-                    case 6: return [2 /*return*/, _c.sent()];
-                    case 7:
-                        i++;
-                        return [3 /*break*/, 4];
-                    case 8:
-                        if (!(declaracao.caminhoSenao !== null)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.executar(declaracao.caminhoSenao)];
-                    case 9: return [2 /*return*/, _c.sent()];
-                    case 10: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoPara = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, erro_2;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!(declaracao.inicializador !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.inicializador)];
-                    case 1:
-                        _b.sent();
-                        _b.label = 2;
-                    case 2:
-                        if (!true) return [3 /*break*/, 10];
-                        if (!(declaracao.condicao !== null)) return [3 /*break*/, 4];
-                        _a = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 3:
-                        if (!_a.apply(this, [_b.sent()])) {
-                            return [3 /*break*/, 10];
-                        }
-                        _b.label = 4;
-                    case 4:
-                        _b.trys.push([4, 6, , 7]);
-                        return [4 /*yield*/, this.executar(declaracao.corpo)];
-                    case 5:
-                        _b.sent();
-                        return [3 /*break*/, 7];
-                    case 6:
-                        erro_2 = _b.sent();
-                        throw erro_2;
-                    case 7:
-                        if (!(declaracao.incrementar !== null)) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.avaliar(declaracao.incrementar)];
-                    case 8:
-                        _b.sent();
-                        _b.label = 9;
-                    case 9: return [3 /*break*/, 2];
-                    case 10: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoFazer = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var erro_3, _a;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _b.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.executar(declaracao.caminhoFazer)];
-                    case 1:
-                        _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        erro_3 = _b.sent();
-                        throw erro_3;
-                    case 3:
-                        _a = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicaoEnquanto)];
-                    case 4:
-                        if (_a.apply(this, [_b.sent()])) return [3 /*break*/, 0];
-                        _b.label = 5;
-                    case 5: return [2 /*return*/];
+    }
+    async visitarDeclaracaoDeExpressao(declaracao) {
+        return await this.avaliar(declaracao.expressao);
+    }
+    async visitarExpressaoLogica(expressao) {
+        const esquerda = await this.avaliar(expressao.esquerda);
+        if (expressao.operador.tipo === egua_classico_1.default.EM) {
+            const direita = await 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(esquerda, "Tipo de chamada inválida com 'em'.", expressao.linha);
+            }
+        }
+        // se um estado for verdadeiro, retorna verdadeiro
+        if (expressao.operador.tipo === egua_classico_1.default.OU) {
+            if (this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        // se um estado for falso, retorna falso
+        if (expressao.operador.tipo === egua_classico_1.default.E) {
+            if (!this.eVerdadeiro(esquerda))
+                return esquerda;
+        }
+        return await this.avaliar(expressao.direita);
+    }
+    async visitarExpressaoSe(declaracao) {
+        if (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            return await this.executar(declaracao.caminhoEntao);
+        }
+        for (let i = 0; i < declaracao.caminhosSeSenao.length; i++) {
+            const atual = declaracao.caminhosSeSenao[i];
+            if (this.eVerdadeiro(await this.avaliar(atual.condicao))) {
+                return await this.executar(atual.caminho);
+            }
+        }
+        if (declaracao.caminhoSenao !== null) {
+            return await this.executar(declaracao.caminhoSenao);
+        }
+        return null;
+    }
+    async visitarExpressaoPara(declaracao) {
+        if (declaracao.inicializador !== null) {
+            await this.avaliar(declaracao.inicializador);
+        }
+        while (true) {
+            if (declaracao.condicao !== null) {
+                if (!this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+                    break;
                 }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEscolha = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var condicaoEscolha, caminhos, caminhoPadrao, encontrado, i, caminho_1, j, k, erro_4, i, erro_5;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.identificadorOuLiteral)];
-                    case 1:
-                        condicaoEscolha = _a.sent();
-                        caminhos = declaracao.caminhos;
-                        caminhoPadrao = declaracao.caminhoPadrao;
-                        encontrado = false;
-                        _a.label = 2;
-                    case 2:
-                        _a.trys.push([2, 19, , 20]);
-                        i = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(i < caminhos.length)) return [3 /*break*/, 14];
-                        caminho_1 = caminhos[i];
-                        j = 0;
-                        _a.label = 4;
-                    case 4:
-                        if (!(j < caminho_1.condicoes.length)) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.avaliar(caminho_1.condicoes[j])];
-                    case 5:
-                        if (!((_a.sent()) === condicaoEscolha)) return [3 /*break*/, 12];
+            }
+            try {
+                await this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                throw erro;
+            }
+            if (declaracao.incrementar !== null) {
+                await this.avaliar(declaracao.incrementar);
+            }
+        }
+        return null;
+    }
+    async visitarExpressaoFazer(declaracao) {
+        do {
+            try {
+                await this.executar(declaracao.caminhoFazer);
+            }
+            catch (erro) {
+                throw erro;
+            }
+        } while (this.eVerdadeiro(await this.avaliar(declaracao.condicaoEnquanto)));
+    }
+    async visitarExpressaoEscolha(declaracao) {
+        const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
+        const caminhos = declaracao.caminhos;
+        const caminhoPadrao = declaracao.caminhoPadrao;
+        let encontrado = false;
+        try {
+            for (let i = 0; i < caminhos.length; i++) {
+                const caminho = caminhos[i];
+                for (let j = 0; j < caminho.condicoes.length; j++) {
+                    if (await this.avaliar(caminho.condicoes[j]) === condicaoEscolha) {
                         encontrado = true;
-                        _a.label = 6;
-                    case 6:
-                        _a.trys.push([6, 11, , 12]);
-                        k = 0;
-                        _a.label = 7;
-                    case 7:
-                        if (!(k < caminho_1.declaracoes.length)) return [3 /*break*/, 10];
-                        return [4 /*yield*/, this.executar(caminho_1.declaracoes[k])];
-                    case 8:
-                        _a.sent();
-                        _a.label = 9;
-                    case 9:
-                        k++;
-                        return [3 /*break*/, 7];
-                    case 10: return [3 /*break*/, 12];
-                    case 11:
-                        erro_4 = _a.sent();
-                        throw erro_4;
-                    case 12:
-                        j++;
-                        return [3 /*break*/, 4];
-                    case 13:
-                        i++;
-                        return [3 /*break*/, 3];
-                    case 14:
-                        if (!(caminhoPadrao !== null && encontrado === false)) return [3 /*break*/, 18];
-                        i = 0;
-                        _a.label = 15;
-                    case 15:
-                        if (!(i < caminhoPadrao.declaracoes.length)) return [3 /*break*/, 18];
-                        return [4 /*yield*/, this.executar(caminhoPadrao['declaracoes'][i])];
-                    case 16:
-                        _a.sent();
-                        _a.label = 17;
-                    case 17:
-                        i++;
-                        return [3 /*break*/, 15];
-                    case 18: return [3 /*break*/, 20];
-                    case 19:
-                        erro_5 = _a.sent();
-                        throw erro_5;
-                    case 20: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoTente = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sucesso, erro_6;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, , 10, 13]);
-                        sucesso = true;
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 3, , 7]);
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoTente)];
-                    case 2:
-                        _a.sent();
-                        return [3 /*break*/, 7];
-                    case 3:
-                        erro_6 = _a.sent();
-                        sucesso = false;
-                        if (!(declaracao.caminhoPegue !== null)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoPegue)];
-                    case 4:
-                        _a.sent();
-                        return [3 /*break*/, 6];
-                    case 5:
-                        this.erros.push(erro_6);
-                        _a.label = 6;
-                    case 6: return [3 /*break*/, 7];
-                    case 7:
-                        if (!(sucesso && declaracao.caminhoSenao !== null)) return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoSenao)];
-                    case 8:
-                        _a.sent();
-                        _a.label = 9;
-                    case 9: return [3 /*break*/, 13];
-                    case 10:
-                        if (!(declaracao.caminhoFinalmente !== null)) return [3 /*break*/, 12];
-                        return [4 /*yield*/, this.executarBloco(declaracao.caminhoFinalmente)];
-                    case 11:
-                        _a.sent();
-                        _a.label = 12;
-                    case 12: return [7 /*endfinally*/];
-                    case 13: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEnquanto = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, erro_7;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = this.eVerdadeiro;
-                        return [4 /*yield*/, this.avaliar(declaracao.condicao)];
-                    case 1:
-                        if (!_a.apply(this, [_b.sent()])) return [3 /*break*/, 6];
-                        _b.label = 2;
-                    case 2:
-                        _b.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, this.executar(declaracao.corpo)];
-                    case 3:
-                        _b.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        erro_7 = _b.sent();
-                        throw erro_7;
-                    case 5: return [3 /*break*/, 0];
-                    case 6: return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoImportar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var caminhoRelativo, caminhoTotal, dados, delegua, exportar, eDicionario, novoModulo, chaves, i;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(declaracao.caminho)];
-                    case 1:
-                        caminhoRelativo = _a.sent();
-                        caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
-                        dados = (0, importar_biblioteca_1.default)(caminhoRelativo);
-                        if (dados)
-                            return [2 /*return*/, dados];
                         try {
-                            if (!fs.existsSync(caminhoTotal)) {
-                                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
+                            for (let k = 0; k < caminho.declaracoes.length; k++) {
+                                await this.executar(caminho.declaracoes[k]);
                             }
                         }
                         catch (erro) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
-                        }
-                        dados = fs.readFileSync(caminhoTotal).toString();
-                        delegua = new delegua_1.Delegua(this.Delegua.dialeto, false);
-                        delegua.executar(dados);
-                        exportar = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
-                        eDicionario = function (objeto) { return objeto.constructor === Object; };
-                        if (eDicionario(exportar)) {
-                            novoModulo = new modulo_1.DeleguaModulo();
-                            chaves = Object.keys(exportar);
-                            for (i = 0; i < chaves.length; i++) {
-                                novoModulo[chaves[i]] = exportar[chaves[i]];
-                            }
-                            return [2 /*return*/, novoModulo];
+                            throw erro;
                         }
-                        return [2 /*return*/, exportar];
+                    }
                 }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoEscreva = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor, erro_8;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 2, , 3]);
-                        return [4 /*yield*/, this.avaliar(declaracao.argumentos[0])];
-                    case 1:
-                        valor = _a.sent();
-                        console.log(this.paraTexto(valor));
-                        return [2 /*return*/, null];
-                    case 2:
-                        erro_8 = _a.sent();
-                        this.erros.push(erro_8);
-                        return [3 /*break*/, 3];
-                    case 3: return [2 /*return*/];
+            }
+            if (caminhoPadrao !== null && encontrado === false) {
+                for (let i = 0; i < caminhoPadrao.declaracoes.length; i++) {
+                    await this.executar(caminhoPadrao['declaracoes'][i]);
                 }
-            });
-        });
-    };
+            }
+        }
+        catch (erro) {
+            throw erro;
+        }
+    }
+    async visitarExpressaoTente(declaracao) {
+        try {
+            let sucesso = true;
+            try {
+                await this.executarBloco(declaracao.caminhoTente);
+            }
+            catch (erro) {
+                sucesso = false;
+                if (declaracao.caminhoPegue !== null) {
+                    await this.executarBloco(declaracao.caminhoPegue);
+                }
+                else {
+                    this.erros.push(erro);
+                }
+            }
+            if (sucesso && declaracao.caminhoSenao !== null) {
+                await this.executarBloco(declaracao.caminhoSenao);
+            }
+        }
+        finally {
+            if (declaracao.caminhoFinalmente !== null)
+                await this.executarBloco(declaracao.caminhoFinalmente);
+        }
+    }
+    async visitarExpressaoEnquanto(declaracao) {
+        while (this.eVerdadeiro(await this.avaliar(declaracao.condicao))) {
+            try {
+                await this.executar(declaracao.corpo);
+            }
+            catch (erro) {
+                throw erro;
+            }
+        }
+        return null;
+    }
+    async visitarExpressaoImportar(declaracao) {
+        const caminhoRelativo = await this.avaliar(declaracao.caminho);
+        const caminhoTotal = caminho.join(this.diretorioBase, caminhoRelativo);
+        // const nomeArquivo = caminho.basename(caminhoTotal);
+        let dados = (0, importar_biblioteca_1.default)(caminhoRelativo);
+        if (dados)
+            return dados;
+        try {
+            if (!fs.existsSync(caminhoTotal)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível encontrar arquivo importado.', declaracao.linha);
+            }
+        }
+        catch (erro) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.simboloFechamento, 'Não foi possível ler o arquivo.', declaracao.linha);
+        }
+        dados = fs.readFileSync(caminhoTotal).toString();
+        const delegua = new delegua_1.Delegua(this.Delegua.dialeto, false);
+        delegua.executar(dados);
+        const exportar = this.pilhaEscoposExecucao.obterTodasDeleguaFuncao();
+        const eDicionario = (objeto) => objeto.constructor === Object;
+        if (eDicionario(exportar)) {
+            const novoModulo = new modulo_1.DeleguaModulo();
+            const chaves = Object.keys(exportar);
+            for (let i = 0; i < chaves.length; i++) {
+                novoModulo[chaves[i]] = exportar[chaves[i]];
+            }
+            return novoModulo;
+        }
+        return exportar;
+    }
+    async visitarExpressaoEscreva(declaracao) {
+        try {
+            const valor = await this.avaliar(declaracao.argumentos[0]);
+            console.log(this.paraTexto(valor));
+            return null;
+        }
+        catch (erro) {
+            this.erros.push(erro);
+        }
+    }
     /**
      * Empilha declarações na pilha de escopos de execução, cria um novo ambiente e
      * executa as declarações empilhadas.
@@ -722,355 +465,221 @@ var InterpretadorEguaClassico = /** @class */ (function () {
      * @param declaracoes Um vetor de declaracoes a ser executado.
      * @param ambiente O ambiente de execução quando houver, como parâmetros, argumentos, etc.
      */
-    InterpretadorEguaClassico.prototype.executarBloco = function (declaracoes, ambiente) {
-        return __awaiter(this, void 0, void 0, function () {
-            var escopoExecucao, retornoUltimoEscopo;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        escopoExecucao = {
-                            declaracoes: declaracoes,
-                            declaracaoAtual: 0,
-                            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
-                        };
-                        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-                        return [4 /*yield*/, this.executarUltimoEscopo()];
-                    case 1:
-                        retornoUltimoEscopo = _a.sent();
-                        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
-                            throw retornoUltimoEscopo;
-                        }
-                        return [2 /*return*/, retornoUltimoEscopo];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoBloco = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.executarBloco(declaracao.declaracoes)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    async executarBloco(declaracoes, ambiente) {
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: ambiente || new espaco_variaveis_1.EspacoVariaveis(),
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        const retornoUltimoEscopo = await this.executarUltimoEscopo();
+        if (retornoUltimoEscopo instanceof excecoes_1.ErroEmTempoDeExecucao) {
+            throw retornoUltimoEscopo;
+        }
+        return retornoUltimoEscopo;
+    }
+    async visitarExpressaoBloco(declaracao) {
+        return await this.executarBloco(declaracao.declaracoes);
+    }
     /**
      * Executa expressão de definição de variável.
      * @param declaracao A declaração Var
      * @returns Sempre retorna nulo.
      */
-    InterpretadorEguaClassico.prototype.visitarExpressaoVar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valorOuOutraVariavel;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        valorOuOutraVariavel = null;
-                        if (!(declaracao.inicializador !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.inicializador)];
-                    case 1:
-                        valorOuOutraVariavel = _a.sent();
-                        _a.label = 2;
-                    case 2:
-                        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorOuOutraVariavel.hasOwnProperty('valor')
-                            ? valorOuOutraVariavel.valor
-                            : valorOuOutraVariavel);
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoContinua = function (declaracao) {
+    async visitarExpressaoVar(declaracao) {
+        let valorOuOutraVariavel = null;
+        if (declaracao.inicializador !== null) {
+            valorOuOutraVariavel = await this.avaliar(declaracao.inicializador);
+        }
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, valorOuOutraVariavel.hasOwnProperty('valor')
+            ? valorOuOutraVariavel.valor
+            : valorOuOutraVariavel);
+        return null;
+    }
+    visitarExpressaoContinua(declaracao) {
         return new quebras_1.ContinuarQuebra();
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoSustar = function (declaracao) {
+    }
+    visitarExpressaoSustar(declaracao) {
         return new quebras_1.SustarQuebra();
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoRetornar = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        valor = null;
-                        if (!(declaracao.valor != null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.valor)];
-                    case 1:
-                        valor = _a.sent();
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, new quebras_1.RetornoQuebra(valor)];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDeleguaFuncao = function (expressao) {
+    }
+    async visitarExpressaoRetornar(declaracao) {
+        let valor = null;
+        if (declaracao.valor != null)
+            valor = await this.avaliar(declaracao.valor);
+        return new quebras_1.RetornoQuebra(valor);
+    }
+    visitarExpressaoDeleguaFuncao(expressao) {
         return new delegua_funcao_1.DeleguaFuncao(null, expressao);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAtribuicaoSobrescrita = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var objeto, indice, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
-                    case 1:
-                        objeto = _a.sent();
-                        return [4 /*yield*/, this.avaliar(expressao.indice)];
-                    case 2:
-                        indice = _a.sent();
-                        return [4 /*yield*/, this.avaliar(expressao.valor)];
-                    case 3:
-                        valor = _a.sent();
-                        if (Array.isArray(objeto)) {
-                            if (indice < 0 && objeto.length !== 0) {
-                                while (indice < 0) {
-                                    indice += objeto.length;
-                                }
-                            }
-                            while (objeto.length < indice) {
-                                objeto.push(null);
-                            }
-                            objeto[indice] = valor;
-                        }
-                        else if (objeto.constructor === Object ||
-                            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
-                            objeto instanceof delegua_funcao_1.DeleguaFuncao ||
-                            objeto instanceof delegua_classe_1.DeleguaClasse ||
-                            objeto instanceof modulo_1.DeleguaModulo) {
-                            objeto[indice] = valor;
-                        }
-                        else {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
-                        }
-                        return [2 /*return*/];
+    }
+    async visitarExpressaoAtribuicaoSobrescrita(expressao) {
+        const objeto = await this.avaliar(expressao.objeto);
+        let indice = await this.avaliar(expressao.indice);
+        const valor = await this.avaliar(expressao.valor);
+        if (Array.isArray(objeto)) {
+            if (indice < 0 && objeto.length !== 0) {
+                while (indice < 0) {
+                    indice += objeto.length;
                 }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAcessoIndiceVariavel = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelObjeto, objeto, indice, valorIndice;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.entidadeChamada)];
-                    case 1:
-                        variavelObjeto = _a.sent();
-                        objeto = variavelObjeto.hasOwnProperty('valor')
-                            ? variavelObjeto.valor
-                            : variavelObjeto;
-                        return [4 /*yield*/, this.avaliar(expressao.indice)];
-                    case 2:
-                        indice = _a.sent();
-                        valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
-                        if (Array.isArray(objeto)) {
-                            if (!Number.isInteger(valorIndice)) {
-                                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) {
-                                    indice += objeto.length;
-                                }
-                            }
-                            if (indice >= objeto.length) {
-                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
-                            }
-                            return [2 /*return*/, objeto[indice]];
-                        }
-                        else if (objeto.constructor === Object ||
-                            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
-                            objeto instanceof delegua_funcao_1.DeleguaFuncao ||
-                            objeto instanceof delegua_classe_1.DeleguaClasse ||
-                            objeto instanceof modulo_1.DeleguaModulo) {
-                            return [2 /*return*/, objeto[indice] || null];
-                        }
-                        else if (typeof objeto === 'string') {
-                            if (!Number.isInteger(indice)) {
-                                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) {
-                                    indice += objeto.length;
-                                }
-                            }
-                            if (indice >= objeto.length) {
-                                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice fora do tamanho.', expressao.linha);
-                            }
-                            return [2 /*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.', expressao.linha);
-                        }
-                        return [2 /*return*/];
+            }
+            while (objeto.length < indice) {
+                objeto.push(null);
+            }
+            objeto[indice] = valor;
+        }
+        else if (objeto.constructor === Object ||
+            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
+            objeto instanceof delegua_funcao_1.DeleguaFuncao ||
+            objeto instanceof delegua_classe_1.DeleguaClasse ||
+            objeto instanceof modulo_1.DeleguaModulo) {
+            objeto[indice] = valor;
+        }
+        else {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente listas, dicionários, classes e objetos podem ser mudados por sobrescrita.', expressao.linha);
+        }
+    }
+    async visitarExpressaoAcessoIndiceVariavel(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.entidadeChamada);
+        const objeto = variavelObjeto.hasOwnProperty('valor')
+            ? variavelObjeto.valor
+            : variavelObjeto;
+        let indice = await this.avaliar(expressao.indice);
+        const valorIndice = indice.hasOwnProperty('valor') ? indice.valor : indice;
+        if (Array.isArray(objeto)) {
+            if (!Number.isInteger(valorIndice)) {
+                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) {
+                    indice += objeto.length;
                 }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDefinirValor = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var objeto, valor;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
-                    case 1:
-                        objeto = _a.sent();
-                        if (!(objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) &&
-                            objeto.constructor !== Object) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
-                        }
-                        return [4 /*yield*/, this.avaliar(expressao.valor)];
-                    case 2:
-                        valor = _a.sent();
-                        if (objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
-                            objeto.set(expressao.nome, valor);
-                            return [2 /*return*/, valor];
-                        }
-                        else if (objeto.constructor === Object) {
-                            objeto[expressao.simbolo.lexema] = valor;
-                        }
-                        return [2 /*return*/];
+            }
+            if (indice >= objeto.length) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Índice do vetor fora do intervalo.', expressao.linha);
+            }
+            return objeto[indice];
+        }
+        else if (objeto.constructor === Object ||
+            objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse ||
+            objeto instanceof delegua_funcao_1.DeleguaFuncao ||
+            objeto instanceof delegua_classe_1.DeleguaClasse ||
+            objeto instanceof modulo_1.DeleguaModulo) {
+            return objeto[indice] || null;
+        }
+        else if (typeof objeto === 'string') {
+            if (!Number.isInteger(indice)) {
+                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) {
+                    indice += objeto.length;
                 }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoFuncao = function (declaracao) {
-        var funcao = new delegua_funcao_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+            }
+            if (indice >= objeto.length) {
+                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.', expressao.linha);
+        }
+    }
+    async visitarExpressaoDefinirValor(expressao) {
+        const objeto = await this.avaliar(expressao.objeto);
+        if (!(objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) &&
+            objeto.constructor !== Object) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(expressao.objeto.nome, 'Somente instâncias e dicionários podem possuir campos.', expressao.linha);
+        }
+        const valor = await this.avaliar(expressao.valor);
+        if (objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+            objeto.definir(expressao.nome, valor);
+            return valor;
+        }
+        else if (objeto.constructor === Object) {
+            objeto[expressao.simbolo.lexema] = valor;
+        }
+    }
+    visitarExpressaoFuncao(declaracao) {
+        const funcao = new delegua_funcao_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoClasse = function (declaracao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var superClasse, variavelSuperClasse, metodos, definirMetodos, i, metodoAtual, eInicializador, funcao, deleguaClasse;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        superClasse = null;
-                        if (!(declaracao.superClasse !== null)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.avaliar(declaracao.superClasse)];
-                    case 1:
-                        variavelSuperClasse = _a.sent();
-                        superClasse = variavelSuperClasse.valor;
-                        if (!(superClasse instanceof delegua_classe_1.DeleguaClasse)) {
-                            throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
-                        }
-                        _a.label = 2;
-                    case 2:
-                        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, null);
-                        if (declaracao.superClasse !== null) {
-                            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
-                        }
-                        metodos = {};
-                        definirMetodos = declaracao.metodos;
-                        for (i = 0; i < declaracao.metodos.length; i++) {
-                            metodoAtual = definirMetodos[i];
-                            eInicializador = metodoAtual.simbolo.lexema === 'construtor';
-                            funcao = new delegua_funcao_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
-                            metodos[metodoAtual.simbolo.lexema] = funcao;
-                        }
-                        deleguaClasse = new delegua_classe_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
-                        // TODO: Recolocar isso se for necessário.
-                        /* if (superClasse !== null) {
-                            this.ambiente = this.ambiente.enclosing;
-                        } */
-                        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, deleguaClasse);
-                        return [2 /*return*/, null];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoAcessoMetodo = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var variavelObjeto, objeto;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.avaliar(expressao.objeto)];
-                    case 1:
-                        variavelObjeto = _a.sent();
-                        objeto = variavelObjeto === null || variavelObjeto === void 0 ? void 0 : variavelObjeto.valor;
-                        if (objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
-                            return [2 /*return*/, objeto.get(expressao.simbolo) || null];
-                        }
-                        else if (objeto.constructor === Object) {
-                            return [2 /*return*/, objeto[expressao.simbolo.lexema] || null];
-                        }
-                        else if (objeto instanceof modulo_1.DeleguaModulo) {
-                            return [2 /*return*/, objeto[expressao.simbolo.lexema] || null];
-                        }
-                        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoIsto = function (expressao) {
+    }
+    async visitarExpressaoClasse(declaracao) {
+        let superClasse = null;
+        if (declaracao.superClasse !== null) {
+            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
+            superClasse = variavelSuperClasse.valor;
+            if (!(superClasse instanceof delegua_classe_1.DeleguaClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'SuperClasse precisa ser uma classe.', declaracao.linha);
+            }
+        }
+        this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, null);
+        if (declaracao.superClasse !== null) {
+            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
+        }
+        const metodos = {};
+        const definirMetodos = declaracao.metodos;
+        for (let i = 0; i < declaracao.metodos.length; i++) {
+            const metodoAtual = definirMetodos[i];
+            const eInicializador = metodoAtual.simbolo.lexema === 'construtor';
+            const funcao = new delegua_funcao_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
+            metodos[metodoAtual.simbolo.lexema] = funcao;
+        }
+        const deleguaClasse = new delegua_classe_1.DeleguaClasse(declaracao.simbolo.lexema, superClasse, metodos);
+        // TODO: Recolocar isso se for necessário.
+        /* if (superClasse !== null) {
+            this.ambiente = this.ambiente.enclosing;
+        } */
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, deleguaClasse);
+        return null;
+    }
+    async visitarExpressaoAcessoMetodo(expressao) {
+        const variavelObjeto = await this.avaliar(expressao.objeto);
+        const objeto = variavelObjeto === null || variavelObjeto === void 0 ? void 0 : variavelObjeto.valor;
+        if (objeto instanceof objeto_delegua_classe_1.ObjetoDeleguaClasse) {
+            return objeto.obter(expressao.simbolo) || null;
+        }
+        else if (objeto.constructor === Object) {
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+        else if (objeto instanceof modulo_1.DeleguaModulo) {
+            return objeto[expressao.simbolo.lexema] || null;
+        }
+        throw new excecoes_1.ErroEmTempoDeExecucao(expressao.nome, 'Você só pode acessar métodos do objeto e dicionários.', expressao.linha);
+    }
+    visitarExpressaoIsto(expressao) {
         return this.procurarVariavel(expressao.palavraChave, expressao);
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoDicionario = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var dicionario, i, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        dicionario = {};
-                        i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(i < expressao.chaves.length)) return [3 /*break*/, 5];
-                        _a = dicionario;
-                        return [4 /*yield*/, this.avaliar(expressao.chaves[i])];
-                    case 2:
-                        _b = _c.sent();
-                        return [4 /*yield*/, this.avaliar(expressao.valores[i])];
-                    case 3:
-                        _a[_b] = _c.sent();
-                        _c.label = 4;
-                    case 4:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 5: return [2 /*return*/, dicionario];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoVetor = function (expressao) {
-        return __awaiter(this, void 0, void 0, function () {
-            var valores, i, _a, _b;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        valores = [];
-                        i = 0;
-                        _c.label = 1;
-                    case 1:
-                        if (!(i < expressao.valores.length)) return [3 /*break*/, 4];
-                        _b = (_a = valores).push;
-                        return [4 /*yield*/, this.avaliar(expressao.valores[i])];
-                    case 2:
-                        _b.apply(_a, [_c.sent()]);
-                        _c.label = 3;
-                    case 3:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 4: return [2 /*return*/, valores];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.visitarExpressaoSuper = function (expressao) {
-        var distancia = this.locais.get(expressao);
-        var superClasse = this.pilhaEscoposExecucao.obterVariavelEm(distancia, 'super');
-        var objeto = this.pilhaEscoposExecucao.obterVariavelEm(distancia - 1, 'isto');
-        var metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
+    }
+    async visitarExpressaoDicionario(expressao) {
+        const dicionario = {};
+        for (let i = 0; i < expressao.chaves.length; i++) {
+            dicionario[await this.avaliar(expressao.chaves[i])] = await this.avaliar(expressao.valores[i]);
+        }
+        return dicionario;
+    }
+    async visitarExpressaoVetor(expressao) {
+        const valores = [];
+        for (let i = 0; i < expressao.valores.length; i++) {
+            valores.push(await this.avaliar(expressao.valores[i]));
+        }
+        return valores;
+    }
+    visitarExpressaoSuper(expressao) {
+        const distancia = this.locais.get(expressao);
+        const superClasse = this.pilhaEscoposExecucao.obterVariavelEm(distancia, 'super');
+        const objeto = this.pilhaEscoposExecucao.obterVariavelEm(distancia - 1, 'isto');
+        const metodo = superClasse.valor.encontrarMetodo(expressao.metodo.lexema);
         if (metodo === undefined) {
             throw new excecoes_1.ErroEmTempoDeExecucao(expressao.metodo, 'Método chamado indefinido.', expressao.linha);
         }
         return metodo.definirInstancia(objeto.valor);
-    };
-    InterpretadorEguaClassico.prototype.paraTexto = function (objeto) {
+    }
+    paraTexto(objeto) {
         if (objeto === null)
             return 'nulo';
         if (typeof objeto === 'boolean') {
             return objeto ? 'verdadeiro' : 'falso';
         }
         if (objeto instanceof Date) {
-            var formato = Intl.DateTimeFormat('pt', {
+            const formato = Intl.DateTimeFormat('pt', {
                 dateStyle: 'full',
                 timeStyle: 'full',
             });
@@ -1084,18 +693,10 @@ var InterpretadorEguaClassico = /** @class */ (function () {
             return 'nulo';
         }
         return objeto.toString();
-    };
-    InterpretadorEguaClassico.prototype.executar = function (declaracao, mostrarResultado) {
-        if (mostrarResultado === void 0) { mostrarResultado = false; }
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, declaracao.aceitar(this)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
+    }
+    async executar(declaracao, mostrarResultado = false) {
+        return await declaracao.aceitar(this);
+    }
     /**
      * Executa o último escopo empilhado no topo na pilha de escopos do Interpretador.
      * Originalmente, Égua não trabalha com uma pilha de escopos.
@@ -1109,69 +710,41 @@ var InterpretadorEguaClassico = /** @class */ (function () {
      * Interpretador Égua: https://github.com/eguatech/egua/blob/master/src/interpreter.js
      * @returns O resultado da execução do escopo, se houver.
      */
-    InterpretadorEguaClassico.prototype.executarUltimoEscopo = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var ultimoEscopo, retornoExecucao, erro_9;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, 7, 8]);
-                        retornoExecucao = void 0;
-                        _a.label = 2;
-                    case 2:
-                        if (!(!(retornoExecucao instanceof quebras_1.Quebra) &&
-                            ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual])];
-                    case 3:
-                        retornoExecucao = _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        ultimoEscopo.declaracaoAtual++;
-                        return [3 /*break*/, 2];
-                    case 5: return [2 /*return*/, retornoExecucao];
-                    case 6:
-                        erro_9 = _a.sent();
-                        return [2 /*return*/, erro_9];
-                    case 7:
-                        this.pilhaEscoposExecucao.removerUltimo();
-                        return [7 /*endfinally*/];
-                    case 8: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.interpretar = function (declaracoes) {
-        return __awaiter(this, void 0, void 0, function () {
-            var retornoResolvedor, escopoExecucao;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.erros = [];
-                        retornoResolvedor = this.resolvedor.resolver(declaracoes);
-                        this.locais = retornoResolvedor.locais;
-                        escopoExecucao = {
-                            declaracoes: declaracoes,
-                            declaracaoAtual: 0,
-                            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
-                        };
-                        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
-                        return [4 /*yield*/, this.executarUltimoEscopo()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, {
-                                erros: this.erros,
-                            }];
-                }
-            });
-        });
-    };
-    InterpretadorEguaClassico.prototype.finalizacao = function () {
+    async executarUltimoEscopo() {
+        const ultimoEscopo = this.pilhaEscoposExecucao.topoDaPilha();
+        try {
+            let retornoExecucao;
+            for (; !(retornoExecucao instanceof quebras_1.Quebra) &&
+                ultimoEscopo.declaracaoAtual < ultimoEscopo.declaracoes.length; ultimoEscopo.declaracaoAtual++) {
+                retornoExecucao = await this.executar(ultimoEscopo.declaracoes[ultimoEscopo.declaracaoAtual]);
+            }
+            return retornoExecucao;
+        }
+        catch (erro) {
+            return erro;
+        }
+        finally {
+            this.pilhaEscoposExecucao.removerUltimo();
+        }
+    }
+    async interpretar(declaracoes) {
+        this.erros = [];
+        const retornoResolvedor = this.resolvedor.resolver(declaracoes);
+        this.locais = retornoResolvedor.locais;
+        const escopoExecucao = {
+            declaracoes: declaracoes,
+            declaracaoAtual: 0,
+            ambiente: new espaco_variaveis_1.EspacoVariaveis(),
+        };
+        this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        await this.executarUltimoEscopo();
+        return {
+            erros: this.erros,
+        };
+    }
+    finalizacao() {
         this.funcaoDeRetorno();
-    };
-    return InterpretadorEguaClassico;
-}());
+    }
+}
 exports.InterpretadorEguaClassico = InterpretadorEguaClassico;
 //# sourceMappingURL=egua-classico.js.map