@designliquido/delegua 1.10.0 → 1.11.1

package/interpretador/interpretador-base.js

@@ -172,7 +172,7 @@ class InterpretadorBase {
         }
         // Se é array, resolve recursivamente todos os elementos
         if (Array.isArray(objeto)) {
-            return objeto.map(elemento => this.resolverValorRecursivo(elemento));
+            return objeto.map((elemento) => this.resolverValorRecursivo(elemento));
         }
         // Se é objeto plano, resolve recursivamente todas as propriedades
         if (objeto && objeto.constructor && objeto.constructor === Object) {
@@ -215,8 +215,18 @@ class InterpretadorBase {
     async visitarExpressaoTupla(expressao) {
         // Lista de propriedades válidas para tuplas (ignorar propriedades de controle)
         const propriedadesValidas = [
-            'primeiro', 'segundo', 'terceiro', 'quarto', 'quinto',
-            'sexto', 'sétimo', 'setimo', 'oitavo', 'nono', 'décimo', 'decimo'
+            'primeiro',
+            'segundo',
+            'terceiro',
+            'quarto',
+            'quinto',
+            'sexto',
+            'sétimo',
+            'setimo',
+            'oitavo',
+            'nono',
+            'décimo',
+            'decimo',
         ];
         const valores = [];
         for (let propriedade of propriedadesValidas) {
@@ -233,7 +243,7 @@ class InterpretadorBase {
             const res = await this.avaliar(expressao.elementos[i]);
             elementos.push(this.resolverValor(res));
         }
-        const elementosComoConstrutos = elementos.map(valor => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
+        const elementosComoConstrutos = elementos.map((valor) => new construtos_1.Literal(expressao.hashArquivo, expressao.linha, valor));
         return new construtos_1.TuplaN(expressao.hashArquivo, expressao.linha, elementosComoConstrutos);
     }
     async visitarExpressaoAtribuicaoPorIndicesMatriz(expressao) {
@@ -575,8 +585,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq ** dir;
                 }
                 const resultadoExponenciacao = Math.pow(valorEsquerdo, valorDireito);
@@ -604,8 +618,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq - dir;
                 }
                 return Number(valorEsquerdo) - Number(valorDireito);
@@ -617,8 +635,12 @@ class InterpretadorBase {
                 }
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq + dir;
                 }
                 if (this.tiposNumericos.includes(tipoEsquerdo) &&
@@ -648,8 +670,12 @@ class InterpretadorBase {
                 }
                 // Retorna BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq / dir; // Trunca automaticamente
                 }
                 return Math.floor(Number(valorEsquerdo) / Number(valorDireito));
@@ -659,8 +685,12 @@ class InterpretadorBase {
                 if ((typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') &&
                     tipoEsquerdo !== delegua_2.default.TEXTO &&
                     tipoDireito !== delegua_2.default.TEXTO) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq * dir;
                 }
                 if (tipoEsquerdo === delegua_2.default.TEXTO ||
@@ -693,7 +723,8 @@ class InterpretadorBase {
             case delegua_1.default.MODULO:
             case delegua_1.default.MODULO_IGUAL:
                 // Se o operando esquerdo é uma string, usar formatação de string
-                if (tipoEsquerdo === delegua_2.default.TEXTO || typeof valorEsquerdo === 'string') {
+                if (tipoEsquerdo === delegua_2.default.TEXTO ||
+                    typeof valorEsquerdo === 'string') {
                     return this.formatarStringComOperadorPorcentagem(String(valorEsquerdo), direita, // Passar 'direita' ao invés de 'valorDireito' para preservar arrays de tuplas
                     expressao.operador);
                 }
@@ -707,8 +738,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq & dir;
                 }
                 return Number(valorEsquerdo) & Number(valorDireito);
@@ -719,8 +754,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq ^ dir;
                 }
                 return Number(valorEsquerdo) ^ Number(valorDireito);
@@ -731,8 +770,12 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt se qualquer operando for BigInt
                 if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq | dir;
                 }
                 return Number(valorEsquerdo) | Number(valorDireito);
@@ -740,9 +783,15 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
                 const tamanhoDeslocamentoEsquerda = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || tamanhoDeslocamentoEsquerda >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    tamanhoDeslocamentoEsquerda >= 32) {
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq << dir;
                 }
                 return Number(valorEsquerdo) << Number(valorDireito);
@@ -750,9 +799,15 @@ class InterpretadorBase {
                 this.verificarOperandosNumeros(expressao.operador, esquerda, direita);
                 // Auto-promove para BigInt (interno para longo) se qualquer operando for BigInt ou se deslocamento >= 32
                 const tamanhoDeslocamentoDireita = Number(valorDireito);
-                if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint' || tamanhoDeslocamentoDireita >= 32) {
-                    const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                    const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
+                if (typeof valorEsquerdo === 'bigint' ||
+                    typeof valorDireito === 'bigint' ||
+                    tamanhoDeslocamentoDireita >= 32) {
+                    const esq = typeof valorEsquerdo === 'bigint'
+                        ? valorEsquerdo
+                        : BigInt(Math.floor(Number(valorEsquerdo)));
+                    const dir = typeof valorDireito === 'bigint'
+                        ? valorDireito
+                        : BigInt(Math.floor(Number(valorDireito)));
                     return esq >> dir;
                 }
                 return Number(valorEsquerdo) >> Number(valorDireito);
@@ -873,7 +928,8 @@ class InterpretadorBase {
             // Casos que passam aqui: chamadas a métodos de bibliotecas de Delégua.
             if (typeof entidadeChamada === primitivos_1.default.FUNCAO) {
                 let objeto = null;
-                if (expressao.entidadeChamada.objeto) { // TODO: Qual o tipo certo aqui?
+                if (expressao.entidadeChamada.objeto) {
+                    // TODO: Qual o tipo certo aqui?
                     objeto = await this.avaliar(expressao.entidadeChamada.objeto);
                 }
                 return entidadeChamada.apply(this.resolverValor(objeto), argumentos);
@@ -932,7 +988,8 @@ class InterpretadorBase {
     }
     logicaContemOuEm(esquerda, direita, expressao) {
         const valorDireitoResolvido = this.resolverValor(direita);
-        if (Array.isArray(valorDireitoResolvido) || typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
+        if (Array.isArray(valorDireitoResolvido) ||
+            typeof valorDireitoResolvido === primitivos_1.default.TEXTO) {
             const avaliacao = valorDireitoResolvido.includes(esquerda);
             return expressao.negado ? !avaliacao : avaliacao;
         }
@@ -964,13 +1021,19 @@ class InterpretadorBase {
                 const valorDireito = this.resolverValor(direita);
                 if (typeof valorDireito === 'number' || typeof valorDireito === 'bigint') {
                     if (typeof valorEsquerdo === 'bigint' || typeof valorDireito === 'bigint') {
-                        const esq = typeof valorEsquerdo === 'bigint' ? valorEsquerdo : BigInt(Math.floor(Number(valorEsquerdo)));
-                        const dir = typeof valorDireito === 'bigint' ? valorDireito : BigInt(Math.floor(Number(valorDireito)));
-                        return expressao.operador.tipo === delegua_1.default.E ? (esq & dir) : (esq | dir);
+                        const esq = typeof valorEsquerdo === 'bigint'
+                            ? valorEsquerdo
+                            : BigInt(Math.floor(Number(valorEsquerdo)));
+                        const dir = typeof valorDireito === 'bigint'
+                            ? valorDireito
+                            : BigInt(Math.floor(Number(valorDireito)));
+                        return expressao.operador.tipo === delegua_1.default.E
+                            ? esq & dir
+                            : esq | dir;
                     }
                     return expressao.operador.tipo === delegua_1.default.E
-                        ? (Number(valorEsquerdo) & Number(valorDireito))
-                        : (Number(valorEsquerdo) | Number(valorDireito));
+                        ? Number(valorEsquerdo) & Number(valorDireito)
+                        : Number(valorEsquerdo) | Number(valorDireito);
                 }
                 // Demais casos sem diferença de tipos
                 if (expressao.operador.tipo === delegua_1.default.OU) {
@@ -1064,7 +1127,7 @@ class InterpretadorBase {
                     const valorComoDupla = valorVetorResolvido[declaracao.posicaoAtual];
                     const promises = await Promise.all([
                         this.avaliar(declaracao.variavelIteracao.primeiro),
-                        this.avaliar(declaracao.variavelIteracao.segundo)
+                        this.avaliar(declaracao.variavelIteracao.segundo),
                     ]);
                     // TODO: O que fazer quando não forem literais?
                     this.pilhaEscoposExecucao.definirVariavel(String(promises[0].valor), valorComoDupla.primeiro);
@@ -1244,7 +1307,9 @@ class InterpretadorBase {
         let formatoTexto = '';
         for (const argumento of argumentos) {
             let resultadoAvaliacao = await this.avaliar(argumento);
-            if (resultadoAvaliacao && resultadoAvaliacao.hasOwnProperty && resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
+            if (resultadoAvaliacao &&
+                resultadoAvaliacao.hasOwnProperty &&
+                resultadoAvaliacao.hasOwnProperty('valorRetornado')) {
                 resultadoAvaliacao = resultadoAvaliacao.valorRetornado;
             }
             let valor = this.resolverValor(resultadoAvaliacao);
@@ -1485,12 +1550,12 @@ class InterpretadorBase {
         }, 'Somente listas, dicionários, classes e objetos podem ter seus valores indexados.', expressao.linha));
     }
     /**
-        * Método base para acesso a intervalo.
-        * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
-        * ainda não suporta isso nativamente, apenas Pituguês.
-    */
+     * Método base para acesso a intervalo.
+     * Por padrão lança erro, pois a maioria dos dialetos (como Delégua padrão)
+     * ainda não suporta isso nativamente, apenas Pituguês.
+     */
     visitarExpressaoAcessoIntervaloVariavel(expressao) {
-        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, "Acesso por intervalo não implementado para este dialeto.", expressao.linha));
+        return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(expressao.simboloFechamento, 'Acesso por intervalo não implementado para este dialeto.', expressao.linha));
     }
     async visitarExpressaoDefinirValor(expressao) {
         const variavelObjeto = await this.avaliar(expressao.objeto);
@@ -1523,18 +1588,30 @@ class InterpretadorBase {
      * @returns Sempre retorna nulo, por ser requerido pelo contrato de visita.
      */
     async visitarDeclaracaoClasse(declaracao) {
-        let superClasse = null;
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            const variavelSuperClasse = await this.avaliar(declaracao.superClasse);
-            superClasse = variavelSuperClasse.valor;
+        // Resolver cada superclasse listada em `herda A, B, ...`
+        const superClassesResolvidas = [];
+        for (const superClasseVariavel of declaracao.superClasses) {
+            const variavelSuperClasse = await this.avaliar(superClasseVariavel);
+            const superClasse = variavelSuperClasse.valor;
             if (!(superClasse instanceof estruturas_1.DescritorTipoClasse)) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(declaracao.superClasse.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
+                throw new excecoes_1.ErroEmTempoDeExecucao(superClasseVariavel.nome, 'Superclasse precisa ser uma classe.', declaracao.linha);
             }
+            superClassesResolvidas.push(superClasse);
+        }
+        // Resolver cada misturável listado em `mescla X, Y, ...`
+        const mesclaResolvidas = [];
+        for (const mesclaVariavel of declaracao.mesclas) {
+            const variavelMisturavel = await this.avaliar(mesclaVariavel);
+            const misturável = variavelMisturavel.valor;
+            if (!(misturável instanceof estruturas_1.DescritorTipoClasse)) {
+                throw new excecoes_1.ErroEmTempoDeExecucao(mesclaVariavel.nome, 'Misturável precisa ser uma classe.', declaracao.linha);
+            }
+            mesclaResolvidas.push(misturável);
         }
         // TODO: Precisamos disso?
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, declaracao);
-        if (declaracao.superClasse !== null && declaracao.superClasse !== undefined) {
-            this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
+        if (superClassesResolvidas.length > 0) {
+            this.pilhaEscoposExecucao.definirVariavel('super', superClassesResolvidas[0]);
         }
         const metodos = {};
         const metodosEstaticos = {};
@@ -1562,9 +1639,7 @@ class InterpretadorBase {
             const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoAtual.funcao, undefined, eInicializador);
             funcao.documentacao = metodoAtual.documentacao;
             // Numa classe estática, todos os métodos (exceto construtor) são estáticos.
-            const ehEstatico = declaracao.classeEstatica
-                ? !eInicializador
-                : metodoAtual.estatico;
+            const ehEstatico = declaracao.classeEstatica ? !eInicializador : metodoAtual.estatico;
             if (metodoAtual.eObtenedor) {
                 if (ehEstatico) {
                     obtenedoresEstaticos[nomeMetodo] = funcao;
@@ -1605,7 +1680,7 @@ class InterpretadorBase {
                 acessoPropriedades[prop.nome.lexema] = prop.acesso;
             }
         }
-        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
+        const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClassesResolvidas, metodos, declaracao.propriedades);
         descritorTipoClasse.metodosEstaticos = metodosEstaticos;
         descritorTipoClasse.membrosEstaticos = membrosEstaticos;
         descritorTipoClasse.obtenedores = obtenedores;
@@ -1620,13 +1695,45 @@ class InterpretadorBase {
         // Toda classe sem superclasse explícita herda implicitamente de `Objeto`.
         // Isso só deve acontecer quando OBJETO_BASE já estiver inicializado e a classe
         // atual não for o próprio OBJETO_BASE, para evitar cadeias de herança recursivas.
-        if (!descritorTipoClasse.superClasse && estruturas_1.OBJETO_BASE && descritorTipoClasse !== estruturas_1.OBJETO_BASE) {
-            descritorTipoClasse.superClasse = estruturas_1.OBJETO_BASE;
+        if (descritorTipoClasse.superClasses.length === 0 &&
+            estruturas_1.OBJETO_BASE &&
+            descritorTipoClasse !== estruturas_1.OBJETO_BASE) {
+            descritorTipoClasse.superClasses = [estruturas_1.OBJETO_BASE];
+        }
+        // Calcular o OReM (linearização C3) após os pais estarem definidos.
+        descritorTipoClasse.orem = estruturas_1.DescritorTipoClasse.computarOReM(descritorTipoClasse);
+        // Mesclar métodos e propriedades dos misturávels (primeiro misturável ganha se não definido na classe).
+        for (const misturável of mesclaResolvidas) {
+            for (const [nome, funcao] of Object.entries(misturável.metodos)) {
+                if (!descritorTipoClasse.metodos.hasOwnProperty(nome)) {
+                    descritorTipoClasse.metodos[nome] = funcao;
+                }
+            }
+            for (const [nome, funcao] of Object.entries(misturável.obtenedores)) {
+                if (!descritorTipoClasse.obtenedores.hasOwnProperty(nome)) {
+                    descritorTipoClasse.obtenedores[nome] = funcao;
+                }
+            }
+            for (const [nome, funcao] of Object.entries(misturável.definidores)) {
+                if (!descritorTipoClasse.definidores.hasOwnProperty(nome)) {
+                    descritorTipoClasse.definidores[nome] = funcao;
+                }
+            }
+            for (const prop of misturável.propriedades) {
+                const jaDeclarada = descritorTipoClasse.propriedades.some((p) => p.nome.lexema === prop.nome.lexema);
+                if (!jaDeclarada) {
+                    descritorTipoClasse.propriedades.push(prop);
+                }
+            }
         }
         // Verifica se a subclasse concreta implementa todos os métodos abstratos
-        // da superclasse abstrata.
-        if (!declaracao.abstrata && superClasse && superClasse.abstrata) {
-            superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
+        // da(s) superclasse(s) abstrata(s).
+        if (!declaracao.abstrata) {
+            for (const superClasse of superClassesResolvidas) {
+                if (superClasse.abstrata) {
+                    superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
+                }
+            }
         }
         // TODO: Até então, a única exceção a isso é Égua Clássico.
         // Por enquanto, tudo bem deixar isso aqui.
@@ -1853,21 +1960,25 @@ class InterpretadorBase {
         let valoresArray;
         // Verificar se é uma TuplaN (verifica instanceof OU propriedade elementos/tipo para maior compatibilidade)
         if (valores instanceof construtos_1.TuplaN ||
-            (valores && valores.tipo === 'tupla' && valores.elementos && Array.isArray(valores.elementos))) {
+            (valores &&
+                valores.tipo === 'tupla' &&
+                valores.elementos &&
+                Array.isArray(valores.elementos))) {
             valoresArray = valores.elementos.map((elem) => {
-                if (elem instanceof construtos_1.Literal || (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
+                if (elem instanceof construtos_1.Literal ||
+                    (elem && typeof elem === 'object' && elem.hasOwnProperty('valor'))) {
                     return this.resolverValor(elem.valor);
                 }
                 return this.resolverValor(elem);
             });
         }
         else if (Array.isArray(valores)) {
-            valoresArray = valores.map(v => this.resolverValor(v));
+            valoresArray = valores.map((v) => this.resolverValor(v));
         }
         else {
             const valorResolvido = this.resolverValor(valores);
             if (Array.isArray(valorResolvido)) {
-                valoresArray = valorResolvido.map(v => this.resolverValor(v));
+                valoresArray = valorResolvido.map((v) => this.resolverValor(v));
             }
             else {
                 valoresArray = [valorResolvido];
@@ -1989,7 +2100,9 @@ class InterpretadorBase {
             return objeto.valor.paraTexto();
         if (objeto instanceof construtos_1.Literal)
             return this.paraTexto(objeto.valor);
-        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse || objeto instanceof estruturas_1.DeleguaFuncao)
+        if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
+            objeto instanceof estruturas_1.DeleguaFuncao ||
+            objeto instanceof estruturas_1.DescritorTipoClasse)
             return objeto.paraTexto();
         if (objeto instanceof quebras_1.RetornoQuebra) {
             if (typeof objeto.valor === 'boolean')