@designliquido/delegua 0.39.3 → 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) {