@designliquido/delegua 1.8.0 → 1.9.0

package/avaliador-sintatico/avaliador-sintatico.js

@@ -51,6 +51,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.erros = [];
         this.performance = performance;
         this.tiposDefinidosEmCodigo = {};
+        this.interfacesDeclaradas = {};
         this.tiposDeFerramentasExternas = {};
         this.primitivasConhecidas = {};
         this.pilhaEscopos = new pilha_escopos_1.PilhaEscopos();
@@ -257,8 +258,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             new declaracoes_1.Se(condicao, new declaracoes_1.Bloco(retornoExpressao.hashArquivo, retornoExpressao.linha, [
                 new declaracoes_1.Retorna(simboloVariavelIteracao, retornoExpressao),
             ]), [], null),
-        ])), 'qualquer[]' // TODO: Talvez um dia inferir o tipo aqui.
-        );
+        ])), retornoExpressao.tipo ? `${retornoExpressao.tipo}[]` : 'qualquer[]');
     }
     async primario() {
         const simboloAtual = this.simbolos[this.atual];
@@ -1056,7 +1056,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             if (Array.isArray(retornoDeclaracao)) {
                 declaracoes = declaracoes.concat(retornoDeclaracao);
             }
-            else {
+            else if (retornoDeclaracao !== null) {
                 declaracoes.push(retornoDeclaracao);
             }
         }
@@ -1541,6 +1541,41 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaDecoradores = [];
         return retornos;
     }
+    logicaComumInferenciaTiposAcessoMetodoOuPropriedade(entidadeChamada) {
+        // Algumas coisas podem acontecer aqui.
+        // Uma delas é a variável/constante ser uma classe padrão.
+        // 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];
+            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.`);
+            }
+            if (!(entidadeChamada.simbolo.lexema in
+                tipoCorrespondente.metodos) &&
+                !(entidadeChamada.simbolo.lexema in
+                    tipoCorrespondente.propriedades)) {
+                throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Membro '${entidadeChamada.simbolo.lexema}' não existe no tipo '${entidadeChamada.objeto.tipo}'.`);
+            }
+            if (entidadeChamada.simbolo.lexema in
+                tipoCorrespondente.metodos) {
+                const metodoCorrespondente = tipoCorrespondente.metodos[entidadeChamada.simbolo.lexema];
+                return metodoCorrespondente.tipoRetorno || 'qualquer';
+            }
+            const propriedadeCorrespondente = tipoCorrespondente.propriedades[entidadeChamada.simbolo.lexema];
+            return propriedadeCorrespondente.tipo;
+        }
+        // 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.
+        for (const primitiva in this.primitivasConhecidas) {
+            if (this.primitivasConhecidas[primitiva].hasOwnProperty(entidadeChamada.simbolo.lexema)) {
+                return this.primitivasConhecidas[primitiva][entidadeChamada.simbolo.lexema].tipo;
+            }
+        }
+        throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamada.simbolo, `Primitiva '${entidadeChamada.simbolo.lexema}' não existe.`);
+    }
     logicaComumInferenciaTiposVariaveisEConstantes(inicializador, tipo) {
         if (tipo !== 'qualquer') {
             return tipo;
@@ -1566,40 +1601,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                         const tipoRetornoAcessoMetodoResolvido = entidadeChamadaAcessoMetodo.tipoRetornoMetodo.replace('<T>', entidadeChamadaAcessoMetodo.objeto.tipo);
                         return tipoRetornoAcessoMetodoResolvido;
                     case construtos_1.AcessoMetodoOuPropriedade:
-                        const entidadeChamadaAcessoMetodoOuPropriedade = entidadeChamadaChamada;
-                        // Algumas coisas podem acontecer aqui.
-                        // Uma delas é a variável/constante ser uma classe padrão.
-                        // Isso ocorre quando a importação é feita de uma biblioteca Node.js.
-                        // Nesse caso, o tipo de `entidadeChamadaAcessoMetodoOuPropriedade.objeto` começa com uma letra maiúscula.
-                        if (entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo &&
-                            entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo.match(/^[A-Z]/)) {
-                            const tipoCorrespondente = this.tiposDefinidosPorBibliotecas[entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo];
-                            if (!tipoCorrespondente) {
-                                throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Tipo '${entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo}' não foi encontrado entre os tipos definidos por bibliotecas.`);
-                            }
-                            if (!(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
-                                tipoCorrespondente.metodos) &&
-                                !(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
-                                    tipoCorrespondente.propriedades)) {
-                                throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Membro '${entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema}' não existe no tipo '${entidadeChamadaAcessoMetodoOuPropriedade.objeto.tipo}'.`);
-                            }
-                            if (entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema in
-                                tipoCorrespondente.metodos) {
-                                const metodoCorrespondente = tipoCorrespondente.metodos[entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema];
-                                return metodoCorrespondente.tipoRetorno || 'qualquer';
-                            }
-                            const propriedadeCorrespondente = tipoCorrespondente.propriedades[entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema];
-                            return propriedadeCorrespondente.tipo;
-                        }
-                        // 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.
-                        for (const primitiva in this.primitivasConhecidas) {
-                            if (this.primitivasConhecidas[primitiva].hasOwnProperty(entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema)) {
-                                return this.primitivasConhecidas[primitiva][entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema].tipo;
-                            }
-                        }
-                        throw new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(entidadeChamadaAcessoMetodoOuPropriedade.simbolo, `Primitiva '${entidadeChamadaAcessoMetodoOuPropriedade.simbolo.lexema}' não existe.`);
+                        return this.logicaComumInferenciaTiposAcessoMetodoOuPropriedade(entidadeChamadaChamada);
                     case construtos_1.AcessoPropriedade:
                         const entidadeChamadaAcessoPropriedade = entidadeChamadaChamada;
                         return entidadeChamadaAcessoPropriedade.tipoRetornoPropriedade;
@@ -1900,8 +1902,68 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         }
         return new construtos_1.FuncaoConstruto(this.hashArquivo, Number(parenteseEsquerdo.linha), parametros, corpo, tipoRetorno, definicaoExplicitaDeTipo);
     }
