@designliquido/delegua 0.35.2 → 0.36.0

package/umd/delegua.js

@@ -230,14 +230,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AvaliadorSintatico = void 0;
-const delegua_1 = __importDefault(require("../tipos-de-simbolos/delegua"));
-const delegua_2 = __importDefault(require("../tipos-de-dados/delegua"));
 const browser_process_hrtime_1 = __importDefault(require("browser-process-hrtime"));
+const delegua_1 = __importDefault(require("../tipos-de-dados/delegua"));
+const delegua_2 = __importDefault(require("../tipos-de-simbolos/delegua"));
 const construtos_1 = require("../construtos");
 const erro_avaliador_sintatico_1 = require("./erro-avaliador-sintatico");
+const tuplas_1 = require("../construtos/tuplas");
 const declaracoes_1 = require("../declaracoes");
 const lexador_1 = require("../lexador");
-const tuplas_1 = require("../construtos/tuplas");
 /**
  * O avaliador sintático (_Parser_) é responsável por transformar os símbolos do Lexador em estruturas de alto nível.
  * Essas estruturas de alto nível são as partes que executam lógica de programação de fato.
@@ -273,13 +273,13 @@ class AvaliadorSintatico {
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
     verificarDefinicaoTipoAtual() {
-        const tipos = [...Object.values(delegua_2.default)];
+        const tipos = [...Object.values(delegua_1.default)];
         const lexema = this.simboloAtual().lexema.toLowerCase();
         const contemTipo = tipos.find((tipo) => tipo === lexema);
-        if (contemTipo && this.verificarTipoProximoSimbolo(delegua_1.default.COLCHETE_ESQUERDO)) {
+        if (contemTipo && this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_ESQUERDO)) {
             const tiposVetores = ['inteiro[]', 'numero[]', 'número[]', 'qualquer[]', 'real[]', 'texto[]'];
             this.avancarEDevolverAnterior();
-            if (!this.verificarTipoProximoSimbolo(delegua_1.default.COLCHETE_DIREITO)) {
+            if (!this.verificarTipoProximoSimbolo(delegua_2.default.COLCHETE_DIREITO)) {
                 throw this.erro(this.simbolos[this.atual], "Esperado símbolo de fechamento do vetor ']'.");
             }
             const contemTipoVetor = tiposVetores.find((tipo) => tipo === `${lexema}[]`);
@@ -316,124 +316,124 @@ class AvaliadorSintatico {
         const simboloAtual = this.simbolos[this.atual];
         let valores = [];
         switch (simboloAtual.tipo) {
-            case delegua_1.default.CHAVE_ESQUERDA:
+            case delegua_2.default.CHAVE_ESQUERDA:
                 this.avancarEDevolverAnterior();
                 const chaves = [];
                 valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
                     return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), [], []);
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA)) {
+                while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA)) {
                     const chave = this.atribuir();
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' entre chave e valor.");
                     const valor = this.atribuir();
                     chaves.push(chave);
                     valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== delegua_1.default.CHAVE_DIREITA) {
-                        this.consumir(delegua_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    if (this.simbolos[this.atual].tipo !== delegua_2.default.CHAVE_DIREITA) {
+                        this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                     }
                 }
                 return new construtos_1.Dicionario(this.hashArquivo, Number(simboloAtual.linha), chaves, valores);
-            case delegua_1.default.COLCHETE_ESQUERDO:
+            case delegua_2.default.COLCHETE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 valores = [];
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_DIREITO)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
                     return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), []);
                 }
-                while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_DIREITO)) {
+                while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_DIREITO)) {
                     let valor = null;
-                    if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO)) {
+                    if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                         const expressao = this.expressao();
                         const argumentos = [expressao];
-                        while (this.simbolos[this.atual].tipo === delegua_1.default.VIRGULA) {
+                        while (this.simbolos[this.atual].tipo === delegua_2.default.VIRGULA) {
                             this.avancarEDevolverAnterior();
                             argumentos.push(this.expressao());
                         }
-                        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
-                        this.consumir(delegua_1.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
+                        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                        this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após a expressão.");
                         return new tuplas_1.SeletorTuplas(...argumentos);
                     }
                     valor = this.atribuir();
                     valores.push(valor);
-                    if (this.simbolos[this.atual].tipo !== delegua_1.default.COLCHETE_DIREITO) {
-                        this.consumir(delegua_1.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
+                    if (this.simbolos[this.atual].tipo !== delegua_2.default.COLCHETE_DIREITO) {
+                        this.consumir(delegua_2.default.VIRGULA, 'Esperado vírgula antes da próxima expressão.');
                     }
                 }
                 return new construtos_1.Vetor(this.hashArquivo, Number(simboloAtual.linha), valores);
-            case delegua_1.default.FALSO:
+            case delegua_2.default.FALSO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), false);
-            case delegua_1.default.FUNCAO:
-            case delegua_1.default.FUNÇÃO:
+            case delegua_2.default.FUNCAO:
+            case delegua_2.default.FUNÇÃO:
                 const simboloFuncao = this.avancarEDevolverAnterior();
                 return this.corpoDaFuncao(simboloFuncao.lexema);
-            case delegua_1.default.IDENTIFICADOR:
+            case delegua_2.default.IDENTIFICADOR:
                 const simboloIdentificador = this.avancarEDevolverAnterior();
                 // Se o próximo símbolo é um incremento ou um decremento,
                 // aqui deve retornar um unário correspondente.
                 // Caso contrário, apenas retornar um construto de variável.
                 if (this.simbolos[this.atual] &&
-                    [delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
+                    [delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR].includes(this.simbolos[this.atual].tipo)) {
                     const simboloIncrementoDecremento = this.avancarEDevolverAnterior();
                     return new construtos_1.Unario(this.hashArquivo, simboloIncrementoDecremento, new construtos_1.Variavel(this.hashArquivo, simboloIdentificador), 'DEPOIS');
                 }
                 return new construtos_1.Variavel(this.hashArquivo, simboloIdentificador);
-            case delegua_1.default.IMPORTAR:
+            case delegua_2.default.IMPORTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoImportar();
-            case delegua_1.default.ISTO:
+            case delegua_2.default.ISTO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Isto(this.hashArquivo, Number(simboloAtual.linha), simboloAtual);
-            case delegua_1.default.NULO:
+            case delegua_2.default.NULO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), null);
-            case delegua_1.default.NUMERO:
-            case delegua_1.default.TEXTO:
+            case delegua_2.default.NUMERO:
+            case delegua_2.default.TEXTO:
                 const simboloNumeroTexto = this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloNumeroTexto.linha), simboloNumeroTexto.literal);
-            case delegua_1.default.PARENTESE_ESQUERDO:
+            case delegua_2.default.PARENTESE_ESQUERDO:
                 this.avancarEDevolverAnterior();
                 const expressao = this.expressao();
-                this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
+                this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após a expressão.");
                 return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
-            case delegua_1.default.SUPER:
+            case delegua_2.default.SUPER:
                 const simboloSuper = this.avancarEDevolverAnterior();
                 // Se o próximo símbolo for uma abertura de parênteses, significa que
                 // é uma chamada ao construtor da classe ancestral (superclasse).
                 // Se o próximo símbolo for um ponto, significa que é uma chamada
                 // a um método da superclasse.
                 switch (this.simbolos[this.atual].tipo) {
-                    case delegua_1.default.PARENTESE_ESQUERDO:
-                        return new construtos_1.Super(this.hashArquivo, simboloSuper, new lexador_1.Simbolo(delegua_1.default.IDENTIFICADOR, 'construtor', null, simboloSuper.linha, this.hashArquivo));
+                    case delegua_2.default.PARENTESE_ESQUERDO:
+                        return new construtos_1.Super(this.hashArquivo, simboloSuper, new lexador_1.Simbolo(delegua_2.default.IDENTIFICADOR, 'construtor', null, simboloSuper.linha, this.hashArquivo));
                     default:
-                        this.consumir(delegua_1.default.PONTO, "Esperado '.' após 'super'.");
-                        const metodoSuperclasse = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
+                        this.consumir(delegua_2.default.PONTO, "Esperado '.' após 'super'.");
+                        const metodoSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
                         return new construtos_1.Super(this.hashArquivo, simboloSuper, metodoSuperclasse);
                 }
-            case delegua_1.default.VERDADEIRO:
+            case delegua_2.default.VERDADEIRO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true);
-            case delegua_1.default.TIPO:
+            case delegua_2.default.TIPO:
                 this.avancarEDevolverAnterior();
-                this.consumir(delegua_1.default.DE, "Esperado 'de' após 'tipo'.");
+                this.consumir(delegua_2.default.DE, "Esperado 'de' após 'tipo'.");
                 let _expressao;
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.ESCREVA, delegua_1.default.LEIA, delegua_1.default.FUNCAO, delegua_1.default.FUNÇÃO, delegua_1.default.SE, delegua_1.default.ENQUANTO, delegua_1.default.PARA, delegua_1.default.RETORNA, delegua_2.default.INTEIRO, delegua_2.default.TEXTO, delegua_2.default.VETOR, delegua_2.default.LOGICO, delegua_2.default.LÓGICO, delegua_2.default.VAZIO)) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESCREVA, delegua_2.default.LEIA, delegua_2.default.FUNCAO, delegua_2.default.FUNÇÃO, delegua_2.default.SE, delegua_2.default.ENQUANTO, delegua_2.default.PARA, delegua_2.default.RETORNA, delegua_1.default.INTEIRO, delegua_1.default.TEXTO, delegua_1.default.VETOR, delegua_1.default.LOGICO, delegua_1.default.LÓGICO, delegua_1.default.VAZIO)) {
                     _expressao = this.simboloAnterior();
                 }
                 else {
                     _expressao = this.expressao();
                 }
                 return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, _expressao instanceof construtos_1.Literal ? _expressao.valor : _expressao);
-            case delegua_1.default.EXPRESSAO_REGULAR:
+            case delegua_2.default.EXPRESSAO_REGULAR:
                 let valor = '';
                 let linhaAtual = this.simbolos[this.atual].linha;
-                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_1.default.EXPRESSAO_REGULAR)
+                let eParExpressaoRegular = this.simbolos.filter((l) => l.linha === linhaAtual && l.tipo === delegua_2.default.EXPRESSAO_REGULAR)
                     .length %
                     2 ===
                     0;
                 if (eParExpressaoRegular) {
                     this.avancarEDevolverAnterior();
-                    while (!this.verificarTipoSimboloAtual(delegua_1.default.EXPRESSAO_REGULAR)) {
+                    while (!this.verificarTipoSimboloAtual(delegua_2.default.EXPRESSAO_REGULAR)) {
                         valor += this.simboloAtual().lexema || '';
                         this.avancarEDevolverAnterior();
                     }
@@ -445,30 +445,30 @@ class AvaliadorSintatico {
     }
     finalizarChamada(entidadeChamada) {
         const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
                 if (argumentos.length >= 255) {
                     throw this.erro(this.simbolos[this.atual], 'Não pode haver mais de 255 argumentos.');
                 }
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        const parenteseDireito = this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
+        const parenteseDireito = this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos.");
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamada, parenteseDireito, argumentos);
     }
     chamar() {
         let expressao = this.primario();
         while (true) {
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO)) {
                 expressao = this.finalizarChamada(expressao);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO)) {
-                const nome = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado nome do método após '.'.");
+            else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO)) {
+                const nome = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome de método ou propriedade após '.'.");
                 expressao = new construtos_1.AcessoMetodoOuPropriedade(this.hashArquivo, expressao, nome);
             }
-            else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.COLCHETE_ESQUERDO)) {
+            else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.COLCHETE_ESQUERDO)) {
                 const indice = this.expressao();
-                const simboloFechamento = this.consumir(delegua_1.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
+                const simboloFechamento = this.consumir(delegua_2.default.COLCHETE_DIREITO, "Esperado ']' após escrita do indice.");
                 expressao = new construtos_1.AcessoIndiceVariavel(this.hashArquivo, expressao, indice, simboloFechamento);
             }
             else {
@@ -478,7 +478,7 @@ class AvaliadorSintatico {
         return expressao;
     }
     unario() {
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.NEGACAO, delegua_1.default.SUBTRACAO, delegua_1.default.BIT_NOT, delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.NEGACAO, delegua_2.default.SUBTRACAO, delegua_2.default.BIT_NOT, delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             return new construtos_1.Unario(this.hashArquivo, operador, direito, 'ANTES');
@@ -487,7 +487,7 @@ class AvaliadorSintatico {
     }
     exponenciacao() {
         let expressao = this.unario();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.EXPONENCIACAO)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EXPONENCIACAO)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.unario();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -496,7 +496,7 @@ class AvaliadorSintatico {
     }
     multiplicar() {
         let expressao = this.exponenciacao();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DIVISAO, delegua_1.default.DIVISAO_IGUAL, delegua_1.default.DIVISAO_INTEIRA, delegua_1.default.DIVISAO_INTEIRA_IGUAL, delegua_1.default.MODULO, delegua_1.default.MODULO_IGUAL, delegua_1.default.MULTIPLICACAO, delegua_1.default.MULTIPLICACAO_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DIVISAO, delegua_2.default.DIVISAO_IGUAL, delegua_2.default.DIVISAO_INTEIRA, delegua_2.default.DIVISAO_INTEIRA_IGUAL, delegua_2.default.MODULO, delegua_2.default.MODULO_IGUAL, delegua_2.default.MULTIPLICACAO, delegua_2.default.MULTIPLICACAO_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.exponenciacao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -510,7 +510,7 @@ class AvaliadorSintatico {
      */
     adicaoOuSubtracao() {
         let expressao = this.multiplicar();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SUBTRACAO, delegua_1.default.ADICAO, delegua_1.default.MAIS_IGUAL, delegua_1.default.MENOS_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SUBTRACAO, delegua_2.default.ADICAO, delegua_2.default.MAIS_IGUAL, delegua_2.default.MENOS_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.multiplicar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -519,7 +519,7 @@ class AvaliadorSintatico {
     }
     bitShift() {
         let expressao = this.adicaoOuSubtracao();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.MENOR_MENOR, delegua_1.default.MAIOR_MAIOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MENOR_MENOR, delegua_2.default.MAIOR_MAIOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.adicaoOuSubtracao();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -528,7 +528,7 @@ class AvaliadorSintatico {
     }
     bitE() {
         let expressao = this.bitShift();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.BIT_AND)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.BIT_AND)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitShift();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -537,7 +537,7 @@ class AvaliadorSintatico {
     }
     bitOu() {
         let expressao = this.bitE();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.BIT_OR, delegua_1.default.BIT_XOR)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.BIT_OR, delegua_2.default.BIT_XOR)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitE();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -546,7 +546,7 @@ class AvaliadorSintatico {
     }
     comparar() {
         let expressao = this.bitOu();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.MAIOR, delegua_1.default.MAIOR_IGUAL, delegua_1.default.MENOR, delegua_1.default.MENOR_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.MAIOR, delegua_2.default.MAIOR_IGUAL, delegua_2.default.MENOR, delegua_2.default.MENOR_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.bitOu();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -555,7 +555,7 @@ class AvaliadorSintatico {
     }
     comparacaoIgualdade() {
         let expressao = this.comparar();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DIFERENTE, delegua_1.default.IGUAL_IGUAL)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DIFERENTE, delegua_2.default.IGUAL_IGUAL)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparar();
             expressao = new construtos_1.Binario(this.hashArquivo, expressao, operador, direito);
