@designliquido/delegua 0.39.2 → 0.39.4

package/umd/delegua.js

@@ -243,7 +243,6 @@ 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 avaliador_sintatico_base_1 = require("./avaliador-sintatico-base");
 const inferenciador_1 = require("../inferenciador");
 const pilha_escopos_1 = require("./pilha-escopos");
@@ -430,18 +429,36 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return new construtos_1.Agrupamento(this.hashArquivo, Number(simboloAtual.linha), expressao);
             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_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_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);
+                if (!this.superclasseAtual) {
+                    throw this.erro(this.simbolos[this.atual], "'Super' usado fora de declaração de classe com herança.");
                 }
+                return new construtos_1.Super(this.hashArquivo, simboloSuper, this.superclasseAtual);
+            /* 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 tiposDeSimbolos.PARENTESE_ESQUERDO:
+                    return new Super(
+                        this.hashArquivo,
+                        simboloSuper,
+                        new Simbolo(
+                            tiposDeSimbolos.IDENTIFICADOR,
+                            'construtor',
+                            null,
+                            simboloSuper.linha,
+                            this.hashArquivo
+                        )
+                    );
+                default:
+                    this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
+                    const metodoSuperclasse = this.consumir(
+                        tiposDeSimbolos.IDENTIFICADOR,
+                        'Esperado nome do método da Superclasse.'
+                    );
+                    // TODO: Validar se o método existe no ancestral.
+                    return new Super(this.hashArquivo, simboloSuper, metodoSuperclasse);
+            } */
             case delegua_2.default.VERDADEIRO:
                 this.avancarEDevolverAnterior();
                 return new construtos_1.Literal(this.hashArquivo, Number(simboloAtual.linha), true, 'lógico');
@@ -549,6 +566,49 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return expressao;
     }
+    /**
+     * `AcessoMetodoOuPropriedade` é um construto intermediário em Delégua, e deve ser resolvido como outro
+     * construto antes de qualquer outra próxima etapa. Algumas validações adicionais também ocorrem aqui.
+     * @param {AcessoMetodoOuPropriedade} entidadeChamadaResolvida O construto original.
+     * @returns {Construto} O construto resolvido como um tipo mais específico.
+     * @see finalizarChamada
+     */
+    resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida) {
+        const construtoTipado = entidadeChamadaResolvida;
+        switch (entidadeChamadaResolvida.tipo) {
+            case delegua_1.default.DICIONARIO:
+            case delegua_1.default.DICIONÁRIO:
+                if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
+                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
+                }
+                const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
+                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
+            case delegua_1.default.INTEIRO:
+            case delegua_1.default.NUMERO:
+            case delegua_1.default.NÚMERO:
+                if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
+                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
+                }
+                const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
+                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
+            case delegua_1.default.TEXTO:
+                if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
+                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
+                }
+                const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
+                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
+            case delegua_1.default.VETOR:
+            case delegua_1.default.VETOR_NUMERO:
+            case delegua_1.default.VETOR_NÚMERO:
+            case delegua_1.default.VETOR_TEXTO:
+                if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
+                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
+                }
+                const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
+                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
+        }
+        return entidadeChamadaResolvida;
+    }
     finalizarChamada(entidadeChamada) {
         const argumentos = [];
         if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
@@ -564,44 +624,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // Toda chamada precisa saber de antemão qual o tipo resolvido.
         let entidadeChamadaResolvida = entidadeChamada;
         if (entidadeChamadaResolvida.constructor.name === 'AcessoMetodoOuPropriedade') {
-            const construtoTipado = entidadeChamadaResolvida;
-            switch (entidadeChamadaResolvida.tipo) {
-                case delegua_1.default.DICIONARIO:
-                case delegua_1.default.DICIONÁRIO:
-                    if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
-                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
-                    }
-                    const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
-                    break;
-                case delegua_1.default.INTEIRO:
-                case delegua_1.default.NUMERO:
-                case delegua_1.default.NÚMERO:
-                    if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
-                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
-                    }
-                    const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
-                    break;
-                case delegua_1.default.TEXTO:
-                    if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
-                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
-                    }
-                    const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
-                    break;
-                case delegua_1.default.VETOR:
-                case delegua_1.default.VETOR_NUMERO:
-                case delegua_1.default.VETOR_NÚMERO:
-                case delegua_1.default.VETOR_TEXTO:
-                    if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
-                        throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
-                    }
-                    const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
-                    entidadeChamadaResolvida = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
-                    break;
-            }
+            entidadeChamadaResolvida = this.resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida);
         }
