@designliquido/delegua 1.8.1 → 1.10.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();
@@ -435,55 +436,61 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
                 if (construto.constructor === construtos_1.AcessoMetodoOuPropriedade) {
                     const construtoTipado = construto;
-                    switch (construtoTipado.tipo) {
-                        case delegua_1.default.DICIONARIO:
-                        case delegua_1.default.DICIONÁRIO:
-                            if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
-                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
-                            }
-                            const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
-                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
-                            break;
-                        case delegua_1.default.INTEIRO:
-                        case delegua_1.default.NUMERO:
-                        case delegua_1.default.NÚMERO:
-                            if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
-                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
-                            }
-                            const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
-                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
-                            break;
-                        case delegua_1.default.TEXTO:
-                            if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
-                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
-                            }
-                            const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
-                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
-                            break;
-                        case delegua_1.default.VETOR:
-                        case delegua_1.default.VETOR_NUMERO:
-                        case delegua_1.default.VETOR_NÚMERO:
-                        case delegua_1.default.VETOR_TEXTO:
-                            if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
-                                throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
-                            }
-                            const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
-                            construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
-                            break;
-                        default:
-                            if (construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
-                                const tipoCorrespondente = this.tiposDefinidosEmCodigo[construtoTipado.tipo];
-                                const possivelMetodo = tipoCorrespondente.metodos.filter((m) => m.simbolo.lexema === construtoTipado.simbolo.lexema);
-                                if (possivelMetodo.length > 0) {
-                                    construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelMetodo[0].tipo);
-                                    break;
+                    const acessoMetodoConhecido = this.resolverAcessoMetodoConhecido(construtoTipado);
+                    if (acessoMetodoConhecido) {
+                        construto = acessoMetodoConhecido;
+                    }
+                    else {
+                        switch (construtoTipado.tipo) {
+                            case delegua_1.default.DICIONARIO:
+                            case delegua_1.default.DICIONÁRIO:
+                                if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
+                                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
                                 }
-                                const possivelPropriedade = tipoCorrespondente.propriedades.filter((p) => p.nome.lexema === construtoTipado.simbolo.lexema);
-                                if (possivelPropriedade.length > 0) {
-                                    construto = new construtos_1.AcessoPropriedade(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelPropriedade[0].tipo);
-                                    break;
+                                const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
+                                construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
+                                break;
+                            case delegua_1.default.INTEIRO:
+                            case delegua_1.default.NUMERO:
+                            case delegua_1.default.NÚMERO:
+                                if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
+                                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
                                 }
-                            }
+                                const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
+                                construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
+                                break;
+                            case delegua_1.default.TEXTO:
+                                if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
+                                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
+                                }
+                                const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
+                                construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
+                                break;
+                            case delegua_1.default.VETOR:
+                            case delegua_1.default.VETOR_NUMERO:
+                            case delegua_1.default.VETOR_NÚMERO:
+                            case delegua_1.default.VETOR_TEXTO:
+                                if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
+                                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
+                                }
+                                const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
+                                construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
+                                break;
+                            default:
+                                if (construtoTipado.tipo in this.tiposDefinidosEmCodigo) {
+                                    const tipoCorrespondente = this.tiposDefinidosEmCodigo[construtoTipado.tipo];
+                                    const possivelMetodo = tipoCorrespondente.metodos.filter((m) => m.simbolo.lexema === construtoTipado.simbolo.lexema);
+                                    if (possivelMetodo.length > 0) {
+                                        construto = new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelMetodo[0].tipo);
+                                        break;
+                                    }
+                                    const possivelPropriedade = tipoCorrespondente.propriedades.filter((p) => p.nome.lexema === construtoTipado.simbolo.lexema);
+                                    if (possivelPropriedade.length > 0) {
+                                        construto = new construtos_1.AcessoPropriedade(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, possivelPropriedade[0].tipo);
+                                        break;
+                                    }
+                                }
+                        }
                     }
                 }
                 return new construtos_1.TipoDe(this.hashArquivo, simboloAtual, construto);