@@ -564,7 +564,7 @@ class AvaliadorSintatico {
     }
     em() {
         let expressao = this.comparacaoIgualdade();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.EM)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EM)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.comparacaoIgualdade();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -573,7 +573,7 @@ class AvaliadorSintatico {
     }
     e() {
         let expressao = this.em();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.E)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.E)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.em();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -582,7 +582,7 @@ class AvaliadorSintatico {
     }
     ou() {
         let expressao = this.e();
-        while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.OU)) {
+        while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.OU)) {
             const operador = this.simbolos[this.atual - 1];
             const direito = this.e();
             expressao = new construtos_1.Logico(this.hashArquivo, expressao, operador, direito);
@@ -597,16 +597,21 @@ class AvaliadorSintatico {
         const expressao = this.ou();
         if (expressao instanceof construtos_1.Binario &&
             [
-                delegua_1.default.MAIS_IGUAL,
-                delegua_1.default.MENOS_IGUAL,
-                delegua_1.default.MULTIPLICACAO_IGUAL,
-                delegua_1.default.DIVISAO_IGUAL,
-                delegua_1.default.DIVISAO_INTEIRA_IGUAL,
-                delegua_1.default.MODULO_IGUAL,
+                delegua_2.default.MAIS_IGUAL,
+                delegua_2.default.MENOS_IGUAL,
+                delegua_2.default.MULTIPLICACAO_IGUAL,
+                delegua_2.default.DIVISAO_IGUAL,
+                delegua_2.default.DIVISAO_INTEIRA_IGUAL,
+                delegua_2.default.MODULO_IGUAL,
             ].includes(expressao.operador.tipo)) {
-            return new construtos_1.Atribuir(this.hashArquivo, expressao.esquerda.simbolo, expressao);
+            let simbolo = expressao.esquerda.simbolo;
+            if (expressao.esquerda instanceof construtos_1.AcessoIndiceVariavel) {
+                simbolo = expressao.esquerda.entidadeChamada.simbolo;
+                return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao, expressao.esquerda.indice);
+            }
+            return new construtos_1.Atribuir(this.hashArquivo, simbolo, expressao);
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
             const igual = this.simbolos[this.atual - 1];
             const valor = this.expressao();
             if (expressao instanceof construtos_1.Variavel) {
@@ -625,13 +630,13 @@ class AvaliadorSintatico {
         return expressao;
     }
     expressao() {
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.LEIA))
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.LEIA))
             return this.declaracaoLeia();
         return this.atribuir();
     }
     blocoEscopo() {
         let declaracoes = [];
-        while (!this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
             const retornoDeclaracao = this.resolverDeclaracaoForaDeBloco();
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
@@ -640,8 +645,8 @@ class AvaliadorSintatico {
                 declaracoes.push(retornoDeclaracao);
             }
         }
-        this.consumir(delegua_1.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o bloco.");
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return declaracoes;
     }
     declaracaoEnquanto() {
@@ -657,22 +662,22 @@ class AvaliadorSintatico {
     }
     declaracaoEscreva() {
         const simboloAtual = this.simbolos[this.atual];
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos valores em escreva.");
         const argumentos = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             do {
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os valores em escreva.");
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Escreva(Number(simboloAtual.linha), simboloAtual.hashArquivo, argumentos);
     }
     declaracaoExpressao() {
         const expressao = this.expressao();
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Expressao(expressao);
     }
     declaracaoComentarioMultilinha() {
@@ -681,7 +686,7 @@ class AvaliadorSintatico {
         do {
             simboloComentario = this.avancarEDevolverAnterior();
             conteudos.push(simboloComentario.literal);
-        } while (simboloComentario.tipo === delegua_1.default.LINHA_COMENTARIO);
+        } while (simboloComentario.tipo === delegua_2.default.LINHA_COMENTARIO);
         return new construtos_1.Comentario(simboloComentario.hashArquivo, simboloComentario.linha, conteudos, true);
     }
     declaracaoComentarioUmaLinha() {
@@ -693,24 +698,24 @@ class AvaliadorSintatico {
             this.erro(this.simbolos[this.atual - 1], "'continua' precisa estar em um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Continua(this.simbolos[this.atual - 1]);
     }
     declaracaoEscolha() {
         try {
             this.blocos += 1;
             const condicao = this.expressao();
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo do 'escolha'.");
             const caminhos = [];
             let caminhoPadrao = null;
-            while (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
-                if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CASO)) {
+            while (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CASO)) {
                     const caminhoCondicoes = [this.expressao()];
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
-                    while (this.verificarTipoSimboloAtual(delegua_1.default.CASO)) {
-                        this.consumir(delegua_1.default.CASO, null);
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após o 'caso'.");
+                    while (this.verificarTipoSimboloAtual(delegua_2.default.CASO)) {
+                        this.consumir(delegua_2.default.CASO, null);
                         caminhoCondicoes.push(this.expressao());
-                        this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
+                        this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'caso'.");
                     }
                     let declaracoes = [];
                     do {
@@ -721,27 +726,27 @@ class AvaliadorSintatico {
                         else {
                             declaracoes.push(retornoDeclaracao);
                         }
-                    } while (!this.verificarTipoSimboloAtual(delegua_1.default.CASO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA));
+                    } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
                     caminhos.push({
                         condicoes: caminhoCondicoes,
                         declaracoes,
                     });
                 }
-                else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PADRAO)) {
+                else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PADRAO)) {
                     if (caminhoPadrao !== null) {
                         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(this.simbolos[this.atual], "Você só pode ter um 'padrao' em cada declaração de 'escolha'.");
                         this.erros.push(excecao);
                         throw excecao;
                     }
-                    this.consumir(delegua_1.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
+                    this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após declaração do 'padrao'.");
                     const declaracoes = [];
                     do {
                         declaracoes.push(this.resolverDeclaracao());
-                    } while (!this.verificarTipoSimboloAtual(delegua_1.default.CASO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.PADRAO) &&
-                        !this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA));
+                    } while (!this.verificarTipoSimboloAtual(delegua_2.default.CASO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.PADRAO) &&
+                        !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA));
                     caminhoPadrao = {
                         declaracoes,
                     };
@@ -762,7 +767,7 @@ class AvaliadorSintatico {
         try {
             this.blocos += 1;
             const caminhoFazer = this.resolverDeclaracao();
-            this.consumir(delegua_1.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
+            this.consumir(delegua_2.default.ENQUANTO, "Esperado declaração do 'enquanto' após o escopo do 'fazer'.");
             const condicaoEnquanto = this.expressao();
             return new declaracoes_1.Fazer(simboloFazer.hashArquivo, Number(simboloFazer.linha), caminhoFazer, condicaoEnquanto);
         }
@@ -771,9 +776,9 @@ class AvaliadorSintatico {
         }
     }
     declaracaoImportar() {
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após declaração.");
         const caminho = this.expressao();
-        const simboloFechamento = this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
+        const simboloFechamento = this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após declaração.");
         return new declaracoes_1.Importar(caminho, simboloFechamento);
     }
     /**
@@ -782,21 +787,21 @@ class AvaliadorSintatico {
      */
     declaracaoLeia() {
         const simboloLeia = this.simbolos[this.atual];
-        this.consumir(delegua_1.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos argumentos em instrução `leia`.");
+        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' antes dos argumentos em instrução `leia`.");
         const argumentos = [];
-        if (this.simbolos[this.atual].tipo !== delegua_1.default.PARENTESE_DIREITO) {
+        if (this.simbolos[this.atual].tipo !== delegua_2.default.PARENTESE_DIREITO) {
             do {
                 argumentos.push(this.expressao());
-            } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos em instrução `leia`.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após os argumentos em instrução `leia`.");
         return new declaracoes_1.Leia(simboloLeia, argumentos);
     }
     declaracaoPara() {
         try {
             const simboloPara = this.simbolos[this.atual - 1];
             this.blocos += 1;
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CADA)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CADA)) {
                 return this.declaracaoParaCada(simboloPara);
             }
             return this.declaracaoParaTradicional(simboloPara);
@@ -806,8 +811,8 @@ class AvaliadorSintatico {
         }
     }
     declaracaoParaCada(simboloPara) {
-        const nomeVariavelIteracao = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.DE, delegua_1.default.EM)) {
+        const nomeVariavelIteracao = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado identificador de variável de iteração para instrução 'para cada'.");
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.DE, delegua_2.default.EM)) {
             throw this.erro(this.simbolos[this.atual], "Esperado palavras reservadas 'em' ou 'de' após variável de iteração em instrução 'para cada'.");
         }
         const vetor = this.expressao();
@@ -815,33 +820,33 @@ class AvaliadorSintatico {
         return new declaracoes_1.ParaCada(this.hashArquivo, Number(simboloPara.linha), nomeVariavelIteracao.lexema, vetor, corpo);
     }
     declaracaoParaTradicional(simboloPara) {
-        const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO);
+        const comParenteses = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
         let inicializador;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA)) {
             inicializador = null;
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VARIAVEL)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VARIAVEL)) {
             inicializador = this.declaracaoDeVariaveis();
         }