+        // TODO: Criar forma de validar tipos dos argumentos da entidade chamada.
         return new construtos_1.Chamada(this.hashArquivo, entidadeChamadaResolvida, argumentos);
     }
     unario() {
@@ -727,14 +752,22 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         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) {
-                return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
-            }
-            if (expressao instanceof construtos_1.AcessoMetodoOuPropriedade) {
-                return new construtos_1.DefinirValor(this.hashArquivo, igual.linha, expressao.objeto, expressao.simbolo, valor);
-            }
-            if (expressao instanceof construtos_1.AcessoIndiceVariavel) {
-                return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressao.linha, expressao.entidadeChamada, expressao.indice, valor);
+            switch (expressao.constructor.name) {
+                case 'Variavel':
+                    return new construtos_1.Atribuir(this.hashArquivo, expressao, valor);
+                case 'AcessoMetodoOuPropriedade':
+                    const expressaoAcessoMetodoOuPropriedade = expressao;
+                    return new construtos_1.DefinirValor(this.hashArquivo, igual.linha, expressaoAcessoMetodoOuPropriedade.objeto, expressaoAcessoMetodoOuPropriedade.simbolo, valor);
+                /* case 'Super':
+                    const expressaoSuper = expressao as Super;
+                    return new DefinirValor(
+                        this.hashArquivo,
+                        igual.linha,
+                        expressaoSuper.
+                    ); */
+                case 'AcessoIndiceVariavel':
+                    const expressaoAcessoIndiceVariavel = expressao;
+                    return new construtos_1.AtribuicaoPorIndice(this.hashArquivo, expressaoAcessoIndiceVariavel.linha, expressaoAcessoIndiceVariavel.entidadeChamada, expressaoAcessoIndiceVariavel.indice, valor);
             }
             throw this.erro(igual, 'Tarefa de atribuição inválida');
         }
@@ -1480,6 +1513,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
             const simboloSuperclasse = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            // TODO: Validar classes existentes?
+            this.superclasseAtual = simboloSuperclasse.lexema;
             // TODO: Colocar tipo aqui?
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloSuperclasse.lexema);
         }
