@designliquido/delegua 1.8.1 → 1.10.0

package/interpretador/interpretador-base.js

@@ -32,11 +32,16 @@ const primitivas_vetor_1 = __importDefault(require("../bibliotecas/primitivas-ve
 class InterpretadorBase {
     constructor(diretorioBase, performance = false, funcaoDeRetorno = null, funcaoDeRetornoMesmaLinha = null) {
         this.resultadoInterpretador = [];
+        this.classeAtualEmExecucao = null;
         this.funcaoDeRetorno = null;
         this.funcaoDeRetornoMesmaLinha = null;
         this.interfaceDeEntrada = null; // Originalmente é `readline.Interface`
         this.interfaceEntradaSaida = null;
         this.emDeclaracaoTente = false;
+        // typeName → methodName → DeleguaFuncao
+        this.extensoesGlobais = new Map();
+        // hashArquivo → typeName → methodName → DeleguaFuncao
+        this.extensoesModulo = new Map();
         this.microLexador = new lexador_1.MicroLexador();
         this.microAvaliadorSintatico = new avaliador_sintatico_1.MicroAvaliadorSintatico();
         this.regexInterpolacao = /\${(.*?)}/g;
@@ -75,6 +80,8 @@ class InterpretadorBase {
             emLacoRepeticao: false,
         };
         this.pilhaEscoposExecucao.empilhar(escopoExecucao);
+        // Registrar a classe base `Objeto` no escopo global.
+        this.pilhaEscoposExecucao.definirVariavel('Objeto', estruturas_1.OBJETO_BASE);
     }
     /**
      * Cede o controle ao loop de eventos do JavaScript.
@@ -324,22 +331,43 @@ class InterpretadorBase {
      */
     async resolverInterpolacoes(textoOriginal, linha) {
         const variaveis = textoOriginal.match(this.regexInterpolacao);
-        let resultadosAvaliacaoSintatica = variaveis.map((s) => {
+        return await Promise.all(variaveis.map(async (s) => {
+            var _a, _b, _c, _d;
             const expressaoInterpolacao = s.replace(/[\$\{\}]*/gm, '');
-            let microLexador = this.microLexador.mapear(expressaoInterpolacao);
-            const resultadoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar(microLexador, linha);
-            return {
-                expressaoInterpolacao,
-                resultadoMicroAvaliadorSintatico,
-            };
-        });
-        // TODO: Verificar erros do `resultadosAvaliacaoSintatica`.
-        const resolucoesPromises = await Promise.all(resultadosAvaliacaoSintatica
-            .flatMap((r) => r.resultadoMicroAvaliadorSintatico.declaracoes)
-            .map((d) => this.avaliar(d)));
-        return resolucoesPromises.map((item, indice) => ({
-            expressaoInterpolacao: resultadosAvaliacaoSintatica[indice].expressaoInterpolacao,
-            valor: item,
+            const microLexador = this.microLexador.mapear(expressaoInterpolacao);
+            let declaracoes = [];
+            try {
+                const resultadoMicroAvaliadorSintatico = this.microAvaliadorSintatico.analisar(microLexador, linha);
+                for (const erro of resultadoMicroAvaliadorSintatico.erros) {
+                    this.erros.push({
+                        erroInterno: erro,
+                        linha: (_a = erro.linha) !== null && _a !== void 0 ? _a : linha,
+                        hashArquivo: (_b = erro.hashArquivo) !== null && _b !== void 0 ? _b : -1,
+                    });
+                }
+                declaracoes = resultadoMicroAvaliadorSintatico.declaracoes;
+            }
+            catch (erroAvaliador) {
+                this.erros.push({
+                    erroInterno: erroAvaliador,
+                    linha: (_c = erroAvaliador.linha) !== null && _c !== void 0 ? _c : linha,
+                    hashArquivo: (_d = erroAvaliador.hashArquivo) !== null && _d !== void 0 ? _d : -1,
+                });
+            }
+            let valor = declaracoes.length > 0 ? await this.avaliar(declaracoes[0]) : '';
+            const instancia = valor instanceof estruturas_1.ObjetoDeleguaClasse
+                ? valor
+                : (valor === null || valor === void 0 ? void 0 : valor.valor) instanceof estruturas_1.ObjetoDeleguaClasse
+                    ? valor.valor
+                    : null;
+            if (instancia) {
+                const metodoParaTexto = instancia.classe.encontrarMetodo('paraTexto');
+                if (metodoParaTexto) {
+                    const funcaoBound = metodoParaTexto.funcaoPorMetodoDeClasse(instancia);
+                    valor = await funcaoBound.chamar(this, []);
+                }
+            }
+            return { expressaoInterpolacao, valor };
         }));
     }
     async visitarExpressaoLiteral(expressao) {
@@ -519,6 +547,23 @@ class InterpretadorBase {
         const direita = await this.avaliar(expressao.direita);
         const valorEsquerdo = this.resolverValor(esquerda);
         const valorDireito = this.resolverValor(direita);
+        // Verificar sobrecarga de operador: se o operando esquerdo é uma instância de classe,
+        // procurar método `operador<símbolo>` (ex: `operador+`, `operador==`).
+        if (valorEsquerdo instanceof estruturas_1.ObjetoDeleguaClasse) {
+            const nomeOperador = 'operador' + expressao.operador.lexema;
+            const metodoOperador = valorEsquerdo.classe.encontrarMetodo(nomeOperador);
+            if (metodoOperador) {
+                const metodoBound = metodoOperador.funcaoPorMetodoDeClasse(valorEsquerdo);
+                const argumentoOperador = direita && Object.prototype.hasOwnProperty.call(direita, 'tipo')
+                    ? direita
+                    : {
+                        tipo: (0, inferenciador_1.inferirTipoVariavel)(valorDireito),
+                        valor: valorDireito,
+                        imutavel: false,
+                    };
+                return await metodoBound.chamar(this, [{ nome: null, valor: argumentoOperador }]);
+            }
+        }
         const tipoEsquerdo = (esquerda === null || esquerda === void 0 ? void 0 : esquerda.hasOwnProperty('tipo'))
             ? esquerda.tipo
             : (0, inferenciador_1.inferirTipoVariavel)(esquerda);
@@ -868,7 +913,7 @@ class InterpretadorBase {
                 const valor = await this.avaliar(expressao.valor);
                 if (objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
                     const objetoDeleguaClasse = objeto;
-                    objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor);
+                    await objetoDeleguaClasse.definir(alvoPropriedade.simbolo, valor, this);
                 }
                 break;
             default:
@@ -1455,7 +1500,7 @@ class InterpretadorBase {
         }
         const valor = await this.avaliar(expressao.valor);
         if (objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
-            objeto.definir(expressao.nome, valor);
+            await objeto.definir(expressao.nome, valor, this);
             return valor;
         }
         if (objeto.constructor === Object) {
@@ -1464,6 +1509,7 @@ class InterpretadorBase {
     }
     visitarDeclaracaoDefinicaoFuncao(declaracao) {
         const funcao = new estruturas_1.DeleguaFuncao(declaracao.simbolo.lexema, declaracao.funcao);
+        funcao.documentacao = declaracao.documentacao;
         this.pilhaEscoposExecucao.definirVariavel(declaracao.simbolo.lexema, funcao);
         this.pilhaEscoposExecucao.registrarReferenciaFuncao(declaracao.id, funcao);
         return Promise.resolve({
@@ -1491,29 +1537,163 @@ class InterpretadorBase {
             this.pilhaEscoposExecucao.definirVariavel('super', superClasse);
         }
         const metodos = {};
+        const metodosEstaticos = {};
+        const obtenedores = {};
+        const definidores = {};
+        const obtenedoresEstaticos = {};
+        const definidoresEstaticos = {};
+        const metodosAbstratos = [];
+        const acessoMetodos = {};
+        const acessoPropriedades = {};
         const definirMetodos = declaracao.metodos;
         for (let i = 0; i < declaracao.metodos.length; i++) {
             const metodoAtual = definirMetodos[i];
-            const eInicializador = metodoAtual.simbolo.lexema === 'construtor';
-            const funcao = new estruturas_1.DeleguaFuncao(metodoAtual.simbolo.lexema, metodoAtual.funcao, undefined, eInicializador);
             const nomeMetodo = metodoAtual.simbolo.lexema;
-            if (metodos[nomeMetodo]) {
-                if (!Array.isArray(metodos[nomeMetodo])) {
-                    metodos[nomeMetodo] = [metodos[nomeMetodo]];
+            // Registrar nível de acesso do método.
+            if (metodoAtual.acesso && metodoAtual.acesso !== 'publico') {
+                acessoMetodos[nomeMetodo] = metodoAtual.acesso;
+            }
+            // Métodos abstratos: registrar apenas o nome, não criar função executável.
+            if (metodoAtual.abstrato) {
+                metodosAbstratos.push(nomeMetodo);
+                continue;
+            }
+            const eInicializador = nomeMetodo === 'construtor';
+            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;
+            if (metodoAtual.eObtenedor) {
+                if (ehEstatico) {
+                    obtenedoresEstaticos[nomeMetodo] = funcao;
+                }
+                else {
+                    obtenedores[nomeMetodo] = funcao;
+                }
+                continue;
+            }
+            if (metodoAtual.eDefinidor) {
+                if (ehEstatico) {
+                    definidoresEstaticos[nomeMetodo] = funcao;
+                }
+                else {
+                    definidores[nomeMetodo] = funcao;
+                }
+                continue;
+            }
+            const destino = ehEstatico && !eInicializador ? metodosEstaticos : metodos;
+            if (destino[nomeMetodo]) {
+                if (!Array.isArray(destino[nomeMetodo])) {
+                    destino[nomeMetodo] = [destino[nomeMetodo]];
                 }
-                metodos[nomeMetodo].push(funcao);
+                destino[nomeMetodo].push(funcao);
             }
             else {
-                metodos[nomeMetodo] = funcao;
+                destino[nomeMetodo] = funcao;
+            }
+        }
+        // Registrar propriedades estáticas no mapa de membros estáticos e níveis de acesso.
+        // Numa classe estática, todas as propriedades são tratadas como estáticas.
+        const membrosEstaticos = {};
+        for (const prop of declaracao.propriedades) {
+            if (prop.estatico || declaracao.classeEstatica) {
+                membrosEstaticos[prop.nome.lexema] = undefined;
+            }
+            if (prop.acesso && prop.acesso !== 'publico') {
+                acessoPropriedades[prop.nome.lexema] = prop.acesso;
             }
         }
         const descritorTipoClasse = new estruturas_1.DescritorTipoClasse(declaracao.simbolo, superClasse, metodos, declaracao.propriedades);
+        descritorTipoClasse.metodosEstaticos = metodosEstaticos;
+        descritorTipoClasse.membrosEstaticos = membrosEstaticos;
+        descritorTipoClasse.obtenedores = obtenedores;
+        descritorTipoClasse.definidores = definidores;
+        descritorTipoClasse.obtenedoresEstaticos = obtenedoresEstaticos;
+        descritorTipoClasse.definidoresEstaticos = definidoresEstaticos;
+        descritorTipoClasse.abstrata = declaracao.abstrata;
+        descritorTipoClasse.classeEstatica = declaracao.classeEstatica;
+        descritorTipoClasse.metodosAbstratos = metodosAbstratos;
+        descritorTipoClasse.acessoMetodos = acessoMetodos;
+        descritorTipoClasse.acessoPropriedades = acessoPropriedades;
+        // 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;
+        }
+        // Verifica se a subclasse concreta implementa todos os métodos abstratos
+        // da superclasse abstrata.
+        if (!declaracao.abstrata && superClasse && 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.
         descritorTipoClasse.dialetoRequerDeclaracaoPropriedades = this.requerDeclaracaoPropriedades;
         this.pilhaEscoposExecucao.atribuirVariavel(declaracao.simbolo, descritorTipoClasse);
         return descritorTipoClasse;
     }
+    /**
+     * Registra uma declaração de interface no ambiente de execução.
+     * Interfaces são verificadas em tempo de análise; em tempo de execução, apenas registramos
+     * o nome para possíveis verificações futuras (ex: `eInstanciaDe`).
+     */
+    async visitarDeclaracaoInterface(_declaracao) {
+        // Interfaces não possuem comportamento em tempo de execução.
+        // São contratos verificados em tempo de análise sintática.
+        return Promise.resolve();
+    }
+    /**
+     * Procura um método de extensão nos registros de módulo e global,
+     * percorrendo os tipos na ordem indicada (específico antes de base).
+     */
+    encontrarMetodoExtensao(tiposParaVerificar, nomeMetodo, hashArquivo) {
+        var _a, _b;
+        // Extensões module-scoped têm prioridade sobre as globais.
+        const extensoesDoModulo = this.extensoesModulo.get(hashArquivo);
+        if (extensoesDoModulo) {
+            for (const tipo of tiposParaVerificar) {
+                const metodo = (_a = extensoesDoModulo.get(tipo)) === null || _a === void 0 ? void 0 : _a.get(nomeMetodo);
+                if (metodo)
+                    return metodo;
+            }
+        }
+        for (const tipo of tiposParaVerificar) {
+            const metodo = (_b = this.extensoesGlobais.get(tipo)) === null || _b === void 0 ? void 0 : _b.get(nomeMetodo);
+            if (metodo)
+                return metodo;
+        }
+        return undefined;
+    }
+    /**
+     * Registra os métodos de uma declaração de extensão nos registros
+     * de extensão do interpretador.
+     */
+    async visitarDeclaracaoExtensao(declaracao) {
+        const tipoNome = declaracao.simboloTipo.lexema;
+        for (const metodoDeclarado of declaracao.metodos) {
+            const nomeMetodo = metodoDeclarado.simbolo.lexema;
+            const funcao = new estruturas_1.DeleguaFuncao(nomeMetodo, metodoDeclarado.funcao);
+            if (declaracao.ehGlobal) {
+                if (!this.extensoesGlobais.has(tipoNome)) {
+                    this.extensoesGlobais.set(tipoNome, new Map());
+                }
+                this.extensoesGlobais.get(tipoNome).set(nomeMetodo, funcao);
+            }
+            else {
+                const hash = declaracao.hashArquivo;
+                if (!this.extensoesModulo.has(hash)) {
+                    this.extensoesModulo.set(hash, new Map());
+                }
+                const mapa = this.extensoesModulo.get(hash);
+                if (!mapa.has(tipoNome)) {
+                    mapa.set(tipoNome, new Map());
+                }
+                mapa.get(tipoNome).set(nomeMetodo, funcao);
+            }
+        }
+    }
     /**
      * Executa um acesso a método, normalmente de um objeto de classe.
      * @param {AcessoMetodoOuPropriedade} expressao A expressão de acesso.
@@ -1534,7 +1714,7 @@ class InterpretadorBase {
         // então testamos também o nome do construtor.
         if (objeto instanceof estruturas_1.ObjetoDeleguaClasse ||
             objeto.constructor.name === 'ObjetoDeleguaClasse') {
-            const valor = objeto.obter(expressao.simbolo);
+            const valor = await objeto.obter(expressao.simbolo, this);
             if (valor === 0)
                 return 0;
             return valor || null;