-        else if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CONSTANTE)) {
+        else if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CONSTANTE)) {
             inicializador = this.declaracaoDeConstantes();
         }
         else {
             inicializador = this.declaracaoExpressao();
         }
         let condicao = null;
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PONTO_E_VIRGULA)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PONTO_E_VIRGULA)) {
             condicao = this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         let incrementar = null;
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             incrementar = this.expressao();
-            this.verificarSeSimboloAtualEIgualA(delegua_1.default.INCREMENTAR, delegua_1.default.DECREMENTAR);
+            this.verificarSeSimboloAtualEIgualA(delegua_2.default.INCREMENTAR, delegua_2.default.DECREMENTAR);
         }
         if (comParenteses) {
-            this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas de inicialização, condição e incremento.");
+            this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após cláusulas de inicialização, condição e incremento.");
         }
         const corpo = this.resolverDeclaracao();
         return new declaracoes_1.Para(this.hashArquivo, Number(simboloPara.linha), inicializador, condicao, incrementar, corpo);
@@ -850,30 +855,30 @@ class AvaliadorSintatico {
         const simboloChave = this.simbolos[this.atual - 1];
         let valor = null;
         if ([
-            delegua_1.default.CHAVE_ESQUERDA,
-            delegua_1.default.COLCHETE_ESQUERDO,
-            delegua_1.default.FALSO,
-            delegua_1.default.IDENTIFICADOR,
-            delegua_1.default.ISTO,
-            delegua_1.default.NEGACAO,
-            delegua_1.default.NUMERO,
-            delegua_1.default.NULO,
-            delegua_1.default.PARENTESE_ESQUERDO,
-            delegua_1.default.SUPER,
-            delegua_1.default.TEXTO,
-            delegua_1.default.VERDADEIRO,
+            delegua_2.default.CHAVE_ESQUERDA,
+            delegua_2.default.COLCHETE_ESQUERDO,
+            delegua_2.default.FALSO,
+            delegua_2.default.IDENTIFICADOR,
+            delegua_2.default.ISTO,
+            delegua_2.default.NEGACAO,
+            delegua_2.default.NUMERO,
+            delegua_2.default.NULO,
+            delegua_2.default.PARENTESE_ESQUERDO,
+            delegua_2.default.SUPER,
+            delegua_2.default.TEXTO,
+            delegua_2.default.VERDADEIRO,
         ].includes(this.simbolos[this.atual].tipo)) {
             valor = this.expressao();
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Retorna(simboloChave, valor);
     }
     declaracaoSe() {
         const condicao = this.expressao();
         const caminhoEntao = this.resolverDeclaracao();
         let caminhoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SENAO, delegua_1.default.SENÃO)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
             caminhoSenao = this.resolverDeclaracao();
         }
         return new declaracoes_1.Se(condicao, caminhoEntao, [], caminhoSenao);