@@ -1516,6 +1551,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
+        this.superclasseAtual = undefined;
         return definicaoClasse;
     }
     /**
@@ -1630,7 +1666,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
 }
 exports.AvaliadorSintatico = AvaliadorSintatico;
 
-},{"../bibliotecas/primitivas-dicionario":18,"../bibliotecas/primitivas-numero":19,"../bibliotecas/primitivas-texto":20,"../bibliotecas/primitivas-vetor":21,"../construtos":44,"../construtos/tuplas":53,"../declaracoes":82,"../inferenciador":116,"../lexador":153,"../tipos-de-dados/delegua":161,"../tipos-de-simbolos/delegua":164,"./avaliador-sintatico-base":1,"./erro-avaliador-sintatico":7,"./informacao-escopo":9,"./pilha-escopos":12,"browser-process-hrtime":340}],3:[function(require,module,exports){
+},{"../bibliotecas/primitivas-dicionario":18,"../bibliotecas/primitivas-numero":19,"../bibliotecas/primitivas-texto":20,"../bibliotecas/primitivas-vetor":21,"../construtos":44,"../construtos/tuplas":53,"../declaracoes":82,"../inferenciador":116,"../tipos-de-dados/delegua":161,"../tipos-de-simbolos/delegua":164,"./avaliador-sintatico-base":1,"./erro-avaliador-sintatico":7,"./informacao-escopo":9,"./pilha-escopos":12,"browser-process-hrtime":340}],3:[function(require,module,exports){
 "use strict";
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
@@ -1732,9 +1768,10 @@ class AvaliadorSintaticoEguaClassico {
     primario() {
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.SUPER)) {
             const simboloChave = this.simboloAnterior();
-            this.consumir(egua_classico_1.default.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(egua_classico_1.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
-            return new construtos_1.Super(this.hashArquivo, simboloChave, metodo);
+            return new construtos_1.Super(this.hashArquivo, simboloChave, this.superclasseAtual);
+            /* this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
+            return new Super(this.hashArquivo, simboloChave, metodo); */
         }
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.COLCHETE_ESQUERDO)) {
             const valores = [];
@@ -2232,7 +2269,8 @@ class AvaliadorSintaticoEguaClassico {
         const nome = this.consumir(egua_classico_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(egua_classico_1.default.HERDA)) {
-            this.consumir(egua_classico_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            const simboloSuperclasse = this.consumir(egua_classico_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            this.superclasseAtual = simboloSuperclasse.lexema;
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
         }
         this.consumir(egua_classico_1.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
@@ -2241,6 +2279,7 @@ class AvaliadorSintaticoEguaClassico {
             metodos.push(this.funcao('método'));
         }
         this.consumir(egua_classico_1.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
+        this.superclasseAtual = undefined;
         return new declaracoes_1.Classe(nome, superClasse, metodos);
     }
     resolverDeclaracaoForaDeBloco() {
@@ -2326,7 +2365,6 @@ class AvaliadorSintaticoPitugues {
             this.verificarSeSimboloAtualEIgualA(pitugues_1.default.PONTO_E_VIRGULA);
             return retorno;
         }
-        //this.consumir(tiposDeSimbolos.IGUAL, "Esperado '=' após identificador em instrução 'var'.");
         const inicializadores = [];
         do {
             inicializadores.push(this.expressao());
@@ -2408,9 +2446,9 @@ class AvaliadorSintaticoPitugues {
     primario() {
         if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.SUPER)) {
             const simboloChave = this.simboloAnterior();
-            this.consumir(pitugues_1.default.PONTO, "Esperado '.' após 'super'.");
-            const metodo = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome do método da Superclasse.');
-            return new construtos_1.Super(this.hashArquivo, simboloChave, metodo);
+            /* this.consumir(tiposDeSimbolos.PONTO, "Esperado '.' após 'super'.");
+            const metodo = this.consumir(tiposDeSimbolos.IDENTIFICADOR, 'Esperado nome do método da Superclasse.'); */
+            return new construtos_1.Super(this.hashArquivo, simboloChave, this.superclassseAtual);
         }
         if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.COLCHETE_ESQUERDO)) {
             const valores = [];
@@ -2981,7 +3019,8 @@ class AvaliadorSintaticoPitugues {
         const simbolo = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da classe.');
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(pitugues_1.default.HERDA)) {
-            this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            const simboloSuperclasse = this.consumir(pitugues_1.default.IDENTIFICADOR, 'Esperado nome da Superclasse.');
+            this.superclassseAtual = simboloSuperclasse.lexema;
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simboloAnterior());
         }
         this.consumir(pitugues_1.default.DOIS_PONTOS, "Esperado ':' antes do escopo da classe.");
@@ -2990,6 +3029,7 @@ class AvaliadorSintaticoPitugues {
             this.verificarSeSimboloAtualEIgualA(pitugues_1.default.CONSTRUTOR, pitugues_1.default.FUNCAO, pitugues_1.default.FUNÇÃO)) {
             metodos.push(this.funcao('método', this.simbolos[this.atual - 1].tipo === pitugues_1.default.CONSTRUTOR));
         }
+        this.superclassseAtual = undefined;
         return new declaracoes_1.Classe(simbolo, superClasse, metodos);
     }
     declaracaoFalhar() {
@@ -5013,11 +5053,11 @@ exports.QualTipo = QualTipo;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Super = void 0;
 class Super {
-    constructor(hashArquivo, simboloChave, metodo) {
+    constructor(hashArquivo, simboloChave, superclasse) {
         this.linha = Number(simboloChave.linha);
         this.hashArquivo = hashArquivo;
         this.simboloChave = simboloChave;
-        this.metodo = metodo;
+        this.superclasse = superclasse;
     }
     async aceitar(visitante) {
         return Promise.resolve(visitante.visitarExpressaoSuper(this));
@@ -6210,7 +6250,7 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
         }
         return argumentosResolvidos;
     }
-    async chamar(visitante, argumentos) {
+    resolverAmbiente(argumentos) {
         const ambiente = new espaco_variaveis_1.EspacoVariaveis();
         const parametros = this.declaracao.parametros || [];
         for (let i = 0; i < parametros.length; i++) {
@@ -6229,6 +6269,10 @@ class DeleguaFuncao extends chamavel_1.Chamavel {
                 ambiente.valores[nome] = argumento && argumento.hasOwnProperty('valor') ? argumento.valor : argumento;
             }
         }
+        return ambiente;
+    }
+    async chamar(visitante, argumentos) {
+        const ambiente = this.resolverAmbiente(argumentos);
         if (this.instancia !== undefined) {
             ambiente.valores['isto'] = {
                 valor: this.instancia,
@@ -6329,7 +6373,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
      * @returns {string} A representação da classe como texto.
      */
     paraTexto() {
-        let texto = `<classe ${this.simboloOriginal.lexema}`;
+        let texto = `<DescritorTipoClasse ${this.simboloOriginal.lexema}`;
         for (let propriedade of this.propriedades) {
             texto += ` ${propriedade.nome.lexema}`;
             if (propriedade.tipo) {
@@ -7128,9 +7172,7 @@ class FormatadorDelegua {
         this.codigoFormatado += `${this.quebraLinha}`;
     }
     visitarExpressaoSuper(expressao) {
-        // TODO: `expressao.metodo` deveria ser um `Construto`, não um `Simbolo` aqui.
-        this.codigoFormatado += `super.${expressao.metodo.lexema}()`;
-        console.log(expressao);
+        this.codigoFormatado += `super`;
     }
     visitarExpressaoSustar(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}sustar${this.quebraLinha}`;
@@ -8239,20 +8281,6 @@ class InterpretadorBase {
         }
         return argumentos;
     }
-    /**
-     * Resolve paraâmetros da chamada de acordo com o tipo da entidade chamada.
-     * @param {Chamavel} entidadeChamada A entidade chamada.
-     * @returns Os parâmetros resolvidos.
-     */
-    resolverParametrosChamada(entidadeChamada) {
-        if (entidadeChamada instanceof estruturas_1.DeleguaFuncao) {
-            return entidadeChamada.declaracao.parametros;
-        }
-        if (entidadeChamada instanceof estruturas_1.DescritorTipoClasse) {
-            return entidadeChamada.metodos.construtor ? entidadeChamada.metodos.construtor.declaracao.parametros : [];
-        }
-        return [];
-    }
     /**
      * Executa uma chamada de função, método ou classe.
      * @param expressao A expressão chamada.
@@ -8274,10 +8302,6 @@ class InterpretadorBase {
                 return await this.chamarMetodoPrimitiva(expressao, entidadeChamada);
             }
             const argumentos = await this.resolverArgumentosChamada(expressao);
-            // TODO: Aparentemente isso nunca é usado se o bloco de resolução de parâmetros,
-            // mais abaixo, também não é.
-            // Estudar remoção mais adiante.
-            const parametros = this.resolverParametrosChamada(entidadeChamada);
             const aridade = entidadeChamada.aridade ? entidadeChamada.aridade() : entidadeChamada.length;
             // Completar os parâmetros não preenchidos com nulos.
             if (argumentos.length < aridade) {
@@ -8285,22 +8309,7 @@ class InterpretadorBase {
                 for (let i = 0; i < diferenca; i++) {
                     argumentos.push(null);
                 }
-            } /* else {
-                // TODO: Aparentemente isso aqui nunca funcionou.
-                // Avaliar de simplesmente apagar este código, e usar o que foi
-                // implementado em `DeleguaFuncao.chamar`.
-                if (
-                    parametros &&
-                    parametros.length > 0 &&
-                    parametros[parametros.length - 1].abrangencia === 'multiplo'
-                ) {
-                    let novosArgumentos = argumentos.slice(0, parametros.length - 1);
-                    novosArgumentos = novosArgumentos.concat(
-                        argumentos.slice(parametros.length - 1, argumentos.length)
-                    );
-                    argumentos = novosArgumentos;
-                }
-            } */
+            }
             if (entidadeChamada instanceof estruturas_1.FuncaoPadrao) {
                 try {
                     return entidadeChamada.chamar(this, argumentos.map((a) => a && a.valor && a.valor.hasOwnProperty('valor') ? a.valor.valor : a === null || a === void 0 ? void 0 : a.valor), expressao.entidadeChamada.simbolo);
@@ -8320,6 +8329,14 @@ class InterpretadorBase {
                 const retornoEntidadeChamada = await entidadeChamada.chamar(this, argumentos);
                 return retornoEntidadeChamada;
             }
+            // Chamadas a `super()`.
+            // Basicamente, chamar o construtor da superclasse.
+            if (expressao.entidadeChamada instanceof construtos_1.Super) {
+                const descritorSuperclasse = variavelEntidadeChamada.classe.superClasse;
+                const metodoConstrutor = descritorSuperclasse.encontrarMetodo('construtor');
+                await metodoConstrutor.chamar(this, argumentos);
+                return null;
+            }
             // A função chamada pode ser de uma biblioteca JavaScript.
             // Neste caso apenas testamos se o tipo é uma função.
             // TODO: Descobrir qual caso exatamente passa aqui.
@@ -8999,14 +9016,8 @@ class InterpretadorBase {
         return valores;
     }
     visitarExpressaoSuper(expressao) {
-        const superClasse = this.pilhaEscoposExecucao.obterVariavelPorNome('super');
         const objeto = this.pilhaEscoposExecucao.obterVariavelPorNome('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);
-        }
-        metodo.instancia = objeto.valor;
-        return metodo;
+        return objeto.valor;
     }
     /**
      * Executa expressão de definição de variável.
@@ -25718,7 +25729,7 @@ class TradutorAssemblyScript {
         else if (tipoDe.valor instanceof construtos_1.Vetor)
             resultado += this.traduzirConstrutoVetor(tipoDe.valor);
         else
-            resultado += tipoDe.valor;
+            resultado += this.dicionarioConstrutos[tipoDe.valor.constructor.name](tipoDe.valor);
         return resultado;
     }
     traduzirConstrutoLogico(logico) {
@@ -25952,40 +25963,46 @@ class TradutorJavaScript {
                 return '-';
         }
     }
-    traduzirFuncoesNativas(metodo) {
-        switch (metodo.toLowerCase()) {
+    traduzirFuncaoOuMetodo(nomeMetodo, objetoResolvido, argumentos) {
+        const argumentosResolvidos = [];
+        for (const argumento of argumentos) {
+            const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+            argumentosResolvidos.push(argumentoResolvido);
+        }
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        textoArgumentos = textoArgumentos.slice(0, -2);
+        switch (nomeMetodo) {
             case 'adicionar':
             case 'empilhar':
-                return 'push';
-            case 'concatenar':
-                return 'concat';
+                return `${objetoResolvido}.push(${textoArgumentos})`;
             case 'fatiar':
-                return 'slice';
+                return `${objetoResolvido}.slice(${argumentos[0]}, ${argumentos[1]})`;
             case 'inclui':
-                return 'includes';
+                return `${objetoResolvido}.includes(${argumentosResolvidos[0]})`;
             case 'inverter':
-                return 'reverse';
+                return `${objetoResolvido}.toReversed()`;
             case 'juntar':
-                return 'join';
-            case 'ordenar':
-                return 'sort';
-            case 'removerprimeiro':
-                return 'shift';
-            case 'removerultimo':
-                return 'pop';
-            case 'tamanho':
-                return 'length';
+                return `${argumentosResolvidos[0]}.join(${objetoResolvido})`;
             case 'maiusculo':
-                return 'toUpperCase';
+                return `${objetoResolvido}.toUpperCase()`;
+            case 'mapear':
+                return `${objetoResolvido}.map(${this.traduzirFuncaoAnonimaParaLambda(argumentos[0])})`;
             case 'minusculo':
-                return 'toLowerCase';
-            case 'substituir':
-                return 'replace';
-            case 'texto':
-                return 'String';
-            default:
-                return metodo;
+                return `${objetoResolvido}.toLowerCase()`;
+            case 'ordenar':
+                return `${objetoResolvido}.sort()`;
+            case 'remover':
+                return `delete ${objetoResolvido}[${argumentosResolvidos[0]}]`;
+            case 'removerPrimeiro':
+                return `${objetoResolvido}.shift()`;
+            case 'removerUltimo':
+                return `${objetoResolvido}.pop()`;
+            case 'somar':
+                return `${objetoResolvido}.reduce((acumulador, valorAtual) => acumulador + valorAtual, 0)`;
+            case 'tamanho':
+                return `${objetoResolvido}.length`;
         }
+        return `${objetoResolvido}.${nomeMetodo}(${textoArgumentos}))`;
     }
     traduzirConstrutoAgrupamento(agrupamento) {
         return this.dicionarioConstrutos[agrupamento.constructor.name](agrupamento.expressao || agrupamento);
@@ -26022,28 +26039,8 @@ class TradutorJavaScript {
     }
     traduzirConstrutoChamada(chamada) {
         let resultado = '';
-        const retorno = `${this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada)}`;
-        const instanciaClasse = this.declaracoesDeClasses.some((declaracao) => { var _a; return ((_a = declaracao === null || declaracao === void 0 ? void 0 : declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === retorno; });
-        if (instanciaClasse) {
-            const classe = this.declaracoesDeClasses.find((declaracao) => { var _a; return ((_a = declaracao === null || declaracao === void 0 ? void 0 : declaracao.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === retorno; });
-            if (classe.simbolo.lexema === retorno)
-                resultado += `new ${retorno}`;
-        }
-        else {
-            resultado += retorno;
-        }
-        if (!retorno.endsWith('length')) {
-            resultado += '(';
-        }
-        for (let parametro of chamada.argumentos) {
-            resultado += this.dicionarioConstrutos[parametro.constructor.name](parametro) + ', ';
-        }
-        if (chamada.argumentos.length > 0) {
-            resultado = resultado.slice(0, -2);
-        }
-        if (!retorno.endsWith('length')) {
-            resultado += ')';
-        }
+        const retorno = `${this.dicionarioConstrutos[chamada.entidadeChamada.constructor.name](chamada.entidadeChamada, chamada.argumentos)}`;
+        resultado += retorno;
         return resultado;
     }
     traduzirConstrutoComentario(comentario) {
@@ -26093,8 +26090,28 @@ class TradutorJavaScript {
         }
         return literal.valor;
     }
-    traduzirConstrutoVariavel(variavel) {
-        return this.traduzirFuncoesNativas(variavel.simbolo.lexema);
+    traduzirConstrutoVariavel(variavel, argumentos) {
+        const argumentosResolvidos = [];
+        const argumentosValidados = argumentos || [];
+        for (const argumento of argumentosValidados) {
+            const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+            argumentosResolvidos.push(argumentoResolvido);
+        }
+        let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+        textoArgumentos = textoArgumentos.slice(0, -2);
+        switch (variavel.simbolo.lexema) {
+            case 'texto':
+                return `String(${textoArgumentos})`;
+            default:
+                const buscaClasseCorrespondente = this.declaracoesDeClasses.filter(d => d.simbolo.lexema === variavel.simbolo.lexema);
+                if (buscaClasseCorrespondente.length === 0 && argumentosValidados.length === 0) {
+                    return `${variavel.simbolo.lexema}`;
+                }
+                if (buscaClasseCorrespondente.length > 0) {
+                    return `new ${variavel.simbolo.lexema}(${textoArgumentos})`;
+                }
+                return `${variavel.simbolo.lexema}(${textoArgumentos})`;
+        }
     }
     logicaComumBlocoEscopo(declaracoes) {
         let resultado = '{\n';
@@ -26361,28 +26378,72 @@ class TradutorJavaScript {
         }
         return resultado;
     }
-    traduzirConstrutoAcessoMetodo(acessoMetodo) {
-        if (acessoMetodo.objeto instanceof construtos_1.Variavel) {
-            let objetoVariavel = acessoMetodo.objeto;
-            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(acessoMetodo.nomeMetodo)}`;
+    // TODO: Talvez terminar (ou remover, sei lá).
+    traduzirFuncaoAnonimaParaLambda(argumento) {
+        return "";
+    }
+    traduzirAcessoMetodoVetor(objeto, nomeMetodo, argumentos) {
+        const objetoResolvido = this.dicionarioConstrutos[objeto.constructor.name](objeto);
+        const argumentosResolvidos = [];
+        for (const argumento of argumentos) {
+            const argumentoResolvido = this.dicionarioConstrutos[argumento.constructor.name](argumento);
+            argumentosResolvidos.push(argumentoResolvido);
+        }
+        switch (nomeMetodo) {
+            case 'adicionar':
+            case 'empilhar':
+                let textoArgumentos = argumentosResolvidos.reduce((atual, proximo) => atual += proximo + ', ', "");
+                textoArgumentos = textoArgumentos.slice(0, -2);
+                return `${objetoResolvido}.push(${textoArgumentos})`;
+            case 'fatiar':
+                return `${objetoResolvido}[${argumentos[0]}:${argumentos[1]}]`;
+            case 'inclui':
+                return `${argumentos[0]} in ${objetoResolvido}`;
+            case 'inverter':
+                return `reversed(${objetoResolvido})`;
+            case 'juntar':
+                return `${argumentos[0]}.join(${objetoResolvido})`;
+            case 'mapear':
+                return `list(map(${this.traduzirFuncaoAnonimaParaLambda(argumentos[0])}), ${objetoResolvido})`;
+            case 'ordenar':
+                return `${objetoResolvido}.sort()`;
+            case 'remover':
+                return `del ${objetoResolvido}[${argumentos[0]}]`;
+            case 'removerPrimeiro':
+                return `del ${objetoResolvido}[0]`;
+            case 'removerUltimo':
+                return `del ${objetoResolvido}[-1]`;
+            case 'somar':
+                return `sum(${objetoResolvido})`;
+            case 'tamanho':
+                return `len(${objetoResolvido})`;
         }
-        if (acessoMetodo.objeto instanceof construtos_1.Isto) {
-            return `this.${acessoMetodo.nomeMetodo}`;
+    }
+    traduzirConstrutoAcessoMetodo(acessoMetodo, argumentos) {
+        switch (acessoMetodo.objeto.constructor.name) {
+            case 'Isto':
+                return `this.${acessoMetodo.nomeMetodo}`;
+            case 'Variavel':
+                let objetoVariavel = acessoMetodo.objeto;
+                return this.traduzirFuncaoOuMetodo(acessoMetodo.nomeMetodo, objetoVariavel.simbolo.lexema, argumentos);
+            case 'Vetor':
+                return this.traduzirAcessoMetodoVetor(acessoMetodo.objeto, acessoMetodo.nomeMetodo, argumentos);
+            default:
+                const objetoResolvido = this.dicionarioConstrutos[acessoMetodo.objeto.constructor.name](acessoMetodo.objeto);
+                return `${objetoResolvido}.${acessoMetodo.nomeMetodo}`;
         }
-        const objetoResolvido = this.dicionarioConstrutos[acessoMetodo.objeto.constructor.name](acessoMetodo.objeto);
-        return `${objetoResolvido}.${acessoMetodo.nomeMetodo}`;
     }
-    traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodo) {
+    traduzirConstrutoAcessoMetodoOuPropriedade(acessoMetodo, argumentos) {
         if (acessoMetodo.objeto instanceof construtos_1.Variavel) {
             let objetoVariavel = acessoMetodo.objeto;
-            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(acessoMetodo.simbolo.lexema)}`;
+            return `${this.traduzirFuncaoOuMetodo(acessoMetodo.simbolo.lexema, objetoVariavel.simbolo.lexema, argumentos)}`;
         }
         return `this.${acessoMetodo.simbolo.lexema}`;
     }
-    traduzirConstrutoAcessoPropriedade(acessoMetodo) {
+    traduzirConstrutoAcessoPropriedade(acessoMetodo, argumentos) {
         if (acessoMetodo.objeto instanceof construtos_1.Variavel) {
             let objetoVariavel = acessoMetodo.objeto;
-            return `${objetoVariavel.simbolo.lexema}.${this.traduzirFuncoesNativas(acessoMetodo.nomePropriedade)}`;
+            return `${this.traduzirFuncaoOuMetodo(objetoVariavel.simbolo.lexema, acessoMetodo.nomePropriedade, argumentos)}`;
         }
         return `this.${acessoMetodo.nomePropriedade}`;
     }
@@ -26443,13 +26504,20 @@ class TradutorJavaScript {
     traduzirConstrutoTipoDe(tipoDe) {
         let resultado = 'typeof ';
         if (!tipoDe.valor)
-            resultado += tipoDe.valor;
+            resultado += tipoDe.valor; // Qual o sentido disso?
         else if (typeof tipoDe.valor === 'string')
             resultado += `'${tipoDe.valor}'`;
         else if (typeof tipoDe.valor === 'number')
             resultado += tipoDe.valor;
-        else
-            resultado += `${this.dicionarioConstrutos[tipoDe.valor.constructor.name](tipoDe.valor)}`;
+        else {
+            // Talvez isso seja uma péssima ideia.
+            // Pensar em algo melhor.
+            let alvoTipoDe = String(this.dicionarioConstrutos[tipoDe.valor.constructor.name](tipoDe.valor));
+            if (alvoTipoDe.startsWith('new')) {
+                alvoTipoDe = alvoTipoDe.slice(4, -2);
+            }
+            resultado += `${alvoTipoDe}`;
+        }
         return resultado;
     }
     traduzirDeclaracaoFalhar(falhar) {
@@ -26703,6 +26771,7 @@ class TradutorPython {
         const indice = this.dicionarioConstrutos[acessoIndiceVariavel.indice.constructor.name](acessoIndiceVariavel.indice);
         return `${entidade}[${indice}]`;
     }
+    // TODO: Talvez terminar (ou remover, sei lá).
     traduzirFuncaoAnonimaParaLambda(argumento) {
         return "";
     }
@@ -26895,7 +26964,6 @@ class TradutorPython {
                     return `${variavel.simbolo.lexema}`;
                 }
                 return `${variavel.simbolo.lexema}(${textoArgumentos})`;
-            // return this.traduzirFuncoesNativas(variavel.simbolo.lexema);
         }
     }
     traduzirConstrutoVetor(vetor) {