@designliquido/delegua 1.8.1 → 1.9.0

package/avaliador-sintatico/avaliador-sintatico.d.ts

@@ -1,7 +1,7 @@
 import { AcessoMetodoOuPropriedade, AjudaComoConstruto, Chamada, Construto, Decorador, Dicionario, EnquantoComoConstruto, FuncaoConstruto, ImportarComoConstruto, Leia, ListaCompreensao, ParaCadaComoConstruto, ParaComoConstruto, Tupla, Variavel } from '../construtos';
 import { AvaliadorSintaticoInterface, ParametroInterface, SimboloInterface } from '../interfaces';
 import { ErroAvaliadorSintatico } from './erro-avaliador-sintatico';
-import { Ajuda, Bloco, Classe, Comentario, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, Para, ParaCada, Retorna, Se, Sustar, TendoComo, Tente, Var } from '../declaracoes';
+import { Ajuda, Bloco, Classe, Comentario, Const, Continua, Declaracao, Enquanto, Escolha, Escreva, Expressao, Falhar, Fazer, FuncaoDeclaracao, Importar, InterfaceDeclaracao, Para, ParaCada, Retorna, Se, Sustar, TendoComo, Tente, Var } from '../declaracoes';
 import { RetornoAvaliadorSintatico } from '../interfaces/retornos/retorno-avaliador-sintatico';
 import { RetornoLexador } from '../interfaces/retornos/retorno-lexador';
 import { AvaliadorSintaticoBase } from './avaliador-sintatico-base';
@@ -36,6 +36,9 @@ export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implement
     tiposDefinidosEmCodigo: {
         [nomeTipo: string]: Declaracao;
     };
+    interfacesDeclaradas: {
+        [nomeInterface: string]: InterfaceDeclaracao;
+    };
     tiposDefinidosPorBibliotecas: {
         [nomeTipo: string]: ClasseDeModulo;
     };
@@ -216,6 +219,7 @@ export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implement
     protected resolverDecoradores(): Promise<void>;
     protected declaracaoTendoComo(): Promise<TendoComo>;
     protected declaracaoDesestruturacaoVariavel(): Promise<Var[]>;
+    protected logicaComumInferenciaTiposAcessoMetodoOuPropriedade(entidadeChamada: AcessoMetodoOuPropriedade): string;
     protected logicaComumInferenciaTiposVariaveisEConstantes(inicializador: Construto, tipo: string): string;
     protected resolverValorConstruto(construto: Construto): string;
     protected resolverInformacaoElementoSintaticoDeDicionario(construto: Construto): ElementoMontaoTipos;
@@ -233,6 +237,12 @@ export declare class AvaliadorSintatico extends AvaliadorSintaticoBase implement
     protected funcao(tipo: string): Promise<FuncaoDeclaracao>;
     protected logicaComumParametros(): Promise<ParametroInterface[]>;
     corpoDaFuncao(tipo: string): Promise<FuncaoConstruto>;
+    /**
+     * 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).
+     */
+    declaracaoDeInterface(): Promise<InterfaceDeclaracao>;
     declaracaoDeClasse(): Promise<Classe>;
     /**
      * Declarações fora de bloco precisam ser verificadas primeiro por

package/avaliador-sintatico/avaliador-sintatico.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"avaliador-sintatico.d.ts","sourceRoot":"","sources":["../../fontes/avaliador-sintatico/avaliador-sintatico.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"avaliador-sintatico.d.ts","sourceRoot":"","sources":["../../fontes/avaliador-sintatico/avaliador-sintatico.ts"],"names":[],"mappings":"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"}

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();
@@ -1540,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;
@@ -1565,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;
@@ -1899,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)) {
@@ -1908,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;
@@ -1962,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) {
@@ -2024,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();
@@ -2202,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)) {
@@ -2218,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 = [];