@@ -619,22 +626,26 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
      */
     resolverEntidadeChamadaAcessoMetodoOuPropriedade(entidadeChamadaResolvida) {
         const construtoTipado = entidadeChamadaResolvida;
+        const acessoMetodoConhecido = this.resolverAcessoMetodoConhecido(construtoTipado);
+        if (acessoMetodoConhecido) {
+            return acessoMetodoConhecido;
+        }
         switch (entidadeChamadaResolvida.tipo) {
             case delegua_1.default.DICIONARIO:
             case delegua_1.default.DICIONÁRIO:
-                if (!(construtoTipado.simbolo.lexema in primitivas_dicionario_1.default)) {
-                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de dicionário.`);
+                if (construtoTipado.simbolo.lexema in primitivas_dicionario_1.default) {
+                    const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
+                    return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
                 }
-                const primitivaDicionarioSelecionada = primitivas_dicionario_1.default[construtoTipado.simbolo.lexema];
-                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaDicionarioSelecionada.tipoRetorno);
+                break;
             case delegua_1.default.INTEIRO:
             case delegua_1.default.NUMERO:
             case delegua_1.default.NÚMERO:
-                if (!(construtoTipado.simbolo.lexema in primitivas_numero_1.default)) {
-                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de número.`);
+                if (construtoTipado.simbolo.lexema in primitivas_numero_1.default) {
+                    const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
+                    return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
                 }
-                const primitivaNumeroSelecionada = primitivas_numero_1.default[construtoTipado.simbolo.lexema];
-                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaNumeroSelecionada.tipoRetorno);
+                break;
             case delegua_1.default.MODULO:
             case delegua_1.default.MÓDULO:
                 // Há dois casos para resolução de módulo:
@@ -647,23 +658,62 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
                 return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema);
             case delegua_1.default.TEXTO:
-                if (!(construtoTipado.simbolo.lexema in primitivas_texto_1.default)) {
-                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de texto.`);
+                if (construtoTipado.simbolo.lexema in primitivas_texto_1.default) {
+                    const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
+                    return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
                 }
-                const primitivaTextoSelecionada = primitivas_texto_1.default[construtoTipado.simbolo.lexema];
-                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaTextoSelecionada.tipoRetorno);
+                break;
             case delegua_1.default.VETOR:
             case delegua_1.default.VETOR_NUMERO:
             case delegua_1.default.VETOR_NÚMERO:
             case delegua_1.default.VETOR_TEXTO:
-                if (!(construtoTipado.simbolo.lexema in primitivas_vetor_1.default)) {
-                    throw this.erro(construtoTipado.simbolo, `${construtoTipado.simbolo.lexema} não é uma primitiva de vetor.`);
+                if (construtoTipado.simbolo.lexema in primitivas_vetor_1.default) {
+                    const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
+                    return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
                 }
-                const primitivaVetorSelecionada = primitivas_vetor_1.default[construtoTipado.simbolo.lexema];
-                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, primitivaVetorSelecionada.tipoRetorno);
+                break;
         }
         return entidadeChamadaResolvida;
     }
+    obterTiposParaConsultaPrimitiva(tipo) {
+        switch (tipo) {
+            case delegua_1.default.DICIONARIO:
+            case delegua_1.default.DICIONÁRIO:
+                return ['dicionário'];
+            case delegua_1.default.INTEIRO:
+            case delegua_1.default.NUMERO:
+            case delegua_1.default.NÚMERO:
+            case delegua_1.default.REAL:
+                return ['número'];
+            case delegua_1.default.TEXTO:
+                return ['texto'];
+            case delegua_1.default.VETOR:
+            case delegua_1.default.VETOR_INTEIRO:
+            case delegua_1.default.VETOR_LOGICO:
+            case delegua_1.default.VETOR_LÓGICO:
+            case delegua_1.default.VETOR_NUMERO:
+            case delegua_1.default.VETOR_NÚMERO:
+            case delegua_1.default.VETOR_QUALQUER:
+            case delegua_1.default.VETOR_TEXTO:
+                return ['vetor'];
+            default:
+                return [tipo];
+        }
+    }
+    resolverAcessoMetodoConhecido(construtoTipado) {
+        const tiposParaConsulta = this.obterTiposParaConsultaPrimitiva(construtoTipado.tipo);
+        for (const tipoConsulta of tiposParaConsulta) {
+            const primitivasPorTipo = this.primitivasConhecidas[tipoConsulta];
+            if (!primitivasPorTipo) {
+                continue;
+            }
+            const informacoesPrimitiva = primitivasPorTipo[construtoTipado.simbolo.lexema];
+            if (informacoesPrimitiva) {
+                return new construtos_1.AcessoMetodo(construtoTipado.hashArquivo, construtoTipado.objeto, construtoTipado.simbolo.lexema, informacoesPrimitiva.tipo);
+            }
+        }
+        return null;
+    }
     validarArgumentosEntidadeChamada(argumentosEntidadeChamada, argumentosUtilizados) {
         if (argumentosEntidadeChamada.length === 0) {
             return [];
@@ -1540,6 +1590,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 +1650,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 +1951,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,43 +2020,359 @@ 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 { }`, `abstrato { }`, `privado { }`, `protegido { }`, `publico { }`.
+         */
+        const compreenderMembros = async (acessoPadrao, ehEstaticoPadrao, ehAbstratoPadrao = false) => {
+            var _a;
+            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].includes(tipoAtual)
+                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoEstatico = tipoAtual === delegua_2.default.ESTATICO
+                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                const ehBlocoAbstrato = tipoAtual === delegua_2.default.ABSTRATO
+                    && tipoProximo === delegua_2.default.CHAVE_ESQUERDA;
+                if (ehBlocoAcesso) {
+                    const novoAcesso = tipoAtual === delegua_2.default.PRIVADO ? 'privado' : 'protegido';
+                    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, ehAbstratoPadrao);
+                    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, ehAbstratoPadrao);
+                    this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' para fechar bloco estático.");
+                    continue;
+                }
+                if (ehBlocoAbstrato) {
+                    this.avancarEDevolverAnterior(); // consume 'abstrato'
+                    this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após 'abstrato'.");
+                    await compreenderMembros(acessoPadrao, ehEstaticoPadrao, true);
+                    this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' para fechar bloco abstrato.");
+                    continue;
+                }
+                const modificadorAcesso = acessoPadrao;
+                const ehEstatico = ehEstaticoPadrao;
+                // 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.");
+                        const ehAbstrato = ehAbstratoPadrao;
+                        // 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.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;
     }