@@ -883,16 +888,16 @@ class AvaliadorSintatico {
             this.erro(this.simbolos[this.atual - 1], "'sustar' ou 'pausa' deve estar dentro de um laço de repetição.");
         }
         // Ponto-e-vírgula é opcional aqui.
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return new declaracoes_1.Sustar(this.simbolos[this.atual - 1]);
     }
     declaracaoTente() {
         const simboloTente = this.simbolos[this.atual - 1];
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'tente'.");
         const blocoTente = this.blocoEscopo();
         let blocoPegue = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.PEGUE)) {
-            if (this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_ESQUERDO)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.PEGUE)) {
+            if (this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_ESQUERDO)) {
                 // Caso 1: com parâmetro de erro.
                 // `pegue` recebe um `FuncaoConstruto`.
                 blocoPegue = this.corpoDaFuncao('bloco `pegue`');
@@ -900,25 +905,25 @@ class AvaliadorSintatico {
             else {
                 // Caso 2: sem parâmetro de erro.
                 // `pegue` recebe um bloco.
-                this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
+                this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'pegue'.");
                 blocoPegue = this.blocoEscopo();
             }
         }
         let blocoSenao = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.SENAO, delegua_1.default.SENÃO)) {
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'senão'.");
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.SENAO, delegua_2.default.SENÃO)) {
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'senão'.");
             blocoSenao = this.blocoEscopo();
         }
         let blocoFinalmente = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.FINALMENTE)) {
-            this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'finalmente'.");
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.FINALMENTE)) {
+            this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após a declaração 'finalmente'.");
             blocoFinalmente = this.blocoEscopo();
         }
         return new declaracoes_1.Tente(simboloTente.hashArquivo, Number(simboloTente.linha), blocoTente, blocoPegue, blocoSenao, blocoFinalmente);
     }
     resolverDecorador() {
         this.pilhaDecoradores = [];
-        while (this.verificarTipoSimboloAtual(delegua_1.default.ARROBA)) {
+        while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
             let nomeDecorador = '';
             let linha;
             let parametros = [];
@@ -926,12 +931,12 @@ class AvaliadorSintatico {
             linha = this.simbolos[this.atual].linha;
             let simbolosLinhaAtual = this.simbolos.filter((l) => l.linha === linha);
             for (let simbolo of simbolosLinhaAtual) {
-                parenteseEsquerdo = this.verificarSeSimboloAtualEIgualA(delegua_1.default.PARENTESE_ESQUERDO);
+                parenteseEsquerdo = this.verificarSeSimboloAtualEIgualA(delegua_2.default.PARENTESE_ESQUERDO);
                 if (parenteseEsquerdo) {
-                    if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+                    if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
                         parametros = this.logicaComumParametros();
                     }
-                    this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+                    this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
                     break;
                 }
                 this.avancarEDevolverAnterior();
@@ -950,65 +955,65 @@ class AvaliadorSintatico {
      */
     resolverDeclaracao() {
         switch (this.simbolos[this.atual].tipo) {
-            case delegua_1.default.CHAVE_ESQUERDA:
+            case delegua_2.default.CHAVE_ESQUERDA:
                 const simboloInicioBloco = this.avancarEDevolverAnterior();
                 return new declaracoes_1.Bloco(simboloInicioBloco.hashArquivo, Number(simboloInicioBloco.linha), this.blocoEscopo());
-            case delegua_1.default.COMENTARIO:
+            case delegua_2.default.COMENTARIO:
                 return this.declaracaoComentarioUmaLinha();
-            case delegua_1.default.CONSTANTE:
+            case delegua_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeConstantes();
-            case delegua_1.default.CONTINUA:
+            case delegua_2.default.CONTINUA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoContinua();
-            case delegua_1.default.ENQUANTO:
+            case delegua_2.default.ENQUANTO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEnquanto();
-            case delegua_1.default.ESCOLHA:
+            case delegua_2.default.ESCOLHA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscolha();
-            case delegua_1.default.ESCREVA:
+            case delegua_2.default.ESCREVA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoEscreva();
-            case delegua_1.default.FALHAR:
+            case delegua_2.default.FALHAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFalhar();
-            case delegua_1.default.FAZER:
+            case delegua_2.default.FAZER:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoFazer();
-            case delegua_1.default.LINHA_COMENTARIO:
+            case delegua_2.default.LINHA_COMENTARIO:
                 return this.declaracaoComentarioMultilinha();
-            case delegua_1.default.PARA:
+            case delegua_2.default.PARA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoPara();
-            case delegua_1.default.PAUSA:
-            case delegua_1.default.SUSTAR:
+            case delegua_2.default.PAUSA:
+            case delegua_2.default.SUSTAR:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSustar();
-            case delegua_1.default.SE:
+            case delegua_2.default.SE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoSe();
-            case delegua_1.default.RETORNA:
+            case delegua_2.default.RETORNA:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoRetorna();
-            case delegua_1.default.TENDO:
+            case delegua_2.default.TENDO:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTendoComo();
-            case delegua_1.default.TENTE:
+            case delegua_2.default.TENTE:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoTente();
-            case delegua_1.default.VARIAVEL:
+            case delegua_2.default.VARIAVEL:
                 this.avancarEDevolverAnterior();
                 return this.declaracaoDeVariaveis();
         }
         const simboloAtual = this.simbolos[this.atual];
-        if (simboloAtual.tipo === delegua_1.default.IDENTIFICADOR) {
+        if (simboloAtual.tipo === delegua_2.default.IDENTIFICADOR) {
             // Pela gramática, a seguinte situação não pode ocorrer:
             // 1. O símbolo anterior ser um identificador; e
             // 2. O símbolo anterior estar na mesma linha do identificador atual.
             const simboloAnterior = this.simbolos[this.atual - 1];
             if (!!simboloAnterior &&
-                simboloAnterior.tipo === delegua_1.default.IDENTIFICADOR &&
+                simboloAnterior.tipo === delegua_2.default.IDENTIFICADOR &&
                 simboloAnterior.linha === simboloAtual.linha) {
                 this.erro(this.simbolos[this.atual], 'Não é permitido ter dois identificadores seguidos na mesma linha.');
             }
@@ -1018,19 +1023,19 @@ class AvaliadorSintatico {
     declaracaoTendoComo() {
         const simboloTendo = this.simbolos[this.atual - 1];
         const expressaoInicializacao = this.expressao();
-        this.consumir(delegua_1.default.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
-        const simboloNomeVariavel = this.consumir(delegua_1.default.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
+        this.consumir(delegua_2.default.COMO, "Esperado palavra reservada 'como' após expressão de inicialização de variável, em declaração 'tendo'.");
+        const simboloNomeVariavel = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome do identificador em declaração 'tendo'.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado chave esquerda para abertura de bloco em declaração 'tendo'.");
         const blocoCorpo = this.blocoEscopo();
         return new declaracoes_1.TendoComo(simboloTendo.linha, simboloTendo.hashArquivo, simboloNomeVariavel, expressaoInicializacao, new declaracoes_1.Bloco(simboloTendo.linha, simboloTendo.hashArquivo, blocoCorpo));
     }
     declaracaoDesestruturacaoVariavel() {
         const identificadores = [];
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        this.consumir(delegua_1.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_1.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
+        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
         const inicializador = this.expressao();
         // TODO: Para cada variável dos identificadores, emitir um `AcessoMetodoOuPropriedade` usando
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
@@ -1048,45 +1053,45 @@ class AvaliadorSintatico {
         const identificadores = [];
         let retorno = [];
         let tipo = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_ESQUERDA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoVariavel();
         }
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        if (!this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+        if (!this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
             // Inicialização de variáveis sem valor.
             for (let [indice, identificador] of identificadores.entries()) {
                 retorno.push(new declaracoes_1.Var(identificador, null, tipo));
             }
-            this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
             return retorno;
         }
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
         }
         for (let [indice, identificador] of identificadores.entries()) {
-            tipo = inicializadores[indice] instanceof tuplas_1.Tupla ? delegua_2.default.TUPLA : tipo;
+            tipo = inicializadores[indice] instanceof tuplas_1.Tupla ? delegua_1.default.TUPLA : tipo;
             retorno.push(new declaracoes_1.Var(identificador, inicializadores[indice], tipo));
         }
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return retorno;
     }
     declaracaoDesestruturacaoConstante() {
         const identificadores = [];
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da variável.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        this.consumir(delegua_1.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
-        this.consumir(delegua_1.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da variável.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        this.consumir(delegua_2.default.CHAVE_DIREITA, 'Esperado chave direita para concluir relação de variáveis a serem desestruturadas.');
+        this.consumir(delegua_2.default.IGUAL, 'Esperado igual após relação de propriedades da desestruturação.');
         const inicializador = this.expressao();
         // TODO: Para cada variável dos identificadores, emitir um `AcessoMetodoOuPropriedade` usando
         // como prefixo o nome do inicializador, e o sufixo o nome de cada propriedade.
@@ -1103,21 +1108,21 @@ class AvaliadorSintatico {
     declaracaoDeConstantes() {
         const identificadores = [];
         let tipo = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CHAVE_ESQUERDA)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CHAVE_ESQUERDA)) {
             return this.declaracaoDesestruturacaoConstante();
         }
         do {
-            identificadores.push(this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da constante.'));
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            identificadores.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da constante.'));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipo = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        this.consumir(delegua_1.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
+        this.consumir(delegua_2.default.IGUAL, "Esperado '=' após identificador em instrução 'constante'.");
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         if (identificadores.length !== inicializadores.length) {
             throw this.erro(this.simboloAtual(), 'Quantidade de identificadores à esquerda do igual é diferente da quantidade de valores à direita.');
         }
@@ -1125,18 +1130,18 @@ class AvaliadorSintatico {
         for (let [indice, identificador] of identificadores.entries()) {
             retorno.push(new declaracoes_1.Const(identificador, inicializadores[indice], tipo));
         }
-        this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
         return retorno;
     }
     funcao(tipo) {
         let simbolo;
         switch (this.simbolos[this.atual].tipo) {
-            case delegua_1.default.CONSTRUTOR:
+            case delegua_2.default.CONSTRUTOR:
                 simbolo = this.avancarEDevolverAnterior();
                 this.pilhaDecoradores = [];
                 break;
             default:
-                simbolo = this.consumir(delegua_1.default.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
+                simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, `Esperado nome de ${tipo}.`);
                 break;
         }
         return new declaracoes_1.FuncaoDeclaracao(simbolo, this.corpoDaFuncao(tipo), null, this.pilhaDecoradores);
@@ -1145,18 +1150,18 @@ class AvaliadorSintatico {
         const parametros = [];
         do {
             const parametro = {};
-            if (this.simbolos[this.atual].tipo === delegua_1.default.MULTIPLICACAO) {
-                this.consumir(delegua_1.default.MULTIPLICACAO, null);
+            if (this.simbolos[this.atual].tipo === delegua_2.default.MULTIPLICACAO) {
+                this.consumir(delegua_2.default.MULTIPLICACAO, null);
                 parametro.abrangencia = 'multiplo';
             }
             else {
                 parametro.abrangencia = 'padrao';
             }
-            parametro.nome = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.IGUAL)) {
+            parametro.nome = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome do parâmetro.');
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IGUAL)) {
                 parametro.valorPadrao = this.primario();
             }
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
                 let tipoDadoParametro = this.verificarDefinicaoTipoAtual();
                 parametro.tipoDado = {
                     nome: this.simbolos[this.atual - 2].lexema,
@@ -1168,43 +1173,43 @@ class AvaliadorSintatico {
             parametros.push(parametro);
             if (parametro.abrangencia === 'multiplo')
                 break;
-        } while (this.verificarSeSimboloAtualEIgualA(delegua_1.default.VIRGULA));
+        } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
         return parametros;
     }
     corpoDaFuncao(tipo) {
         // O parêntese esquerdo é considerado o símbolo inicial para
         // fins de pragma.
-        const parenteseEsquerdo = this.consumir(delegua_1.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
+        const parenteseEsquerdo = this.consumir(delegua_2.default.PARENTESE_ESQUERDO, `Esperado '(' após o nome ${tipo}.`);
         let parametros = [];
-        if (!this.verificarTipoSimboloAtual(delegua_1.default.PARENTESE_DIREITO)) {
+        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
             parametros = this.logicaComumParametros();
         }
-        this.consumir(delegua_1.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
         let tipoRetorno = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.DOIS_PONTOS)) {
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
             tipoRetorno = this.verificarDefinicaoTipoAtual();
             this.avancarEDevolverAnterior();
         }
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, `Esperado '{' antes do escopo do ${tipo}.`);
         const corpo = this.blocoEscopo();
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno);
     }
     declaracaoDeClasse() {
-        const simbolo = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
         const pilhaDecoradoresClasse = this.pilhaDecoradores;
         let superClasse = null;
-        if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.HERDA)) {
-            this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
+            this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1]);
         }
-        this.consumir(delegua_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
         this.pilhaDecoradores = [];
         const metodos = [];
         const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(delegua_1.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
             // Se o símbolo atual é arroba, é um decorador.
             // Caso contrário, verificamos o próximo símbolo.
-            if (this.simbolos[this.atual].tipo === delegua_1.default.ARROBA) {
+            if (this.simbolos[this.atual].tipo === delegua_2.default.ARROBA) {
                 this.resolverDecorador();
                 continue;
             }
@@ -1212,15 +1217,15 @@ class AvaliadorSintatico {
             // Caso contrário, é uma propriedade.
             const proximoSimbolo = this.simbolos[this.atual + 1];
             switch (proximoSimbolo.tipo) {
-                case delegua_1.default.PARENTESE_ESQUERDO:
+                case delegua_2.default.PARENTESE_ESQUERDO:
                     metodos.push(this.funcao('método'));
                     this.pilhaDecoradores = [];
                     break;
-                case delegua_1.default.DOIS_PONTOS:
-                    const nomePropriedade = this.consumir(delegua_1.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
-                    this.consumir(delegua_1.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
+                case delegua_2.default.DOIS_PONTOS:
+                    const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
+                    this.consumir(delegua_2.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
                     const tipoPropriedade = this.avancarEDevolverAnterior();
-                    this.verificarSeSimboloAtualEIgualA(delegua_1.default.PONTO_E_VIRGULA);
+                    this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
                     propriedades.push(new declaracoes_1.PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, this.pilhaDecoradores));
                     this.pilhaDecoradores = [];
                     break;
@@ -1228,7 +1233,7 @@ class AvaliadorSintatico {
                     throw this.erro(this.simbolos[this.atual], 'Esperado definição de método ou propriedade.');
             }
         }
-        this.consumir(delegua_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         return new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse);
     }
     /**
@@ -1241,13 +1246,13 @@ class AvaliadorSintatico {
      */
     resolverDeclaracaoForaDeBloco() {
         try {
-            if ((this.verificarTipoSimboloAtual(delegua_1.default.FUNCAO) ||
-                this.verificarTipoSimboloAtual(delegua_1.default.FUNÇÃO)) &&
-                this.verificarTipoProximoSimbolo(delegua_1.default.IDENTIFICADOR)) {
+            if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
+                this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
+                this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
                 return this.funcao('funcao');
             }
-            if (this.verificarSeSimboloAtualEIgualA(delegua_1.default.CLASSE)) {
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CLASSE)) {
                 return this.declaracaoDeClasse();
             }
             return this.resolverDeclaracao();
@@ -1268,15 +1273,15 @@ class AvaliadorSintatico {
         while (!this.estaNoFinal()) {
             const tipoSimboloAtual = this.simbolos[this.atual - 1].tipo;
             switch (tipoSimboloAtual) {
-                case delegua_1.default.CLASSE:
-                case delegua_1.default.FUNCAO:
-                case delegua_1.default.FUNÇÃO:
-                case delegua_1.default.VARIAVEL:
-                case delegua_1.default.PARA:
-                case delegua_1.default.SE:
-                case delegua_1.default.ENQUANTO:
-                case delegua_1.default.ESCREVA:
-                case delegua_1.default.RETORNA:
+                case delegua_2.default.CLASSE:
+                case delegua_2.default.FUNCAO:
+                case delegua_2.default.FUNÇÃO:
+                case delegua_2.default.VARIAVEL:
+                case delegua_2.default.PARA:
+                case delegua_2.default.SE:
+                case delegua_2.default.ENQUANTO:
+                case delegua_2.default.ESCREVA:
+                case delegua_2.default.RETORNA:
                     return;
             }
             this.avancarEDevolverAnterior();
@@ -3410,7 +3415,7 @@ exports.tupla = exports.todosEmCondicao = exports.texto = exports.tamanho = expo
 const excecoes_1 = require("../excecoes");
 const objeto_delegua_classe_1 = require("../estruturas/objeto-delegua-classe");
 const funcao_padrao_1 = require("../estruturas/funcao-padrao");
-const delegua_classe_1 = require("../estruturas/delegua-classe");
+const descritor_tipo_classe_1 = require("../estruturas/descritor-tipo-classe");
 const estruturas_1 = require("../estruturas");
 const construtos_1 = require("../construtos");
 /**
@@ -3815,7 +3820,7 @@ async function tamanho(interpretador, objeto) {
     if (valorObjeto instanceof funcao_padrao_1.FuncaoPadrao) {
         return Promise.resolve(valorObjeto.valorAridade);
     }
-    if (valorObjeto instanceof delegua_classe_1.DeleguaClasse) {
+    if (valorObjeto instanceof descritor_tipo_classe_1.DescritorTipoClasse) {
         const metodos = valorObjeto.metodos;
         let tamanho = 0;
         if (metodos.inicializacao && metodos.inicializacao.eInicializador) {
@@ -3903,7 +3908,7 @@ async function tupla(interpretador, vetor) {
 }
 exports.tupla = tupla;
 
-},{"../construtos":39,"../estruturas":100,"../estruturas/delegua-classe":97,"../estruturas/funcao-padrao":99,"../estruturas/objeto-delegua-classe":103,"../excecoes":106}],16:[function(require,module,exports){
+},{"../construtos":39,"../estruturas":100,"../estruturas/descritor-tipo-classe":98,"../estruturas/funcao-padrao":99,"../estruturas/objeto-delegua-classe":103,"../excecoes":106}],16:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = {
@@ -4171,11 +4176,17 @@ exports.Atribuir = void 0;
  * Construto de atribuição de um valor a um símbolo.
  */
 class Atribuir {
-    constructor(hashArquivo, simbolo, valor) {
+    constructor(hashArquivo, simbolo, valor, 
+    // indice so é usado para variaveis de vetores
+    // TODO: criar alguma validaçao para garantir que indice so seja passado para variaveis de vetores
+    indice) {
         this.linha = Number(simbolo.linha);
         this.hashArquivo = hashArquivo;
         this.simbolo = simbolo;
         this.valor = valor;
+        if (indice !== undefined) {
+            this.indice = indice;
+        }
     }
     async aceitar(visitante) {
         return await visitante.visitarExpressaoDeAtribuicao(this);
@@ -5656,85 +5667,6 @@ exports.ClassePadrao = ClassePadrao;
 },{"./chamavel":95}],97:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeleguaClasse = void 0;
-const excecoes_1 = require("../excecoes");
-const chamavel_1 = require("./chamavel");
-const objeto_delegua_classe_1 = require("./objeto-delegua-classe");
-/**
- * Estrutura de declaração de classe.
- */
-class DeleguaClasse extends chamavel_1.Chamavel {
-    constructor(simboloOriginal, superClasse, metodos, propriedades) {
-        super();
-        this.simboloOriginal = simboloOriginal;
-        this.superClasse = superClasse;
-        this.metodos = metodos || {};
-        this.propriedades = propriedades || [];
-        this.dialetoRequerDeclaracaoPropriedades = false;
-    }
-    encontrarMetodo(nome) {
-        if (this.metodos.hasOwnProperty(nome)) {
-            return this.metodos[nome];
-        }
-        if (this.superClasse !== null && this.superClasse !== undefined) {
-            return this.superClasse.encontrarMetodo(nome);
-        }
-        return undefined;
-    }
-    encontrarPropriedade(nome) {
-        if (nome in this.propriedades) {
-            return this.propriedades[nome];
-        }
-        if (this.superClasse !== null && this.superClasse !== undefined) {
-            return this.superClasse.encontrarPropriedade(nome);
-        }
-        if (this.dialetoRequerDeclaracaoPropriedades) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${this.simboloOriginal.lexema}.`);
-        }
-        return undefined;
-    }
-    /**
-     * Método utilizado por Delégua para representar esta classe quando impressa.
-     * @returns {string} A representação da classe como texto.
-     */
-    paraTexto() {
-        let texto = `<classe ${this.simboloOriginal.lexema}`;
-        for (let propriedade of this.propriedades) {
-            texto += ` ${propriedade.nome}`;
-            if (propriedade.tipo) {
-                texto += `:${propriedade.tipo}`;
-            }
-            texto += ' ';
-        }
-        texto += '>';
-        return texto;
-    }
-    /**
-     * Método utilizado pelo VSCode para inspecionar esta classe em depuração.
-     * @returns {string} A representação da classe como texto.
-     */
-    toString() {
-        return this.paraTexto();
-    }
-    aridade() {
-        const inicializador = this.encontrarMetodo('construtor');
-        return inicializador ? inicializador.aridade() : 0;
-    }
-    async chamar(visitante, argumentos) {
-        const instancia = new objeto_delegua_classe_1.ObjetoDeleguaClasse(this);
-        const inicializador = this.encontrarMetodo('construtor');
-        if (inicializador) {
-            const metodoConstrutor = inicializador.funcaoPorMetodoDeClasse(instancia);
-            await metodoConstrutor.chamar(visitante, argumentos);
-        }
-        return instancia;
-    }
-}
-exports.DeleguaClasse = DeleguaClasse;
-
-},{"../excecoes":106,"./chamavel":95,"./objeto-delegua-classe":103}],98:[function(require,module,exports){
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeleguaFuncao = void 0;
 const chamavel_1 = require("./chamavel");
 const espaco_variaveis_1 = require("../espaco-variaveis");
@@ -5796,7 +5728,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
     }
     resolverParametrosEspalhados(argumentos, indiceArgumentoAtual) {
         const argumentosResolvidos = [];
-        for (let i = indiceArgumentoAtual; i < argumentos.length; indiceArgumentoAtual++) {
+        for (let i = indiceArgumentoAtual; i < argumentos.length; i++) {
             const argumentoAtual = argumentos[i];
             argumentosResolvidos.push(argumentoAtual && argumentoAtual.hasOwnProperty('valor') ? argumentoAtual.valor : argumentoAtual);
         }
@@ -5875,7 +5807,88 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
 }
 exports.DeleguaFuncao = DeleguaFuncao;
 
-},{"../declaracoes":77,"../espaco-variaveis":94,"../interpretador/inferenciador":134,"../quebras":153,"./chamavel":95}],99:[function(require,module,exports){
+},{"../declaracoes":77,"../espaco-variaveis":94,"../interpretador/inferenciador":134,"../quebras":153,"./chamavel":95}],98:[function(require,module,exports){
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescritorTipoClasse = void 0;
+const excecoes_1 = require("../excecoes");
+const chamavel_1 = require("./chamavel");
+const objeto_delegua_classe_1 = require("./objeto-delegua-classe");
+/**
+ * Descritor de tipo de classe. Quando uma declaração de classe é visitada, o que
+ * vai para a pilha de escopos de execução é esta estrutura. Quando uma nova instância
+ * de classe é criada, a referência para a instância é implementada aqui.
+ */
+class DescritorTipoClasse extends chamavel_1.Chamavel {
+    constructor(simboloOriginal, superClasse, metodos, propriedades) {
+        super();
+        this.simboloOriginal = simboloOriginal;
+        this.superClasse = superClasse;
+        this.metodos = metodos || {};
+        this.propriedades = propriedades || [];
+        this.dialetoRequerDeclaracaoPropriedades = false;
+    }
+    encontrarMetodo(nome) {
+        if (this.metodos.hasOwnProperty(nome)) {
+            return this.metodos[nome];
+        }
+        if (this.superClasse !== null && this.superClasse !== undefined) {
+            return this.superClasse.encontrarMetodo(nome);
+        }
+        return undefined;
+    }
+    encontrarPropriedade(nome) {
+        if (nome in this.propriedades) {
+            return this.propriedades[nome];
+        }
+        if (this.superClasse !== null && this.superClasse !== undefined) {
+            return this.superClasse.encontrarPropriedade(nome);
+        }
+        if (this.dialetoRequerDeclaracaoPropriedades) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${this.simboloOriginal.lexema}.`);
+        }
+        return undefined;
+    }
+    /**
+     * Método utilizado por Delégua para representar esta classe quando impressa.
+     * @returns {string} A representação da classe como texto.
+     */
+    paraTexto() {
+        let texto = `<classe ${this.simboloOriginal.lexema}`;
+        for (let propriedade of this.propriedades) {
+            texto += ` ${propriedade.nome.lexema}`;
+            if (propriedade.tipo) {
+                texto += `:${propriedade.tipo}`;
+            }
+            texto += ' ';
+        }
+        texto += '>';
+        return texto;
+    }
+    /**
+     * Método utilizado pelo VSCode para inspecionar esta classe em depuração.
+     * @returns {string} A representação da classe como texto.
+     */
+    toString() {
+        return this.paraTexto();
+    }
+    aridade() {
+        const inicializador = this.encontrarMetodo('construtor');
+        return inicializador ? inicializador.aridade() : 0;
+    }
+    async chamar(visitante, argumentos) {
+        const instancia = new objeto_delegua_classe_1.ObjetoDeleguaClasse(this);
+        const inicializador = this.encontrarMetodo('construtor');
+        if (inicializador) {
+            const metodoConstrutor = inicializador.funcaoPorMetodoDeClasse(instancia);
+            await metodoConstrutor.chamar(visitante, argumentos);
+        }
+        return instancia;
+    }
+}
+exports.DescritorTipoClasse = DescritorTipoClasse;
+
+},{"../excecoes":106,"./chamavel":95,"./objeto-delegua-classe":103}],99:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FuncaoPadrao = void 0;
@@ -5930,7 +5943,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./chamavel"), exports);
 __exportStar(require("./classe-padrao"), exports);
-__exportStar(require("./delegua-classe"), exports);
+__exportStar(require("./descritor-tipo-classe"), exports);
 __exportStar(require("./funcao-padrao"), exports);
 __exportStar(require("./delegua-funcao"), exports);
 __exportStar(require("./metodo-primitiva"), exports);
@@ -5938,7 +5951,7 @@ __exportStar(require("./modulo"), exports);
 __exportStar(require("./objeto-delegua-classe"), exports);
 __exportStar(require("./objeto-padrao"), exports);
 
-},{"./chamavel":95,"./classe-padrao":96,"./delegua-classe":97,"./delegua-funcao":98,"./funcao-padrao":99,"./metodo-primitiva":101,"./modulo":102,"./objeto-delegua-classe":103,"./objeto-padrao":104}],101:[function(require,module,exports){
+},{"./chamavel":95,"./classe-padrao":96,"./delegua-funcao":97,"./descritor-tipo-classe":98,"./funcao-padrao":99,"./metodo-primitiva":101,"./modulo":102,"./objeto-delegua-classe":103,"./objeto-padrao":104}],101:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetodoPrimitiva = void 0;
@@ -6014,7 +6027,7 @@ const excecoes_1 = require("../excecoes");
 /**
  * A instância de uma classe em Delégua.
  * Possui propriedades e métodos. Propriedades são definidas localmente.
- * Métodos são extraídos da definição de classe.
+ * Métodos são extraídos do descritor da classe, uma `DeleguaClasse`.
  */
 class ObjetoDeleguaClasse {
     constructor(classe) {
@@ -7686,7 +7699,7 @@ class InterpretadorBase {
         if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
             return entidadeChamada.declaracao.parametros;
         }
-        if (entidadeChamada instanceof estruturas_1.DeleguaClasse) {
+        if (entidadeChamada instanceof estruturas_1.DescritorTipoClasse) {
             return entidadeChamada.metodos.construtor
                 ? entidadeChamada.metodos.construtor.declaracao.parametros
                 : [];
@@ -7753,7 +7766,7 @@ class InterpretadorBase {
                     });
                 }
             }
-            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido, 
+            // Por algum motivo misterioso, `entidadeChamada instanceof Chamavel` dá `false` em Liquido,
             // mesmo que esteja tudo certo com `DeleguaFuncao`,
             // então precisamos testar o nome do construtor também.
             if (entidadeChamada instanceof estruturas_1.Chamavel || entidadeChamada.constructor.name === 'DeleguaFuncao') {
@@ -7788,7 +7801,11 @@ class InterpretadorBase {
     async visitarExpressaoDeAtribuicao(expressao) {
         const valor = await this.avaliar(expressao.valor);
         const valorResolvido = valor !== undefined && valor.hasOwnProperty('valor') ? valor.valor : valor;
-        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido);
+        let indice = null;
+        if (expressao.indice) {
+            indice = await this.avaliar(expressao.indice);
+        }
+        this.pilhaEscoposExecucao.atribuirVariavel(expressao.simbolo, valorResolvido, indice);
         return valorResolvido;
     }
     procurarVariavel(simbolo) {
@@ -8190,7 +8207,7 @@ class InterpretadorBase {
         else if (objeto.constructor === Object ||
             objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaFuncao ||
-            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DescritorTipoClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
             objeto[indice] = valor;
         }
@@ -8218,14 +8235,17 @@ class InterpretadorBase {
             }
             return objeto[valorIndice];
         }
-        else if (objeto.constructor === Object ||
+        if (objeto instanceof construtos_1.Vetor) {
+            return objeto.valores[valorIndice];
+        }
+        if (objeto.constructor === Object ||
             objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto instanceof estruturas_1.DeleguaFuncao ||
-            objeto instanceof estruturas_1.DeleguaClasse ||
+            objeto instanceof estruturas_1.DescritorTipoClasse ||
             objeto instanceof estruturas_1.DeleguaModulo) {
             return objeto[valorIndice] || null;
         }
-        else if (typeof objeto === primitivos_1.default.TEXTO) {
+        if (typeof objeto === primitivos_1.default.TEXTO) {
             if (!Number.isInteger(valorIndice)) {
                 return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Somente inteiros podem ser usados para indexar um vetor.', expressao.linha));
             }
@@ -8239,9 +8259,7 @@ class InterpretadorBase {
             }
             return objeto.charAt(valorIndice);
         }
-        else {
-            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
-        }
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.entidadeChamada.nome, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
@@ -8264,6 +8282,7 @@ class InterpretadorBase {
     }
     /**
      * Executa uma declaração de classe.
+     * Uma variável do tipo `DeleguaClasse` é adicionada à pilha de escopos de execução.
      * @param declaracao A declaração de classe.
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
@@ -8272,7 +8291,7 @@ class InterpretadorBase {
         if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
             const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
             superClasse = variavelSuperClasse.valor;
-            if (!(superClasse instanceof estruturas_1.DeleguaClasse)) {
+            if (!(superClasse instanceof estruturas_1.DescritorTipoClasse)) {
                 throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
             }
         }
@@ -8289,15 +8308,15 @@ class InterpretadorBase {
             const funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
             metodos[metodoAtual.simbolo.lexema] = funcao;
         }
-        const deleguaClasse = new estruturas_1.DeleguaClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
-        deleguaClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis =
+        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
+        descritorTipoClasse.dialetoRequerExpansaoPropriedadesEspacoVariaveis =
             this.expandirPropriedadesDeObjetosEmEspacoVariaveis;
-        deleguaClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
+        descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
         // TODO: Recolocar isso se for necessário.
         /* if (superClasse !== null) {
             this.ambiente = this.ambiente.enclosing;
         } */
-        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, deleguaClasse);
+        this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
         return null;
     }
     /**
@@ -8307,15 +8326,15 @@ class InterpretadorBase {
      */
     async visitarExpressaoAcessoMetodo(expressao) {
         let variavelObjeto = await this.avaliar(expressao.objeto);
-        // Este caso acontece quando há encadeamento de métodos. 
+        // Este caso acontece quando há encadeamento de métodos.
         // Por exemplo, `objeto1.metodo1().metodo2()`.
-        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o 
+        // Como `RetornoQuebra` também possui `valor`, precisamos extrair o
         // valor dele primeiro.
         if (variavelObjeto.constructor.name === 'RetornoQuebra') {
             variavelObjeto = variavelObjeto.valor;
         }
         const objeto = variavelObjeto.hasOwnProperty('valor') ? variavelObjeto.valor : variavelObjeto;
-        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido, 
+        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido,
         // então testamos também o nome do construtor.
         if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto.constructor.name === 'ObjetoDeleguaClasse') {
             return objeto.obter(expressao.simbolo) || null;
@@ -9294,7 +9313,7 @@ class PilhaEscoposExecucao {
             imutavel: false,
         };
     }
-    atribuirVariavel(simbolo, valor) {
+    atribuirVariavel(simbolo, valor, indice) {
         for (let i = 1; i <= this.pilha.length; i++) {
             const ambiente = this.pilha[this.pilha.length - i].ambiente;
             if (ambiente.valores[simbolo.lexema] !== undefined) {
@@ -9304,11 +9323,21 @@ class PilhaEscoposExecucao {
                 }
                 const tipo = (variavel && variavel.hasOwnProperty('tipo') ? variavel.tipo : (0, inferenciador_1.inferirTipoVariavel)(valor)).toLowerCase();
                 const valorResolvido = this.converterValor(tipo, valor);
-                ambiente.valores[simbolo.lexema] = {
-                    valor: valorResolvido,
-                    tipo,
-                    imutavel: false,
-                };
+                if (indice !== undefined && indice !== null) {
+                    if (variavel.valor instanceof Array) {
+                        variavel.valor[indice] = valorResolvido;
+                    }
+                    else {
+                        throw new excecoes_1.ErroEmTempoDeExecucao(simbolo, "Variável não é um vetor.");
+                    }
+                }
+                else {
+                    ambiente.valores[simbolo.lexema] = {
+                        valor: valorResolvido,
+                        tipo,
+                        imutavel: false,
+                    };
+                }
                 return;
             }
         }
@@ -9385,7 +9414,7 @@ class PilhaEscoposExecucao {
         const ambiente = this.pilha[this.pilha.length - 1].ambiente;
         for (const [nome, corpo] of Object.entries(ambiente.valores)) {
             const corpoValor = corpo.hasOwnProperty('valor') ? corpo.valor : corpo;
-            if (corpoValor instanceof estruturas_1.DeleguaClasse) {
+            if (corpoValor instanceof estruturas_1.DescritorTipoClasse) {
                 retorno[nome] = corpoValor;
             }
         }