@designliquido/delegua 1.22.2 → 1.23.1

package/umd/delegua.js

@@ -520,13 +520,15 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.funcoes = {};
         this.classesDeclaradas = new Set();
         this.classesRegistradas = new Map();
-        this.classesExternasConhecidas = new Set();
+        this.classesExternasRegistradas = new Map();
         this.classeAtualEmAnalise = null;
         this.atual = 0;
         this.diagnosticos = [];
     }
-    definirClassesExternasConhecidas(classesExternasConhecidas) {
-        this.classesExternasConhecidas = new Set(classesExternasConhecidas);
+    registrarClassesExternas(classes) {
+        for (const classe of classes) {
+            this.classesExternasRegistradas.set(classe.simbolo.lexema, classe);
+        }
     }
     verificarTipoAtribuido(declaracao) {
         if (declaracao.tipo) {
@@ -1304,8 +1306,11 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.verificarLadoLogico(logico.esquerda);
         return Promise.resolve();
     }
-    verificarChamada(chamada) {
+    async verificarChamada(chamada) {
         switch (chamada.entidadeChamada.constructor) {
+            case construtos_1.AcessoMetodoOuPropriedade:
+                await chamada.entidadeChamada.aceitar(this);
+                break;
             case construtos_1.Variavel:
                 let entidadeChamadaVariavel = chamada.entidadeChamada;
                 const nomeFuncao = entidadeChamadaVariavel.simbolo.lexema;
@@ -1692,7 +1697,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 this.erro(superClasseVariavel.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
             }
             else if (!this.classesDeclaradas.has(nomeSuperclasse) &&
-                !this.classesExternasConhecidas.has(nomeSuperclasse)) {
+                !this.classesRegistradas.has(nomeSuperclasse)) {
                 this.erro(superClasseVariavel.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
             }
         }
@@ -1861,8 +1866,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     async analisar(declaracoes) {
         this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
-        this.classesDeclaradas = new Set();
-        this.classesRegistradas = new Map();
+        this.classesDeclaradas = new Set(this.classesExternasRegistradas.keys());
+        this.classesRegistradas = new Map(this.classesExternasRegistradas);
         this.classeAtualEmAnalise = null;
         this.atual = 0;
         this.diagnosticos = [];
@@ -13763,29 +13768,17 @@ function simboloAtual(interpretador) {
 function construirModuloDeTestes(interpretador, registro) {
     const modulo = new modulo_1.DeleguaModulo('testes');
     modulo.componentes['afirmar'] = (0, modulo_afirmar_1.construirModuloAfirmar)();
-    modulo.componentes['grupo'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
-        const nome = interpretador.resolverValor(nomeRaw);
-        const funcao = interpretador.resolverValor(funcaoRaw);
-        const suiteAnterior = registro.suiteAtual;
-        registro.suiteAtual = suiteAnterior ? `${suiteAnterior} > ${nome}` : nome;
-        const emDeclaracaoTenteAnterior = interpretador.emDeclaracaoTente;
-        interpretador.emDeclaracaoTente = true;
-        try {
-            await funcao.chamar(interpretador, [], null);
-        }
-        finally {
-            registro.suiteAtual = suiteAnterior;
-            interpretador.emDeclaracaoTente = emDeclaracaoTenteAnterior;
-        }
-    });
-    modulo.componentes['teste'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
-        const nome = interpretador.resolverValor(nomeRaw);
-        const funcao = interpretador.resolverValor(funcaoRaw);
+    async function executarTeste(nome, fn) {
         const inicio = Date.now();
         const emDeclaracaoTenteAnterior = interpretador.emDeclaracaoTente;
         interpretador.emDeclaracaoTente = true;
+        for (const escopo of registro.pilhaEscopos) {
+            for (const h of escopo.antesDeCada) {
+                await h.chamar(interpretador, [], null);
+            }
+        }
         try {
-            await funcao.chamar(interpretador, [], null);
+            await fn.chamar(interpretador, [], null);
             registro.resultados.push({
                 nomeSuite: registro.suiteAtual,
                 nomeTeste: nome,
@@ -13803,9 +13796,134 @@ function construirModuloDeTestes(interpretador, registro) {
             });
         }
         finally {
+            for (const escopo of [...registro.pilhaEscopos].reverse()) {
+                for (const h of escopo.depoisDeCada) {
+                    await h.chamar(interpretador, [], null);
+                }
+            }
+            interpretador.emDeclaracaoTente = emDeclaracaoTenteAnterior;
+        }
+    }
+    async function executarGrupo(nome, fn) {
+        const suiteAnterior = registro.suiteAtual;
+        registro.suiteAtual = suiteAnterior ? `${suiteAnterior} > ${nome}` : nome;
+        const escopo = {
+            antesDeCada: [],
+            antesDeTodos: [],
+            depoisDeCada: [],
+            depoisDeTodos: [],
+            itensColetados: [],
+            temApenas: false,
+        };
+        registro.pilhaEscopos.push(escopo);
+        const modoColetarAnterior = registro.modoColeta;
+        registro.modoColeta = true;
+        const emDeclaracaoTenteAnterior = interpretador.emDeclaracaoTente;
+        interpretador.emDeclaracaoTente = true;
+        try {
+            await fn.chamar(interpretador, [], null);
+            registro.modoColeta = modoColetarAnterior;
+            for (const h of escopo.antesDeTodos) {
+                await h.chamar(interpretador, [], null);
+            }
+            for (const item of escopo.itensColetados) {
+                if (escopo.temApenas && !item.apenas)
+                    continue;
+                if (item.pular) {
+                    if (item.tipo === 'teste') {
+                        registro.resultados.push({
+                            nomeSuite: registro.suiteAtual,
+                            nomeTeste: item.nome,
+                            status: 'pulado',
+                            tempoMs: 0,
+                        });
+                    }
+                    continue;
+                }
+                if (item.tipo === 'teste') {
+                    await executarTeste(item.nome, item.fn);
+                }
+                else {
+                    await executarGrupo(item.nome, item.fn);
+                }
+            }
+            for (const h of escopo.depoisDeTodos) {
+                await h.chamar(interpretador, [], null);
+            }
+        }
+        finally {
+            registro.pilhaEscopos.pop();
+            registro.modoColeta = modoColetarAnterior;
+            registro.suiteAtual = suiteAnterior;
             interpretador.emDeclaracaoTente = emDeclaracaoTenteAnterior;
         }
+    }
+    function coletarOuExecutar(tipo, nome, fn, pular, apenas) {
+        if (registro.modoColeta && registro.pilhaEscopos.length > 0) {
+            const escopoAtual = registro.pilhaEscopos[registro.pilhaEscopos.length - 1];
+            if (apenas)
+                escopoAtual.temApenas = true;
+            escopoAtual.itensColetados.push({ tipo, nome, fn, pular, apenas });
+            return Promise.resolve();
+        }
+        if (pular) {
+            if (tipo === 'teste') {
+                registro.resultados.push({
+                    nomeSuite: registro.suiteAtual,
+                    nomeTeste: nome,
+                    status: 'pulado',
+                    tempoMs: 0,
+                });
+            }
+            return Promise.resolve();
+        }
+        return tipo === 'teste' ? executarTeste(nome, fn) : executarGrupo(nome, fn);
+    }
+    const grupoFn = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('grupo', nome, fn, false, false);
+    });
+    grupoFn['pular'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('grupo', nome, fn, true, false);
+    });
+    grupoFn['apenas'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('grupo', nome, fn, false, true);
     });
+    modulo.componentes['grupo'] = grupoFn;
+    const testeFn = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('teste', nome, fn, false, false);
+    });
+    testeFn['pular'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('teste', nome, fn, true, false);
+    });
+    testeFn['apenas'] = new funcao_padrao_1.FuncaoPadrao(2, async function (_visitante, nomeRaw, funcaoRaw) {
+        const nome = interpretador.resolverValor(nomeRaw);
+        const fn = interpretador.resolverValor(funcaoRaw);
+        return coletarOuExecutar('teste', nome, fn, false, true);
+    });
+    modulo.componentes['teste'] = testeFn;
+    function registrarHook(campo) {
+        return new funcao_padrao_1.FuncaoPadrao(1, function (_visitante, funcaoRaw) {
+            const fn = interpretador.resolverValor(funcaoRaw);
+            if (registro.pilhaEscopos.length > 0) {
+                registro.pilhaEscopos[registro.pilhaEscopos.length - 1][campo].push(fn);
+            }
+            return Promise.resolve(null);
+        });
+    }
+    modulo.componentes['antesDeCada'] = registrarHook('antesDeCada');
+    modulo.componentes['antesDeTodos'] = registrarHook('antesDeTodos');
+    modulo.componentes['depoisDeCada'] = registrarHook('depoisDeCada');
+    modulo.componentes['depoisDeTodos'] = registrarHook('depoisDeTodos');
     modulo.componentes['lancarErro'] = new funcao_padrao_1.FuncaoPadrao(1, function (_visitante, mensagemRaw) {
         const mensagem = interpretador.resolverValor(mensagemRaw);
         return Promise.reject(new erro_de_assertiva_1.ErroDeAssertiva(simboloAtual(interpretador), String(mensagem)));
@@ -13821,6 +13939,8 @@ class RegistroTestes {
     constructor() {
         this.resultados = [];
         this.suiteAtual = '';
+        this.pilhaEscopos = [];
+        this.modoColeta = false;
     }
 }
 exports.RegistroTestes = RegistroTestes;
@@ -21914,7 +22034,7 @@ class InterpretadorBase {
      */
     async visitarExpressaoAgrupamento(expressao) {
         const avaliacaoAgrupamento = await this.avaliar(expressao.expressao);
-        if (avaliacaoAgrupamento.declaracao !== undefined) {
+        if (avaliacaoAgrupamento !== null && avaliacaoAgrupamento.declaracao) {
             return avaliacaoAgrupamento.declaracao;
         }
         return avaliacaoAgrupamento;
@@ -22172,12 +22292,12 @@ class InterpretadorBase {
                     this.tiposNumericos.includes(tipoDireito)) {
                     return Number(valorEsquerdo) + Number(valorDireito);
                 }
+                if (valorEsquerdo === null || valorDireito === null) {
+                    return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
+                }
                 // TODO: Se tipo for 'qualquer', seria uma boa confiar nos operadores
                 // tradicionais do JavaScript?
-                if (tipoEsquerdo === 'qualquer' ||
-                    tipoDireito === 'qualquer' ||
-                    tipoEsquerdo === 'nulo' ||
-                    tipoDireito === 'nulo') {
+                if (tipoEsquerdo === 'qualquer' || tipoDireito === 'qualquer') {
                     return valorEsquerdo + valorDireito;
                 }
                 return this.paraTexto(valorEsquerdo) + this.paraTexto(valorDireito);
@@ -22733,35 +22853,22 @@ class InterpretadorBase {
         return retornoExecucao;
     }
     async visitarDeclaracaoEscolha(declaracao) {
-        const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
-        const valorCondicaoEscolha = this.resolverValor(condicaoEscolha);
-        const caminhos = declaracao.caminhos;
-        const caminhoPadrao = declaracao.caminhoPadrao;
-        let encontrado = false;
         try {
-            for (let i = 0; i < caminhos.length; i++) {
-                const caminho = caminhos[i];
-                for (let j = 0; j < caminho.condicoes.length; j++) {
-                    const condicaoAvaliada = await this.avaliar(caminho.condicoes[j]);
+            const condicaoEscolha = await this.avaliar(declaracao.identificadorOuLiteral);
+            const valorCondicaoEscolha = this.resolverValor(condicaoEscolha);
+            const caminhos = declaracao.caminhos;
+            const caminhoPadrao = declaracao.caminhoPadrao;
+            for (const caminho of caminhos) {
+                for (const condicao of caminho.condicoes) {
+                    const condicaoAvaliada = await this.avaliar(condicao);
                     if (condicaoAvaliada === valorCondicaoEscolha) {
-                        encontrado = true;
-                        try {
-                            await this.executarBloco(caminho.declaracoes);
-                        }
-                        catch (erro) {
-                            this.erros.push({
-                                erroInterno: erro,
-                                linha: declaracao.linha,
-                                hashArquivo: declaracao.hashArquivo,
-                            });
-                            return Promise.reject(erro);
-                        }
+                        return await this.executarBloco(caminho.declaracoes);
                     }
                 }
             }
-            if (caminhoPadrao !== null && !encontrado) {
+            if (caminhoPadrao !== null) {
                 this.registrarRamo?.(declaracao.hashArquivo, declaracao.linha, 'caso-padrao');
-                await this.executarBloco(caminhoPadrao.declaracoes);
+                return await this.executarBloco(caminhoPadrao.declaracoes);
             }
         }
         catch (erro) {
@@ -24488,6 +24595,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             variavelObjeto = variavelObjeto.valor;
         }
         const objeto = this.resolverValor(variavelObjeto);
+        if (objeto === null || objeto === undefined) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(undefined, `Não é possível acessar a propriedade '${expressao.nomeMetodo}' de um valor nulo.`, expressao.linha));
+        }
         if (objeto.constructor && objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
             try {
                 return objeto.obterMetodo(expressao.nomeMetodo);
@@ -24623,6 +24733,9 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
             variavelObjeto = retornoQuebra.valor;
         }
         const objeto = this.resolverValor(variavelObjeto, true);
+        if (objeto === null || objeto === undefined) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(undefined, `Não é possível acessar a propriedade '${expressao.simbolo.lexema}' de um valor nulo.`, expressao.linha));
+        }
         // Acesso a método via `super()`: percorre o OReM a partir de `proximaClasse`,
         // vincula o método encontrado à instância original e registra `classeDefinidora`
         // para que chamadas aninhadas a `super()` avancem corretamente na cadeia.
@@ -24792,12 +24905,14 @@ class Interpretador extends interpretador_base_1.InterpretadorBase {
         // Por exemplo, `objeto1.metodo1().metodo2()`.
         // Como `RetornoQuebra` também possui `valor`, precisamos extrair o
         // valor dele primeiro.
-        if (variavelObjeto.constructor === quebras_1.RetornoQuebra) {
+        if (variavelObjeto && variavelObjeto.constructor === quebras_1.RetornoQuebra) {
             variavelObjeto = variavelObjeto.valor;
         }
         const objeto = this.resolverValor(variavelObjeto);
-        // Outro caso que `instanceof` simplesmente não funciona para casos em Liquido,
-        // então testamos também o nome do construtor.
+        if (objeto === null || objeto === undefined) {
+            return Promise.reject(new excecoes_1.ErroEmTempoDeExecucao(undefined, `Não é possível acessar a propriedade '${expressao.nomePropriedade}' de um valor nulo.`, expressao.linha));
+        }
+        // A partir daqui, o interpretador sabe que 'objeto' não é nulo.
         if (objeto.constructor === estruturas_1.ObjetoDeleguaClasse) {
             return objeto.obterMetodo(expressao.nomePropriedade) || null;
         }