@designliquido/delegua 1.18.1 → 1.18.3

package/avaliador-sintatico/avaliador-sintatico.js

@@ -1730,9 +1730,26 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         // Isso ocorre quando a importação é feita de uma biblioteca Node.js.
         // Nesse caso, o tipo de `entidadeChamada.objeto` começa com uma letra maiúscula.
         if (entidadeChamada.objeto.tipo && entidadeChamada.objeto.tipo.match(/^[A-Z]/)) {
-            const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[entidadeChamada.objeto.tipo];
+            const tipoObjeto = entidadeChamada.objeto.tipo;
+            // Classe definida em código (local ou importada de arquivo .delegua) tem precedência.
+            if (tipoObjeto in this.tiposDefinidosEmCodigo) {
+                const classeDefinida = this.tiposDefinidosEmCodigo[tipoObjeto];
+                if (classeDefinida instanceof declaracoes_1.Classe) {
+                    const nomeMembro = entidadeChamada.simbolo.lexema;
+                    const metodo = classeDefinida.metodos?.find(m => m.simbolo.lexema === nomeMembro);
+                    if (metodo) {
+                        return metodo.tipo || 'qualquer';
+                    }
+                    const propriedade = classeDefinida.propriedades?.find(p => p.nome.lexema === nomeMembro);
+                    if (propriedade) {
+                        return propriedade.tipo || 'qualquer';
+                    }
+                    return 'qualquer';
+                }
+            }
+            const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[tipoObjeto];
             if (!tipoCorrespondente) {
-                throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Tipo '${entidadeChamada.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
+                throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Tipo '${tipoObjeto}' não foi encontrado entre os tipos definidos por bibliotecas.`);
             }
             if (!(entidadeChamada.simbolo.lexema in tipoCorrespondente.metodos) &&
                 !(entidadeChamada.simbolo.lexema in tipoCorrespondente.propriedades)) {
@@ -1745,6 +1762,17 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             const propriedadeCorrespondente = tipoCorrespondente.propriedades[entidadeChamada.simbolo.lexema];
             return propriedadeCorrespondente.tipo;
         }
+        // Chamada via 'isto': verificar métodos da classe em análise antes de checar primitivas.
+        if (entidadeChamada.objeto instanceof construtos_1.Isto) {
+            if (this.metodosClasseAtualEmAnalise) {
+                const nomeMembro = entidadeChamada.simbolo.lexema;
+                const metodo = this.metodosClasseAtualEmAnalise.find(m => m.simbolo.lexema === nomeMembro);
+                if (metodo) {
+                    return metodo.tipo || 'qualquer';
+                }
+            }
+            return 'qualquer';
+        }
         // Este caso ocorre quando a variável/constante é do tipo 'qualquer',
         // e a chamada normalmente é feita para uma primitiva.
         // A inferência, portanto, ocorre pelo uso da primitiva.
@@ -2254,7 +2282,20 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                     }
                     this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros do operador.");
                     this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do operador.");
-                    const corpoOp = await this.blocoEscopo();
+                    const indiceAberturaCorpoOp = this.atual - 1;
+                    const quantidadeErrosAntesCorpoOp = this.erros.length;
+                    let corpoOp = [];
+                    try {
+                        corpoOp = await this.blocoEscopo();
+                    }
+                    catch (erro) {
+                        this.erros.push(erro);
+                    }
+                    if (this.erros.length > quantidadeErrosAntesCorpoOp) {
+                        this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoOp);
+                        corpoOp = [];
+                        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                    }
                     const corpoFuncaoOp = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloNomeMetodo.linha, paramsOp, corpoOp);
                     const metodoOp = new declaracoes_1.FuncaoDeclaracao(simboloNomeMetodo, corpoFuncaoOp);
                     metodoOp.estatico = ehEstatico;
@@ -2312,7 +2353,20 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             // Método concreto: com corpo.
                             // Inferência de tipo de retorno igual a corpoDaFuncao().
                             this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do método.");
-                            const corpo = await this.blocoEscopo();
+                            const indiceAberturaCorpo = this.atual - 1;
+                            const quantidadeErrosAntesCorpo = this.erros.length;
+                            let corpo = [];
+                            try {
+                                corpo = await this.blocoEscopo();
+                            }
+                            catch (erro) {
+                                this.erros.push(erro);
+                            }
+                            if (this.erros.length > quantidadeErrosAntesCorpo) {
+                                this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpo);
+                                corpo = [];
+                                this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                            }
                             let expressoesRetorna = [];
                             for (const declaracao of corpo) {
                                 expressoesRetorna = expressoesRetorna.concat((0, comum_1.buscarRetornos)(declaracao));
@@ -2378,7 +2432,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                                         }
                                         this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros do acessor.");
                                         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo do acessor.");
-                                        const corpoAcessor = await this.blocoEscopo();
+                                        const indiceAberturaCorpoAcessor = this.atual - 1;
+                                        const quantidadeErrosAntesCorpoAcessor = this.erros.length;
+                                        let corpoAcessor = [];
+                                        try {
+                                            corpoAcessor = await this.blocoEscopo();
+                                        }
+                                        catch (erro) {
+                                            this.erros.push(erro);
+                                        }
+                                        if (this.erros.length >
+                                            quantidadeErrosAntesCorpoAcessor) {
+                                            this.atual = this.encontrarIndiceAposFechamentoDeBloco(indiceAberturaCorpoAcessor);
+                                            corpoAcessor = [];
+                                            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                                        }
                                         // Inferência de tipo de retorno
                                         let tipoAcessor = 'qualquer';
                                         let expressoesRetornaAcessor = [];
@@ -2443,6 +2511,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
             }
         };
+        this.metodosClasseAtualEmAnalise = metodos;
         await compreenderMembros('publico', false);
         this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o escopo da classe.");
         // Verificação em tempo de análise: classe deve implementar todos os contratos das interfaces.
@@ -2501,6 +2570,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasses, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstrangeira, ehEstatica, implementaInterfaces, mesclas);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         this.superclasseAtual = undefined;
+        this.metodosClasseAtualEmAnalise = undefined;
         return definicaoClasse;
     }
     /**
@@ -2648,6 +2718,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * @returns Sempre retorna `void`.
      */
     sincronizar() {
+        if (this.estaNoFinal()) {
+            return;
+        }
         this.avancarEDevolverAnterior(); // avança além do token com erro
         while (!this.estaNoFinal()) {
             // Um ponto-e-vírgula já consumido indica fronteira limpa entre declarações.
@@ -2671,6 +2744,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.avancarEDevolverAnterior();
         }
     }
+    encontrarIndiceAposFechamentoDeBloco(indiceAbertura) {
+        let aberturasPendentes = 1;
+        for (let indice = indiceAbertura + 1; indice < this.simbolos.length; indice++) {
+            if (this.simbolos[indice].tipo === delegua_2.default.CHAVE_ESQUERDA) {
+                aberturasPendentes++;
+            }
+            else if (this.simbolos[indice].tipo === delegua_2.default.CHAVE_DIREITA) {
+                aberturasPendentes--;
+                if (aberturasPendentes === 0) {
+                    return indice + 1;
+                }
+            }
+        }
+        return this.simbolos.length;
+    }
     /**
      * Todas as resoluções triviais da linguagem, ou seja, todas as
      * resoluções que podem ocorrer dentro ou fora de um bloco.