+    /**
+     * Analisa uma declaração de interface.
+     * Interfaces definem contratos de métodos e propriedades que as classes devem implementar.
+     * A verificação é feita em tempo de análise (parse-time).
+     */
+    async declaracaoDeInterface() {
+        const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da interface.');
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do corpo da interface.");
+        const metodos = [];
+        const propriedades = [];
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+            if (this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA))
+                break;
+            const nomeMembro = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome de método ou propriedade na interface.');
+            if (this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_ESQUERDO)) {
+                // Assinatura de método: nome(params): tipoRetorno
+                this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após nome do método.");
+                let params = [];
+                if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
+                    params = await this.logicaComumParametros();
+                }
+                this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros.");
+                let tipoRetorno = 'qualquer';
+                if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
+                    tipoRetorno = this.verificarDefinicaoTipoAtual();
+                    this.avancarEDevolverAnterior();
+                }
+                this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                metodos.push(new declaracoes_1.AssinaturaMetodo(nomeMembro, params, tipoRetorno));
+            }
+            else {
+                // Assinatura de propriedade: nome: tipo
+                this.consumir(delegua_2.default.DOIS_PONTOS, "Esperado ':' após nome de propriedade na interface.");
+                const tipo = this.verificarDefinicaoTipoAtual();
+                this.avancarEDevolverAnterior();
+                this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                propriedades.push(new declaracoes_1.PropriedadeClasse(nomeMembro, tipo));
+            }
+        }
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após o corpo da interface.");
+        const declaracao = new declaracoes_1.InterfaceDeclaracao(simbolo, metodos, propriedades);
+        this.interfacesDeclaradas[simbolo.lexema] = declaracao;
+        return declaracao;
+    }
     async declaracaoDeClasse() {
+        var _a;
+        // Modificadores opcionais no nível da classe: `abstrata` e/ou `estática`.
+        // Sintaxe: `classe abstrata NomeDaClasse` ou `classe estática NomeDaClasse`.
+        let ehAbstrata = false;
+        let ehEstatica = false;
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ABSTRATO))
+            ehAbstrata = true;
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESTATICO))
+            ehEstatica = true;
+        // Também permite a ordem invertida: `classe estática abstrata`
+        if (!ehAbstrata && this.verificarSeSimboloAtualEIgualA(delegua_2.default.ABSTRATO))
+            ehAbstrata = true;
         const simbolo = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome da classe.');
