@designliquido/delegua 1.9.0 → 1.10.0

package/avaliador-sintatico/avaliador-sintatico.js

@@ -436,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);
@@ -620,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:
@@ -648,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 [];
@@ -1984,10 +2033,10 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         const propriedades = [];
         /**
          * 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 { }`.
+         * Suporta blocos de contexto aninhados: `estático { }`, `abstrato { }`, `privado { }`, `protegido { }`, `publico { }`.
          */
-        const compreenderMembros = async (acessoPadrao, ehEstaticoPadrao) => {
-            var _a, _b;
+        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 ||
@@ -2009,57 +2058,36 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 // 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)
+                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' :
-                        tipoAtual === delegua_2.default.PROTEGIDO ? 'protegido' : 'publico';
+                    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);
+                    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);
+                    await compreenderMembros(acessoPadrao, true, ehAbstratoPadrao);
                     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';
+                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();
@@ -2103,12 +2131,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             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;
-                        }
+                        const ehAbstrato = ehAbstratoPadrao;
                         // Tipo de retorno opcional (igual a corpoDaFuncao())
                         let tipoRetorno = 'qualquer';
                         let definicaoExplicitaDeTipo = false;
@@ -2152,8 +2175,6 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             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;
@@ -2280,6 +2301,78 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
         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:
@@ -2317,6 +2410,9 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
             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) {