+    /**
+     * Analisa uma declaração de extensão:
+     * `extensão [global] de <tipo> { <métodos> }`
+     */
+    async declaracaoDeExtensao() {
+        let ehGlobal = false;
+        if (this.simbolos[this.atual].tipo === delegua_2.default.IDENTIFICADOR &&
+            this.simbolos[this.atual].lexema === 'global') {
+            this.avancarEDevolverAnterior();
+            ehGlobal = true;
+        }
+        this.consumir(delegua_2.default.DE, "Esperado 'de' após 'extensão'.");
+        const simboloTipo = this.consumir(delegua_2.default.IDENTIFICADOR, "Esperado nome do tipo após 'de'.");
+        this.consumir(delegua_2.default.CHAVE_ESQUERDA, "Esperado '{' após o nome do tipo.");
+        const metodos = [];
+        const nomeTipo = simboloTipo.lexema;
+        if (!this.primitivasConhecidas[nomeTipo]) {
+            this.primitivasConhecidas[nomeTipo] = {};
+        }
+        while (!this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_DIREITA) && !this.estaNoFinal()) {
+            // Pular comentários dentro do corpo da extensão.
+            if (this.simbolos[this.atual].tipo === delegua_2.default.COMENTARIO ||
+                this.simbolos[this.atual].tipo === delegua_2.default.LINHA_COMENTARIO) {
+                this.avancarEDevolverAnterior();
+                continue;
+            }
+            // Apenas métodos são suportados em extensões.
+            const proximoSimbolo = this.simbolos[this.atual + 1];
+            if ((proximoSimbolo === null || proximoSimbolo === void 0 ? void 0 : proximoSimbolo.tipo) !== delegua_2.default.PARENTESE_ESQUERDO) {
+                throw this.erro(this.simbolos[this.atual], 'Esperado declaração de método na extensão.');
+            }
+            const nomeMetodo = this.avancarEDevolverAnterior();
+            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.");
+            let tipoRetorno = 'qualquer';
+            let definicaoExplicitaDeTipo = false;
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.DOIS_PONTOS)) {
+                tipoRetorno = this.verificarDefinicaoTipoAtual();
+                this.avancarEDevolverAnterior();
+                definicaoExplicitaDeTipo = true;
+            }
+            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);
+            metodos.push(metodo);
+            const argumentos = params.map((parametro) => new informacao_elemento_sintatico_1.InformacaoElementoSintatico(parametro.nome.lexema, parametro.tipoDado || 'qualquer', parametro.valorPadrao === undefined));
+            this.primitivasConhecidas[nomeTipo][nomeMetodo.lexema] = new informacao_elemento_sintatico_1.InformacaoElementoSintatico(nomeMetodo.lexema, tipoRetorno, true, argumentos);
+        }
+        this.consumir(delegua_2.default.CHAVE_DIREITA, "Esperado '}' ao final da extensão.");
+        return new declaracoes_1.Extensao(simboloTipo, metodos, ehGlobal, this.hashArquivo);
+    }
     /**
      * Declarações fora de bloco precisam ser verificadas primeiro por
      * uma série de motivos, como, por exemplo:
@@ -1962,15 +2390,29 @@ 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();
+            }
+            if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.EXTENSAO)) {
+                return await this.declaracaoDeExtensao();
+            }
             return await this.resolverDeclaracao();
         }
         catch (erro) {
@@ -2024,6 +2466,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 +2658,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 +2676,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 = [];