+        // Pré-registro para permitir auto-referência no corpo da própria classe,
+        // como em `MinhaClasse.propriedadeEstatica` dentro de métodos.
+        this.tiposDefinidosEmCodigo[simbolo.lexema] = (_a = this.tiposDefinidosEmCodigo[simbolo.lexema]) !== null && _a !== void 0 ? _a : {};
         const pilhaDecoradoresClasse = Array.from(this.pilhaDecoradores);
         let superClasse = null;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.HERDA)) {
@@ -1909,39 +1971,311 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             this.superclasseAtual = simboloSuperclasse.lexema;
             superClasse = new construtos_1.Variavel(this.hashArquivo, this.simbolos[this.atual - 1], simboloSuperclasse.lexema);
         }
+        // Verificar `implementa InterfaceA, InterfaceB`
+        const implementaInterfaces = [];
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.IMPLEMENTA)) {
+            do {
+                implementaInterfaces.push(this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado nome de interface após "implementa".'));
+            } while (this.verificarSeSimboloAtualEIgualA(delegua_2.default.VIRGULA));
+        }
         this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' antes do escopo da classe.");
         this.pilhaDecoradores = [];
         const metodos = [];
         const propriedades = [];
-        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
-            !this.estaNoFinal()) {
-            // Se o símbolo atual é arroba, é um decorador.
-            // Caso contrário, verificamos o próximo símbolo.
-            if (this.simbolos[this.atual].tipo === delegua_2.default.ARROBA) {
-                await this.resolverDecoradores();
+        /**
+         * Analisa membros do corpo da classe com um contexto de acesso e estático padrão.
+         * Suporta blocos de contexto aninhados: `estático { }`, `privado { }`, `protegido { }`, `publico { }`.
+         */
+        const compreenderMembros = async (acessoPadrao, ehEstaticoPadrao) => {
+            var _a, _b;
+            while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+                // Pular comentários normais dentro do corpo da classe.
+                if (this.simbolos[this.atual].tipo === delegua_2.default.COMENTARIO ||
+                    this.simbolos[this.atual].tipo === delegua_2.default.LINHA_COMENTARIO) {
+                    this.avancarEDevolverAnterior();
+                    continue;
+                }
+                // Documentário (/** ... */)
+                let docAtual = null;
+                if (this.simbolos[this.atual].tipo === delegua_2.default.DOCUMENTARIO) {
+                    const simboloDoc = this.avancarEDevolverAnterior();
+                    docAtual = new construtos_1.ComentarioComoConstruto(simboloDoc);
+                }
+                // Decorador
+                if (this.simbolos[this.atual].tipo === delegua_2.default.ARROBA) {
+                    await this.resolverDecoradores();
+                    continue;
+                }
+                // Detecção de bloco de contexto: modificador seguido de '{'
+                const tipoAtual = this.simbolos[this.atual].tipo;
+                const tipoProximo = (_a = this.simbolos[this.atual + 1]) === null || _a === void 0 ? void 0 : _a.tipo;
+                const ehBlocoAcesso = [delegua_2.default.PRIVADO, delegua_2.default.PROTEGIDO, delegua_2.default.PUBLICO].includes(tipoAtual)
+                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoEstatico = tipoAtual === delegua_2.default.ESTATICO
+                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                if (ehBlocoAcesso) {
+                    const novoAcesso = tipoAtual === delegua_2.default.PRIVADO ? 'privado' :
+                        tipoAtual === delegua_2.default.PROTEGIDO ? 'protegido' : 'publico';
+                    this.avancarEDevolverAnterior(); // consume modificador de acesso
+                    this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após modificador de acesso de bloco.");
+                    await compreenderMembros(novoAcesso, ehEstaticoPadrao);
+                    this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' para fechar bloco de modificador de acesso.");
+                    continue;
+                }
+                if (ehBlocoEstatico) {
+                    this.avancarEDevolverAnterior(); // consume 'estático'
+                    this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após 'estático'.");
+                    await compreenderMembros(acessoPadrao, true);
+                    this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' para fechar bloco estático.");
+                    continue;
+                }
+                // Modificador de acesso por membro (somente quando NÃO seguido de '{')
+                let modificadorAcesso = acessoPadrao;
+                if (this.simbolos[this.atual].tipo === delegua_2.default.PRIVADO) {
+                    this.avancarEDevolverAnterior();
+                    modificadorAcesso = 'privado';
+                }
+                else if (this.simbolos[this.atual].tipo === delegua_2.default.PROTEGIDO) {
+                    this.avancarEDevolverAnterior();
+                    modificadorAcesso = 'protegido';
+                }
+                else if (this.simbolos[this.atual].tipo === delegua_2.default.PUBLICO) {
+                    this.avancarEDevolverAnterior();
+                    modificadorAcesso = 'publico';
+                }
+                // Modificador estático por membro (somente quando NÃO seguido de '{')
+                let ehEstatico = ehEstaticoPadrao;
+                if (this.simbolos[this.atual].tipo === delegua_2.default.ESTATICO &&
+                    ((_b = this.simbolos[this.atual + 1]) === null || _b === void 0 ? void 0 : _b.tipo) !== delegua_2.default.CHAVE_ESQUERDA) {
+                    this.avancarEDevolverAnterior();
+                    ehEstatico = true;
+                }
+                // Palavras-chave de acessor (obter/definir)
+                let eObtenedor = false;
+                let eDefinidor = false;
+                if (this.simbolos[this.atual].tipo === delegua_2.default.IDENTIFICADOR &&
+                    ['obter', 'definir', 'obtenedor', 'definidor', 'get', 'set'].includes(String(this.simbolos[this.atual].lexema || '').toLowerCase())) {
+                    const palavraAcessor = String(this.simbolos[this.atual].lexema || '').toLowerCase();
+                    this.avancarEDevolverAnterior();
+                    eObtenedor = palavraAcessor === 'obter' || palavraAcessor === 'obtenedor' || palavraAcessor === 'get';
+                    eDefinidor = palavraAcessor === 'definir' || palavraAcessor === 'definidor' || palavraAcessor === 'set';
+                }
+                // Método operador sobrecarregado: `operador+ (outro) { ... }`
+                if (this.simbolos[this.atual].tipo === delegua_2.default.OPERADOR) {
+                    const simboloOperadorKeyword = this.avancarEDevolverAnterior();
+                    const simboloDoOperador = this.avancarEDevolverAnterior();
+                    const nomeMetodoOp = 'operador' + simboloDoOperador.lexema;
+                    const simboloNomeMetodo = {
+                        tipo: delegua_2.default.IDENTIFICADOR,
+                        lexema: nomeMetodoOp,
+                        literal: null,
+                        linha: simboloOperadorKeyword.linha,
+                        hashArquivo: this.hashArquivo,
+                    };
+                    this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após operador sobrecarregado.");
+                    let paramsOp = [];
+                    if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
+                        paramsOp = await this.logicaComumParametros();
+                    }
+                    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 corpoFuncaoOp = new construtos_1.FuncaoConstruto(this.hashArquivo, simboloNomeMetodo.linha, paramsOp, corpoOp);
+                    const metodoOp = new declaracoes_1.FuncaoDeclaracao(simboloNomeMetodo, corpoFuncaoOp);
+                    metodoOp.estatico = ehEstatico;
+                    metodoOp.acesso = modificadorAcesso;
+                    metodoOp.documentacao = docAtual;
+                    metodos.push(metodoOp);
+                    this.pilhaDecoradores = [];
+                    continue;
+                }
+                // Método ou propriedade, determinado pelo token seguinte ao nome
+                const proximoSimbolo = this.simbolos[this.atual + 1];
+                switch (proximoSimbolo === null || proximoSimbolo === void 0 ? void 0 : proximoSimbolo.tipo) {
+                    case delegua_2.default.PARENTESE_ESQUERDO: {
+                        // Analisa: nome ( params ) [abstrato] [: tipoRetorno] { corpo }
+                        const nomeMetodo = this.avancarEDevolverAnterior();
+                        // Pré-registrar para suportar chamadas recursivas (igual a funcao()).
+                        this.pilhaEscopos.definirInformacoesVariavel(nomeMetodo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeMetodo.lexema, 'qualquer'));
+                        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após nome do método.");
+                        let params = [];
+                        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
+                            params = await this.logicaComumParametros();
+                        }
+                        this.consumir(delegua_2.default.PARENTESE_DIREITO, "Esperado ')' após parâmetros do método.");
+                        // O modificador `abstrato` vem APÓS o fechamento dos parâmetros.
+                        // Sintaxe: `area() abstrato: numero`
+                        let ehAbstrato = false;
+                        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ABSTRATO)) {
+                            ehAbstrato = true;
+                        }
+                        // Tipo de retorno opcional (igual a corpoDaFuncao())
+                        let tipoRetorno = 'qualquer';
+                        let definicaoExplicitaDeTipo = false;
+                        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
+                            tipoRetorno = this.verificarDefinicaoTipoAtual();
+                            this.avancarEDevolverAnterior();
+                            definicaoExplicitaDeTipo = true;
+                        }
+                        if (ehAbstrato) {
+                            // Método abstrato: sem corpo
+                            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                            const corpoVazio = new construtos_1.FuncaoConstruto(this.hashArquivo, nomeMetodo.linha, params, [], tipoRetorno);
+                            const metodoAbstrato = new declaracoes_1.FuncaoDeclaracao(nomeMetodo, corpoVazio, tipoRetorno);
+                            metodoAbstrato.estatico = ehEstatico;
+                            metodoAbstrato.abstrato = true;
+                            metodoAbstrato.acesso = modificadorAcesso;
+                            metodoAbstrato.documentacao = docAtual;
+                            metodos.push(metodoAbstrato);
+                        }
+                        else {
+                            // 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();
+                            let expressoesRetorna = [];
+                            for (const declaracao of corpo) {
+                                expressoesRetorna = expressoesRetorna.concat((0, comum_1.buscarRetornos)(declaracao));
+                            }
+                            const tiposRetornos = new Set(expressoesRetorna.filter((e) => e.tipo !== 'qualquer').map((e) => e.tipo));
+                            const retornaChamadoExplicitamente = tiposRetornos.size > 0;
+                            tiposRetornos.delete('qualquer');
+                            if (tipoRetorno === 'qualquer') {
+                                if (tiposRetornos.size > 0) {
+                                    tipoRetorno = tiposRetornos.values().next().value;
+                                }
+                                else if (!retornaChamadoExplicitamente && !definicaoExplicitaDeTipo) {
+                                    tipoRetorno = 'vazio';
+                                }
+                            }
+                            const corpoFuncao = new construtos_1.FuncaoConstruto(this.hashArquivo, nomeMetodo.linha, params, corpo, tipoRetorno);
+                            const tipoDaFuncao = `função<${tipoRetorno}>`;
+                            const metodo = new declaracoes_1.FuncaoDeclaracao(nomeMetodo, corpoFuncao, tipoDaFuncao);
+                            metodo.estatico = ehEstatico;
+                            metodo.eObtenedor = eObtenedor;
+                            metodo.eDefinidor = eDefinidor;
+                            metodo.acesso = modificadorAcesso;
+                            metodo.decoradores = Array.from(this.pilhaDecoradores);
+                            metodo.documentacao = docAtual;
+                            metodos.push(metodo);
+                            this.pilhaEscopos.definirInformacoesVariavel(nomeMetodo.lexema, new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeMetodo.lexema, tipoDaFuncao));
+                            this.pilhaEscopos.registrarReferenciaFuncao(nomeMetodo.lexema, metodo);
+                        }
+                        this.pilhaDecoradores = [];
+                        break;
+                    }
+                    case delegua_2.default.DOIS_PONTOS: {
+                        const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
+                        this.consumir(delegua_2.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
+                        const tipoPropriedade = this.avancarEDevolverAnterior();
+                        const prop = new declaracoes_1.PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, Array.from(this.pilhaDecoradores), modificadorAcesso, ehEstatico);
+                        prop.documentacao = docAtual;
+                        // Auto-propriedade: `nome: tipo { obter; definir; }`
+                        // Ou corpo personalizado: `nome: tipo { obter() { ... } definir(valor) { ... } }`
+                        if (this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA)) {
+                            this.avancarEDevolverAnterior(); // consume '{'
+                            let temCorpoPersonalizado = false;
+                            while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) &&
+                                !this.estaNoFinal()) {
+                                const lexema = String(this.simbolos[this.atual].lexema || '').toLowerCase();
+                                if (lexema === 'obter' || lexema === 'definir') {
+                                    const ehObter = lexema === 'obter';
+                                    this.avancarEDevolverAnterior(); // consume 'obter' / 'definir'
+                                    if (this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_ESQUERDO)) {
+                                        // Corpo personalizado: obter() { ... } / definir(valor) { ... }
+                                        temCorpoPersonalizado = true;
+                                        this.consumir(delegua_2.default.PARENTESE_ESQUERDO, "Esperado '(' após acessor.");
+                                        let paramsAcessor = [];
+                                        if (!this.verificarTipoSimboloAtual(delegua_2.default.PARENTESE_DIREITO)) {
+                                            paramsAcessor = await this.logicaComumParametros();
+                                        }
+                                        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();
+                                        // Inferência de tipo de retorno
+                                        let tipoAcessor = 'qualquer';
+                                        let expressoesRetornaAcessor = [];
+                                        for (const declaracao of corpoAcessor) {
+                                            expressoesRetornaAcessor = expressoesRetornaAcessor.concat((0, comum_1.buscarRetornos)(declaracao));
+                                        }
+                                        const tiposRetornosAcessor = new Set(expressoesRetornaAcessor.filter((e) => e.tipo !== 'qualquer').map((e) => e.tipo));
+                                        const retornaExplicitamenteAcessor = tiposRetornosAcessor.size > 0;
+                                        tiposRetornosAcessor.delete('qualquer');
+                                        if (tiposRetornosAcessor.size > 0) {
+                                            tipoAcessor = tiposRetornosAcessor.values().next().value;
+                                        }
+                                        else if (!retornaExplicitamenteAcessor) {
+                                            tipoAcessor = 'vazio';
+                                        }
+                                        const corpoFuncaoAcessor = new construtos_1.FuncaoConstruto(this.hashArquivo, nomePropriedade.linha, paramsAcessor, corpoAcessor, tipoAcessor);
+                                        const tipoDaFuncaoAcessor = `função<${tipoAcessor}>`;
+                                        const metodoAcessor = new declaracoes_1.FuncaoDeclaracao(nomePropriedade, corpoFuncaoAcessor, tipoDaFuncaoAcessor);
+                                        metodoAcessor.estatico = ehEstatico;
+                                        metodoAcessor.acesso = modificadorAcesso;
+                                        metodoAcessor.eObtenedor = ehObter;
+                                        metodoAcessor.eDefinidor = !ehObter;
+                                        metodos.push(metodoAcessor);
+                                    }
+                                    else {
+                                        // Forma trivial: obter; / definir;
+                                        if (ehObter) {
+                                            prop.autoObter = true;
+                                        }
+                                        else {
+                                            prop.autoDefinir = true;
+                                        }
+                                        this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                                    }
+                                }
+                                else {
+                                    break;
+                                }
+                            }
+                            this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' após acessores da propriedade.");
+                            // Corpo personalizado: obtenedor/definidor são métodos — não há campos base a declarar.
+                            // Para auto-propriedades, o campo base iniciado por '_' é criado em tempo de execução com base
+                            // nos indicadores autoObter/autoDefinir. O avaliador sintático usa o nome original ('nome').
+                            if (!temCorpoPersonalizado) {
+                                propriedades.push(prop);
+                            }
+                        }
+                        else {
+                            this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
+                            propriedades.push(prop);
+                        }
+                        this.pilhaDecoradores = [];
+                        break;
+                    }
+                    default:
+                        throw this.erro(this.simbolos[this.atual], 'Esperado definição de método ou propriedade.');
+                }
+            }
+        };
+        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.
+        for (const nomeInterface of implementaInterfaces) {
+            const interfaceDecl = this.interfacesDeclaradas[nomeInterface.lexema];
+            if (!interfaceDecl) {
+                this.erros.push(this.erro(nomeInterface, `Interface '${nomeInterface.lexema}' não foi declarada antes da classe '${simbolo.lexema}'.`));
                 continue;
             }
-            // Se o próximo símbolo ao atual for um parênteses, é um método.
-            // Caso contrário, é uma propriedade.
-            const proximoSimbolo = this.simbolos[this.atual + 1];
-            switch (proximoSimbolo.tipo) {
-                case delegua_2.default.PARENTESE_ESQUERDO:
-                    metodos.push(await this.funcao('método'));
-                    break;
-                case delegua_2.default.DOIS_PONTOS:
-                    const nomePropriedade = this.consumir(delegua_2.default.IDENTIFICADOR, 'Esperado identificador para nome de propriedade.');
-                    this.consumir(delegua_2.default.DOIS_PONTOS, 'Esperado dois-pontos após nome de propriedade.');
-                    const tipoPropriedade = this.avancarEDevolverAnterior();
-                    this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
-                    propriedades.push(new declaracoes_1.PropriedadeClasse(nomePropriedade, tipoPropriedade.lexema, Array.from(this.pilhaDecoradores)));
-                    this.pilhaDecoradores = [];
-                    break;
-                default:
-                    throw this.erro(this.simbolos[this.atual], 'Esperado definição de método ou propriedade.');
+            for (const assinatura of interfaceDecl.metodos) {
+                const nomeMetodo = assinatura.nome.lexema;
+                const implementado = metodos.some((m) => m.simbolo.lexema === nomeMetodo);
+                if (!implementado) {
+                    this.erros.push(this.erro(simbolo, `Classe '${simbolo.lexema}' não implementa o método '${nomeMetodo}' exigido pela interface '${nomeInterface.lexema}'.`));
+                }
+            }
+            for (const prop of interfaceDecl.propriedades) {
+                const nomeProp = prop.nome.lexema;
+                const implementada = propriedades.some((p) => p.nome.lexema === nomeProp);
+                if (!implementada) {
+                    this.erros.push(this.erro(simbolo, `Classe '${simbolo.lexema}' não declara a propriedade '${nomeProp}' exigida pela interface '${nomeInterface.lexema}'.`));
+                }
             }
         }
-        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);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasse, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstatica, implementaInterfaces);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         this.superclasseAtual = undefined;
         return definicaoClasse;
@@ -1963,15 +2297,26 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             while (this.verificarTipoSimboloAtual(delegua_2.default.ARROBA)) {
                 await this.resolverDecoradores();
             }
+            // Documentário (/** ... */) antes de uma declaração de função.
+            let docTopLevel = null;
+            if (this.verificarTipoSimboloAtual(delegua_2.default.DOCUMENTARIO)) {
+                const simboloDoc = this.avancarEDevolverAnterior();
+                docTopLevel = new construtos_1.ComentarioComoConstruto(simboloDoc);
+            }
             if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
                 this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
                 this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
                 this.avancarEDevolverAnterior();
-                return await this.funcao('funcao');
+                const declaracaoFuncao = await this.funcao('funcao');
+                declaracaoFuncao.documentacao = docTopLevel;
+                return declaracaoFuncao;
             }
             if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.CLASSE)) {
                 return await this.declaracaoDeClasse();
             }
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.INTERFACE)) {
+                return await this.declaracaoDeInterface();
+            }
             return await this.resolverDeclaracao();
         }
         catch (erro) {
@@ -1986,10 +2331,15 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      * @returns Sempre retorna `void`.
      */
     sincronizar() {
-        this.avancarEDevolverAnterior();
+        this.avancarEDevolverAnterior(); // avança além do token com erro
         while (!this.estaNoFinal()) {
-            const tipoSimboloAtual = this.simbolos[this.atual - 1].tipo;
-            switch (tipoSimboloAtual) {
+            // Um ponto-e-vírgula já consumido indica fronteira limpa entre declarações.
+            if (this.simbolos[this.atual - 1].tipo === delegua_2.default.PONTO_E_VIRGULA)
+                return;
+            // Uma palavra-chave de início de declaração ou fecha-chave à frente:
+            // retorna SEM consumir o token, para que o chamador o analise normalmente.
+            switch (this.simbolos[this.atual].tipo) {
+                case delegua_2.default.CHAVE_DIREITA:
                 case delegua_2.default.CLASSE:
                 case delegua_2.default.FUNCAO:
                 case delegua_2.default.FUNÇÃO:
@@ -2020,6 +2370,20 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 return await this.declaracaoBloco();
             case delegua_2.default.COMENTARIO:
                 return this.declaracaoComentarioUmaLinha();
+            case delegua_2.default.DOCUMENTARIO: {
+                const simboloDoc = this.avancarEDevolverAnterior();
+                // Se o próximo token for uma declaração de função com identificador,
+                // anexa o documentário como documentação da função.
+                if ((this.verificarTipoSimboloAtual(delegua_2.default.FUNCAO) ||
+                    this.verificarTipoSimboloAtual(delegua_2.default.FUNÇÃO)) &&
+                    this.verificarTipoProximoSimbolo(delegua_2.default.IDENTIFICADOR)) {
+                    this.avancarEDevolverAnterior();
+                    const declaracaoFuncao = await this.funcao('funcao');
+                    declaracaoFuncao.documentacao = new construtos_1.ComentarioComoConstruto(simboloDoc);
+                    return declaracaoFuncao;
+                }
+                return new declaracoes_1.Comentario(simboloDoc.hashArquivo, simboloDoc.linha, simboloDoc.literal, false);
+            }
             case delegua_2.default.CONSTANTE:
                 this.avancarEDevolverAnterior();
                 return await this.declaracaoDeConstantes();
@@ -2198,6 +2562,8 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.pilhaEscopos.definirInformacoesVariavel('tupla', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('tupla', 'tupla', true, [
             new informacao_elemento_sintatico_1.InformacaoElementoSintatico('vetor', 'qualquer[]'),
         ]));
+        // Classe base global `Objeto`, registrada pelo interpretador em tempo de execução.
+        this.pilhaEscopos.definirInformacoesVariavel('Objeto', new informacao_elemento_sintatico_1.InformacaoElementoSintatico('Objeto', 'qualquer'));
         // TODO: Escrever algum tipo de validação aqui.
         for (const tipos of Object.values(this.tiposDeFerramentasExternas)) {
             for (const [nomeTipo, tipo] of Object.entries(tipos)) {
@@ -2214,6 +2580,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         this.simbolos = (retornoLexador === null || retornoLexador === void 0 ? void 0 : retornoLexador.simbolos) || [];
         this.pilhaDecoradores = [];
         this.tiposDefinidosEmCodigo = {};
+        this.interfacesDeclaradas = {};
         this.montaoTipos = new montao_tipos_1.MontaoTipos();
         this.inicializarPilhaEscopos();
         let declaracoes = [];