@designliquido/delegua 1.15.5 → 1.16.0

package/umd/delegua.js

@@ -5,16 +5,25 @@ exports.AnalisadorSemanticoBase = void 0;
 const construtos_1 = require("../construtos");
 const declaracoes_1 = require("../declaracoes");
 const interfaces_1 = require("../interfaces");
+const quebras_1 = require("../quebras");
+const gerenciador_escopos_1 = require("./gerenciador-escopos");
 /**
  * Essa classe só existe para eliminar redundância entre todos os analisadores
  * semânticos. Por padrão, quando um método não é implementado, ao invés de dar erro,
  * simplesmente passa por ele (`return Promise.resolve()`).
  */
 class AnalisadorSemanticoBase {
+    constructor() {
+        this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
+        this.diagnosticos = [];
+    }
     diagnosticoJaExiste(simbolo, mensagem) {
-        return this.diagnosticos.some((d) => d.linha === simbolo.linha &&
-            d.mensagem === mensagem &&
-            d.simbolo.lexema === simbolo.lexema);
+        return this.diagnosticos.some((d) => {
+            var _a;
+            return d.linha === simbolo.linha &&
+                d.mensagem === mensagem &&
+                ((_a = d.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === simbolo.lexema;
+        });
     }
     erro(simbolo, mensagem) {
         if (this.diagnosticoJaExiste(simbolo, mensagem)) {
@@ -156,6 +165,10 @@ class AnalisadorSemanticoBase {
      * Marca as variáveis usadas em uma expressão.
      */
     marcarVariaveisUsadasEmExpressao(expressao) {
+        if (expressao instanceof declaracoes_1.Expressao) {
+            this.marcarVariaveisUsadasEmExpressao(expressao.expressao);
+            return;
+        }
         if (expressao instanceof construtos_1.Variavel) {
             this.gerenciadorEscopos.marcarComoUsada(expressao.simbolo.lexema);
             return;
@@ -202,8 +215,18 @@ class AnalisadorSemanticoBase {
             }
             return;
         }
+        if (expressao instanceof construtos_1.Literal && typeof expressao.valor === 'string') {
+            this.verificarInterpolacaoTexto(expressao.valor, expressao);
+            return;
+        }
         // TODO: Adicionar outros tipos de expressões conforme necessário.
     }
+    /**
+     * Stub para ser sobrescrito por subclasses que implementam análise de interpolações.
+     */
+    verificarInterpolacaoTexto(_texto, _literal) {
+        // implementado nas subclasses
+    }
     /**
      * Analisa se todos os caminhos retornam
      * @returns true se todos os caminhos retornam, false caso contrário
@@ -390,7 +413,7 @@ class AnalisadorSemanticoBase {
         return Promise.resolve();
     }
     visitarExpressaoContinua(declaracao) {
-        return null;
+        return new quebras_1.ContinuarQuebra();
     }
     visitarExpressaoDeChamada(expressao) {
         return Promise.resolve();
@@ -408,7 +431,7 @@ class AnalisadorSemanticoBase {
         return Promise.resolve();
     }
     visitarExpressaoExpressaoRegular(expressao) {
-        return;
+        return Promise.resolve(new RegExp(''));
     }
     visitarDeclaracaoEscrevaMesmaLinha(declaracao) {
         return Promise.resolve();
@@ -435,13 +458,13 @@ class AnalisadorSemanticoBase {
         return Promise.resolve();
     }
     visitarExpressaoRetornar(declaracao) {
-        return;
+        return Promise.resolve(new quebras_1.RetornoQuebra(null));
     }
     visitarExpressaoSuper(expressao) {
         return Promise.resolve();
     }
     visitarExpressaoSustar(declaracao) {
-        return null;
+        return new quebras_1.SustarQuebra();
     }
     visitarExpressaoTupla(expressao) {
         return Promise.resolve();
@@ -458,7 +481,7 @@ class AnalisadorSemanticoBase {
 }
 exports.AnalisadorSemanticoBase = AnalisadorSemanticoBase;
 
-},{"../construtos":62,"../declaracoes":110,"../interfaces":149}],2:[function(require,module,exports){
+},{"../construtos":62,"../declaracoes":110,"../interfaces":149,"../quebras":216,"./gerenciador-escopos":5}],2:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnalisadorSemantico = void 0;
@@ -466,6 +489,8 @@ const construtos_1 = require("../construtos");
 const declaracoes_1 = require("../declaracoes");
 const erros_1 = require("../interfaces/erros");
 const comum_1 = require("../avaliador-sintatico/comum");
+const micro_avaliador_sintatico_1 = require("../avaliador-sintatico/micro-avaliador-sintatico");
+const micro_lexador_1 = require("../lexador/micro-lexador");
 const analisador_semantico_base_1 = require("./analisador-semantico-base");
 const gerenciador_escopos_1 = require("./gerenciador-escopos");
 const pilha_variaveis_1 = require("./pilha-variaveis");
@@ -475,15 +500,21 @@ const pilha_variaveis_1 = require("./pilha-variaveis");
 class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemanticoBase {
     constructor() {
         super();
+        this.microLexador = new micro_lexador_1.MicroLexador();
+        this.microAvaliadorSintatico = new micro_avaliador_sintatico_1.MicroAvaliadorSintatico();
         this.pilhaVariaveis = new pilha_variaveis_1.PilhaVariaveis();
         this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
         this.funcoes = {};
-        this.classesDeclararadas = new Set();
+        this.classesDeclaradas = new Set();
         this.classesRegistradas = new Map();
+        this.classesExternasConhecidas = new Set();
         this.classeAtualEmAnalise = null;
         this.atual = 0;
         this.diagnosticos = [];
     }
+    definirClassesExternasConhecidas(classesExternasConhecidas) {
+        this.classesExternasConhecidas = new Set(classesExternasConhecidas);
+    }
     verificarTipoAtribuido(declaracao) {
         if (declaracao.tipo) {
             if (['vetor', 'qualquer[]', 'inteiro[]', 'texto[]'].includes(declaracao.tipo)) {
@@ -668,6 +699,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         // Marca como inicializada após atribuição
         this.gerenciadorEscopos.marcarComoInicializada(simboloAlvo.lexema, expressao.valor);
+        // Marca variáveis usadas no valor atribuído (ex: idade = ano - inteiro(leia(...))).
+        this.marcarVariaveisUsadasEmExpressao(expressao.valor);
         // Atualiza tipo se a variável não foi tipada explicitamente
         if (variavel.tipo === 'qualquer') {
             const tipoInferido = this.obterTipoExpressao(expressao.valor);
@@ -742,10 +775,34 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 this.variaveis[simboloAlvo.lexema].valor = expressao.valor;
             }
         } */
+        return Promise.resolve();
     }
     async visitarDeclaracaoDeExpressao(declaracao) {
         return await declaracao.expressao.aceitar(this);
     }
+    async visitarExpressaoBloco(declaracao) {
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            for (const declaracaoBloco of declaracao.declaracoes) {
+                await declaracaoBloco.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
+        return Promise.resolve();
+    }
+    visitarExpressaoAcessoIndiceVariavel(expressao) {
+        this.marcarVariaveisUsadasEmExpressao(expressao.entidadeChamada);
+        this.marcarVariaveisUsadasEmExpressao(expressao.indice);
+        return Promise.resolve();
+    }
+    visitarExpressaoAtribuicaoPorIndice(expressao) {
+        this.marcarVariaveisUsadasEmExpressao(expressao.objeto);
+        this.marcarVariaveisUsadasEmExpressao(expressao.indice);
+        this.marcarVariaveisUsadasEmExpressao(expressao.valor);
+        return Promise.resolve();
+    }
     visitarDeclaracaoAjuda(declaracao) {
         if (declaracao.elemento) {
             this.marcarVariaveisUsadasEmExpressao(declaracao.elemento);
@@ -760,7 +817,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     visitarDeclaracaoEscolha(declaracao) {
         const identificadorOuLiteral = declaracao.identificadorOuLiteral;
-        const tipo = identificadorOuLiteral.tipo;
+        const tipo = identificadorOuLiteral.tipo || 'qualquer';
         for (let caminho of declaracao.caminhos) {
             for (let condicao of caminho.condicoes) {
                 switch (condicao.constructor) {
@@ -791,8 +848,16 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
         return Promise.resolve();
     }
-    visitarDeclaracaoEnquanto(declaracao) {
-        return this.verificarCondicao(declaracao.condicao);
+    async visitarDeclaracaoEnquanto(declaracao) {
+        // Marca variáveis usadas na condição.
+        this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
+        // Verifica a condição (incluindo validações de tipo para operadores lógicos).
+        await this.verificarCondicao(declaracao.condicao);
+        // Visita corpo para que usos/atribuições dentro do laço sejam analisados.
+        for (const declaracaoCorpo of declaracao.corpo.declaracoes) {
+            await declaracaoCorpo.aceitar(this);
+        }
+        return Promise.resolve();
     }
     visitarDeclaracaoFazer(declaracao) {
         // Marca variáveis usadas na condição
@@ -801,25 +866,31 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         return this.verificarCondicao(declaracao.condicaoEnquanto);
     }
     async visitarDeclaracaoPara(declaracao) {
-        if (Array.isArray(declaracao.inicializador)) {
-            for (const inicializador of declaracao.inicializador) {
-                await inicializador.aceitar(this);
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            if (Array.isArray(declaracao.inicializador)) {
+                for (const inicializador of declaracao.inicializador) {
+                    await inicializador.aceitar(this);
+                }
+            }
+            else if (declaracao.inicializador) {
+                await declaracao.inicializador.aceitar(this);
+            }
+            // O laço precisa visitar condição/incremento/corpo para registrar usos de variáveis.
+            if (declaracao.condicao) {
+                this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
+                await this.verificarCondicao(declaracao.condicao);
+            }
+            if (declaracao.incrementar) {
+                this.marcarVariaveisUsadasEmExpressao(declaracao.incrementar);
+                this.verificarExpressao(declaracao.incrementar);
+            }
+            for (const declaracaoCorpo of declaracao.corpo.declaracoes) {
+                await declaracaoCorpo.aceitar(this);
             }
         }
-        else if (declaracao.inicializador) {
-            await declaracao.inicializador.aceitar(this);
-        }
-        // O laço precisa visitar condição/incremento/corpo para registrar usos de variáveis.
-        if (declaracao.condicao) {
-            this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
-            await this.verificarCondicao(declaracao.condicao);
-        }
-        if (declaracao.incrementar) {
-            this.marcarVariaveisUsadasEmExpressao(declaracao.incrementar);
-            this.verificarExpressao(declaracao.incrementar);
-        }
-        for (const declaracaoCorpo of declaracao.corpo.declaracoes) {
-            await declaracaoCorpo.aceitar(this);
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
         }
         return Promise.resolve();
     }
@@ -828,11 +899,25 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.marcarVariaveisUsadasEmExpressao(declaracao.vetorOuDicionario);
         return Promise.resolve();
     }
-    visitarDeclaracaoSe(declaracao) {
+    async visitarDeclaracaoSe(declaracao) {
         // Marca variáveis usadas na condição
         this.marcarVariaveisUsadasEmExpressao(declaracao.condicao);
         // Verifica a condição (incluindo validação de tipos para operadores lógicos)
-        return this.verificarCondicao(declaracao.condicao);
+        await this.verificarCondicao(declaracao.condicao);
+        if (declaracao.caminhoEntao) {
+            await declaracao.caminhoEntao.aceitar(this);
+        }
+        if (declaracao.caminhosSeSenao && declaracao.caminhosSeSenao.length > 0) {
+            for (const caminhoSeSenao of declaracao.caminhosSeSenao) {
+                this.marcarVariaveisUsadasEmExpressao(caminhoSeSenao.condicao);
+                await this.verificarCondicao(caminhoSeSenao.condicao);
+                await caminhoSeSenao.caminho.aceitar(this);
+            }
+        }
+        if (declaracao.caminhoSenao) {
+            await declaracao.caminhoSenao.aceitar(this);
+        }
+        return Promise.resolve();
     }
     /**
      * Verifica uma expressão recursivamente, incluindo operações binárias
@@ -979,6 +1064,9 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         const tipoEsquerda = this.obterTipoExpressao(binario.esquerda);
         const tipoDireita = this.obterTipoExpressao(binario.direita);
         const tiposNumericos = ['inteiro', 'número', 'real'];
+        if (!tipoEsquerda || !tipoDireita) {
+            return;
+        }
         if ((tipoEsquerda === 'texto' && tiposNumericos.includes(tipoDireita)) ||
             (tiposNumericos.includes(tipoEsquerda) && tipoDireita === 'texto')) {
             this.aviso(binario.operador, `Esta comparação ocorre entre tipos ${tipoEsquerda} e ${tipoDireita}, e o resultado pode não ser o desejado.`);
@@ -1133,40 +1221,24 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         }
     }
     /**
-     * Verifica interpolações de texto e marca variáveis como usadas
+     * Verifica interpolações de texto e marca variáveis como usadas,
+     * compreendendo cada expressão interpolada com MicroLexador e MicroAvaliadorSintatico.
      */
     verificarInterpolacaoTexto(texto, literal) {
-        // Regex para encontrar ${identificador}
-        const regexInterpolacao = /\$\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g;
+        const regexInterpolacao = /\$\{(.*?)\}/g;
         let match;
         while ((match = regexInterpolacao.exec(texto)) !== null) {
-            const nomeVariavel = match[1];
-            // Verifica se a variável existe
-            const variavel = this.gerenciadorEscopos.buscar(nomeVariavel);
-            const funcao = this.funcoes[nomeVariavel];
-            if (!variavel && !funcao) {
-                this.erro({
-                    lexema: nomeVariavel,
-                    tipo: 'IDENTIFICADOR',
-                    linha: literal.linha,
-                    hashArquivo: literal.hashArquivo,
-                    literal: null,
-                }, `Variável ou função '${nomeVariavel}' usada em interpolação não existe.`);
-            }
-            else if (variavel) {
-                // Marca como usada
-                this.gerenciadorEscopos.marcarComoUsada(nomeVariavel);
-                // Verifica se foi inicializada
-                if (!variavel.inicializada) {
-                    this.aviso({
-                        lexema: nomeVariavel,
-                        tipo: 'IDENTIFICADOR',
-                        linha: literal.linha,
-                        hashArquivo: literal.hashArquivo,
-                        literal: null,
-                    }, `Variável '${nomeVariavel}' usada em interpolação pode não ter sido inicializada.`);
+            const expressaoInterpolacao = match[1].trim();
+            try {
+                const retornoMicroLexador = this.microLexador.mapear(expressaoInterpolacao);
+                const retornoMicro = this.microAvaliadorSintatico.analisar(retornoMicroLexador, literal.linha);
+                for (const construto of retornoMicro.declaracoes) {
+                    this.marcarVariaveisUsadasEmExpressao(construto);
                 }
             }
+            catch (_) {
+                // Erros de sintaxe na interpolação são tratados em tempo de execução
+            }
         }
     }
     async visitarDeclaracaoEscreva(declaracao) {
@@ -1281,7 +1353,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         // Inferir tipo do inicializador se não foi especificado explicitamente
         let tipoInferido = declaracao.tipo;
         if (!tipoInferido && declaracao.inicializador) {
-            tipoInferido = this.obterTipoExpressao(declaracao.inicializador);
+            const tipoInicializador = this.obterTipoExpressao(declaracao.inicializador);
+            if (tipoInicializador) {
+                tipoInferido = tipoInicializador;
+            }
         }
         // Sugestão de tipo melhor quando 'qualquer' é usado explicitamente
         if (declaracao.tipoExplicito &&
@@ -1295,8 +1370,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                         textoOriginal: 'qualquer',
                         textoSubstituto: tipoMelhor,
                         linha: declaracao.simbolo.linha,
-                        colunaInicio: declaracao.simbolo.colunaInicio,
-                        colunaFim: declaracao.simbolo.colunaFim,
+                        colunaInicio: declaracao.simbolo.colunaInicio || 0,
+                        colunaFim: declaracao.simbolo.colunaFim || 0,
                     },
                 ]);
             }
@@ -1331,7 +1406,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         return Promise.resolve();
     }
     visitarExpressaoRetornar(declaracao) {
-        return Promise.resolve(null);
+        return Promise.resolve(undefined);
     }
     visitarExpressaoDeVariavel(expressao) {
         if (expressao instanceof construtos_1.Variavel) {
@@ -1415,23 +1490,29 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
             if (nomeSuperclasse === declaracao.simbolo.lexema) {
                 this.erro(superClasseVariavel.simbolo, `A classe '${declaracao.simbolo.lexema}' não pode herdar de si mesma.`);
             }
-            else if (!this.classesDeclararadas.has(nomeSuperclasse)) {
+            else if (!this.classesDeclaradas.has(nomeSuperclasse) && !this.classesExternasConhecidas.has(nomeSuperclasse)) {
                 this.erro(superClasseVariavel.simbolo, `Superclasse '${nomeSuperclasse}' não foi declarada.`);
             }
         }
-        this.classesDeclararadas.add(declaracao.simbolo.lexema);
+        this.classesDeclaradas.add(declaracao.simbolo.lexema);
         this.classesRegistradas.set(declaracao.simbolo.lexema, declaracao);
-        // Visita corpos dos métodos com contexto de classe ativo
+        // Visita corpos dos métodos com contexto de classe ativo.
+        // Métodos abstratos implícitos e métodos de classes estrangeiras têm corpo vazio —
+        // não há declarações para visitar.
         const classeAnterior = this.classeAtualEmAnalise;
         this.classeAtualEmAnalise = declaracao;
-        for (const metodo of declaracao.metodos) {
-            for (const stmt of metodo.funcao.corpo) {
-                await stmt.aceitar(this);
+        if (!declaracao.estrangeira) {
+            for (const metodo of declaracao.metodos) {
+                if (metodo.abstrato)
+                    continue;
+                for (const stmt of metodo.funcao.corpo) {
+                    await stmt.aceitar(this);
+                }
             }
         }
         this.classeAtualEmAnalise = classeAnterior;
     }
-    visitarDeclaracaoDefinicaoFuncao(declaracao) {
+    async visitarDeclaracaoDefinicaoFuncao(declaracao) {
         var _a;
         if (declaracao.funcao.tipo === undefined) {
             this.erro(declaracao.simbolo, `Declaração de retorno da função é inválido.`);
@@ -1447,7 +1528,10 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                     this.erro(declaracao.simbolo, `Função '${declaracao.simbolo.lexema}' deve retornar '${tipoRetornoFuncao}' em todos os caminhos de execução.`);
                 }
             }
-            const retornos = declaracao.funcao.corpo.flatMap((c) => (0, comum_1.buscarRetornos)(c));
+            let retornos = [];
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                retornos = retornos.concat((0, comum_1.buscarRetornos)(declaracaoCorpo));
+            }
             // Filtra retornos com tipo 'qualquer' (não determinado em tempo de análise sintática)
             const retornosComTipoIndeterminado = retornos.filter((retorno) => retorno.valor !== null &&
                 retorno.valor !== undefined &&
@@ -1458,7 +1542,8 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
                 declaracao.funcao.tipoExplicito &&
                 retornosComTipoIndeterminado.length > 0) {
                 const retornoComValor = retornosComTipoIndeterminado[0];
-                const tipoInferido = this.obterTipoExpressao(retornoComValor.valor);
+                const valorRetorno = retornoComValor.valor;
+                const tipoInferido = this.obterTipoExpressao(valorRetorno);
                 if (tipoInferido && tipoInferido !== 'qualquer') {
                     this.erro(declaracao.simbolo, `A função não pode ter nenhum tipo de retorno. Tipo inferido do retorno: '${tipoInferido}'.`);
                 }
@@ -1486,14 +1571,38 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
         this.funcoes[declaracao.simbolo.lexema] = {
             valor: declaracao.funcao,
         };
+        this.gerenciadorEscopos.empilharEscopo();
+        try {
+            for (const parametro of declaracao.funcao.parametros) {
+                this.gerenciadorEscopos.declarar(parametro.nome.lexema, {
+                    nome: parametro.nome.lexema,
+                    tipo: parametro.tipoDado || 'qualquer',
+                    imutavel: false,
+                    valor: undefined,
+                    inicializada: true,
+                    usada: false,
+                    hashArquivo: parametro.nome.hashArquivo,
+                    linha: parametro.nome.linha,
+                });
+            }
+            for (const declaracaoCorpo of declaracao.funcao.corpo) {
+                await declaracaoCorpo.aceitar(this);
+            }
+        }
+        finally {
+            this.gerenciadorEscopos.desempilharEscopo();
+        }
         return Promise.resolve();
     }
     verificarVariaveisNaoUsadas() {
         const naoUsadas = this.gerenciadorEscopos.obterVariaveisNaoUsadas();
         for (let variavel of naoUsadas) {
             // Verifica se já existe um erro associado à variável.
-            const temErro = this.diagnosticos.some((d) => d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
-                d.simbolo.lexema === variavel.nome);
+            const temErro = this.diagnosticos.some((d) => {
+                var _a;
+                return d.severidade === erros_1.DiagnosticoSeveridade.ERRO &&
+                    ((_a = d.simbolo) === null || _a === void 0 ? void 0 : _a.lexema) === variavel.nome;
+            });
             // Se a variável já tem um erro associado, não emitir aviso de não usada.
             if (temErro) {
                 continue;
@@ -1508,7 +1617,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
     }
     async analisar(declaracoes) {
         this.gerenciadorEscopos = new gerenciador_escopos_1.GerenciadorEscopos();
-        this.classesDeclararadas = new Set();
+        this.classesDeclaradas = new Set();
         this.classesRegistradas = new Map();
         this.classeAtualEmAnalise = null;
         this.atual = 0;
@@ -1531,7 +1640,7 @@ class AnalisadorSemantico extends analisador_semantico_base_1.AnalisadorSemantic
 }
 exports.AnalisadorSemantico = AnalisadorSemantico;
 
-},{"../avaliador-sintatico/comum":11,"../construtos":62,"../declaracoes":110,"../interfaces/erros":146,"./analisador-semantico-base":1,"./gerenciador-escopos":5,"./pilha-variaveis":7}],3:[function(require,module,exports){
+},{"../avaliador-sintatico/comum":11,"../avaliador-sintatico/micro-avaliador-sintatico":24,"../construtos":62,"../declaracoes":110,"../interfaces/erros":146,"../lexador/micro-lexador":213,"./analisador-semantico-base":1,"./gerenciador-escopos":5,"./pilha-variaveis":7}],3:[function(require,module,exports){
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 
@@ -1690,6 +1799,13 @@ const comum_1 = __importDefault(require("../tipos-de-simbolos/comum"));
  * de tipos de símbolos comuns entre todos os dialetos.
  */
 class AvaliadorSintaticoBase {
+    constructor() {
+        this.simbolos = [];
+        this.erros = [];
+        this.hashArquivo = -1;
+        this.atual = 0;
+        this.blocos = 0;
+    }
     erro(simbolo, mensagemDeErro) {
         const excecao = new erro_avaliador_sintatico_1.ErroAvaliadorSintatico(simbolo, mensagemDeErro);
         return excecao;
@@ -1721,6 +1837,8 @@ class AvaliadorSintaticoBase {
         return this.simbolos[this.atual].tipo === tipo;
     }
     verificarTipoProximoSimbolo(tipo) {
+        if (this.atual + 1 >= this.simbolos.length)
+            return false;
         return this.simbolos[this.atual + 1].tipo === tipo;
     }
     estaNoFinal() {
@@ -1880,7 +1998,7 @@ class AvaliadorSintaticoBase {
             }
             const parametro = {};
             if (this.simbolos[this.atual].tipo === comum_1.default.MULTIPLICACAO) {
-                this.consumir(comum_1.default.MULTIPLICACAO, null);
+                this.avancarEDevolverAnterior();
                 parametro.abrangencia = 'multiplo';
             }
             else {
@@ -3957,12 +4075,15 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
     }
     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`.
+        // Modificadores opcionais no nível da classe: `abstrata`, `estrangeira` e/ou `estática`.
+        // Sintaxe: `classe abstrata NomeDaClasse`, `classe estrangeira NomeDaClasse`, etc.
         let ehAbstrata = false;
+        let ehEstrangeira = false;
         let ehEstatica = false;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ABSTRATO))
             ehAbstrata = true;
+        if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESTRANGEIRA))
+            ehEstrangeira = true;
         if (this.verificarSeSimboloAtualEIgualA(delegua_2.default.ESTATICO))
             ehEstatica = true;
         // Também permite a ordem invertida: `classe estática abstrata`
@@ -4105,7 +4226,6 @@ 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.");
-                        const ehAbstrato = ehAbstratoPadrao;
                         // Tipo de retorno opcional (igual a corpoDaFuncao())
                         let tipoRetorno = 'qualquer';
                         let definicaoExplicitaDeTipo = false;
@@ -4114,10 +4234,21 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                             this.avancarEDevolverAnterior();
                             definicaoExplicitaDeTipo = true;
                         }
+                        // Método de classe estrangeira não pode ter corpo.
+                        if (ehEstrangeira &&
+                            this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA)) {
+                            throw this.erro(this.simbolos[this.atual], "Métodos de classe estrangeira não podem ter corpo.");
+                        }
+                        // Método é abstrato quando: (a) está dentro de um bloco `abstrato {}`,
+                        // ou (b) a classe é abstrata/estrangeira e o próximo token não é `{`.
+                        const ehAbstrato = ehAbstratoPadrao ||
+                            ehEstrangeira ||
+                            (ehAbstrata &&
+                                !this.verificarTipoSimboloAtual(delegua_2.default.CHAVE_ESQUERDA));
                         if (ehAbstrato) {
-                            // Método abstrato: sem corpo
+                            // Método abstrato/estrangeiro: sem corpo
                             this.verificarSeSimboloAtualEIgualA(delegua_2.default.PONTO_E_VIRGULA);
-                            const corpoVazio = new construtos_1.FuncaoConstruto(this.hashArquivo, nomeMetodo.linha, params, [], tipoRetorno);
+                            const corpoVazio = new construtos_1.FuncaoConstruto(this.hashArquivo, nomeMetodo.linha, params, [], tipoRetorno, definicaoExplicitaDeTipo);
                             const metodoAbstrato = new declaracoes_1.FuncaoDeclaracao(nomeMetodo, corpoVazio, tipoRetorno);
                             metodoAbstrato.estatico = ehEstatico;
                             metodoAbstrato.abstrato = true;
@@ -4315,7 +4446,7 @@ class AvaliadorSintatico extends avaliador_sintatico_base_1.AvaliadorSintaticoBa
                 }
             }
         }
-        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasses, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstatica, implementaInterfaces, mesclas);
+        const definicaoClasse = new declaracoes_1.Classe(simbolo, superClasses, metodos, propriedades, pilhaDecoradoresClasse, ehAbstrata, ehEstrangeira, ehEstatica, implementaInterfaces, mesclas);
         this.tiposDefinidosEmCodigo[definicaoClasse.simbolo.lexema] = definicaoClasse;
         this.superclasseAtual = undefined;
         return definicaoClasse;
@@ -14234,7 +14365,7 @@ class Classe extends declaracao_1.Declaracao {
         var _a;
         return (_a = this.superClasses[0]) !== null && _a !== void 0 ? _a : null;
     }
-    constructor(simbolo, superClasses = [], metodos, propriedades = [], decoradores = [], abstrata = false, classeEstatica = false, implementa = [], mesclas = []) {
+    constructor(simbolo, superClasses = [], metodos, propriedades = [], decoradores = [], abstrata = false, estrangeira = false, classeEstatica = false, implementa = [], mesclas = []) {
         super(Number(simbolo.linha), simbolo.hashArquivo);
         this.simbolo = simbolo;
         this.superClasses = superClasses;
@@ -14243,6 +14374,7 @@ class Classe extends declaracao_1.Declaracao {
         this.propriedades = propriedades;
         this.decoradores = decoradores;
         this.abstrata = abstrata;
+        this.estrangeira = estrangeira;
         this.classeEstatica = classeEstatica;
         this.implementa = implementa;
     }
@@ -14499,6 +14631,9 @@ exports.Expressao = Expressao;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Extensao = void 0;
 const declaracao_1 = require("./declaracao");
+/**
+ * Declaração de Extensão de Classe.
+ */
 class Extensao extends declaracao_1.Declaracao {
     constructor(simboloTipo, metodos, ehGlobal, hashArquivo) {
         super(Number(simboloTipo.linha), hashArquivo);
@@ -15692,6 +15827,135 @@ class FormatadorDelegua {
         this.deveIndentar = true;
         this.delimitadorTexto = opcoes.delimitadorTexto || 'aspas-simples';
     }
+    visitarDeclaracaoAjuda(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}ajuda(`;
+        if (declaracao.elemento) {
+            this.formatarDeclaracaoOuConstruto(declaracao.elemento);
+        }
+        this.codigoFormatado += `)${this.quebraLinha}`;
+    }
+    visitarDeclaracaoExtensao(declaracao) {
+        const global = declaracao.ehGlobal ? 'global ' : '';
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}extensão ${global}de ${declaracao.simboloTipo.lexema} {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let metodo of declaracao.metodos) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.simbolo.lexema}`;
+            this.visitarExpressaoFuncaoConstruto(metodo.funcao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarDeclaracaoInterface(declaracao) {
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}interface ${declaracao.simbolo.lexema} {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let propriedade of declaracao.propriedades) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${propriedade.nome.lexema}: ${propriedade.tipo || 'qualquer'}${this.quebraLinha}`;
+        }
+        for (let metodo of declaracao.metodos) {
+            this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.nome.lexema}(`;
+            for (let parametro of metodo.parametros) {
+                this.codigoFormatado += `${parametro.nome.lexema}: ${parametro.tipoDado || 'qualquer'}, `;
+            }
+            if (metodo.parametros.length > 0) {
+                this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+            }
+            this.codigoFormatado += `)`;
+            if (metodo.tipoRetorno) {
+                this.codigoFormatado += `: ${metodo.tipoRetorno}`;
+            }
+            this.codigoFormatado += this.quebraLinha;
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
+    }
+    visitarExpressaoAjuda(expressao) {
+        this.codigoFormatado += `ajuda(`;
+        if (expressao.valor) {
+            this.formatarDeclaracaoOuConstruto(expressao.valor);
+        }
+        this.codigoFormatado += `)`;
+    }
+    visitarExpressaoEnquanto(expressao) {
+        this.codigoFormatado += `enquanto `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoElvis(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.esquerda);
+        this.codigoFormatado += ` ?? `;
+        this.formatarDeclaracaoOuConstruto(expressao.direita);
+    }
+    visitarExpressaoFazer(expressao) {
+        this.codigoFormatado += `fazer {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.caminhoFazer.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}} enquanto `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicaoEnquanto);
+    }
+    visitarExpressaoListaCompreensao(listaCompreensao) {
+        this.codigoFormatado += `[`;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.expressaoRetorno);
+        this.codigoFormatado += ` para cada `;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.referenciaVariavelIteracao);
+        this.codigoFormatado += ` de `;
+        this.formatarDeclaracaoOuConstruto(listaCompreensao.paraCada.vetorOuDicionario);
+        this.codigoFormatado += `]`;
+    }
+    visitarExpressaoPara(expressao) {
+        this.codigoFormatado += `para `;
+        this.devePularLinha = false;
+        if (expressao.inicializador) {
+            if (Array.isArray(expressao.inicializador)) {
+                this.deveIndentar = false;
+                for (let declaracaoInicializador of expressao.inicializador) {
+                    this.formatarDeclaracaoOuConstruto(declaracaoInicializador);
+                }
+                this.deveIndentar = true;
+            }
+            else {
+                this.formatarDeclaracaoOuConstruto(expressao.inicializador);
+            }
+        }
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += `; `;
+        this.formatarDeclaracaoOuConstruto(expressao.incrementar);
+        this.devePularLinha = true;
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoParaCada(expressao) {
+        this.codigoFormatado += `para cada ${expressao.variavelIteracao} de `;
+        this.formatarDeclaracaoOuConstruto(expressao.vetorOuDicionario);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracao of expressao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracao);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}`;
+    }
+    visitarExpressaoSeTernario(expressao) {
+        this.formatarDeclaracaoOuConstruto(expressao.condicao);
+        this.codigoFormatado += ` ? `;
+        this.formatarDeclaracaoOuConstruto(expressao.expressaoSe);
+        this.codigoFormatado += ` : `;
+        this.formatarDeclaracaoOuConstruto(expressao.expressaoSenao);
+    }
     obterDelimitadorTexto(expressao) {
         if (this.delimitadorTexto === 'aspas-duplas') {
             return '"';
@@ -15769,7 +16033,12 @@ class FormatadorDelegua {
         return '';
     }
     visitarDeclaracaoClasse(declaracao) {
-        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}classe ${declaracao.simbolo.lexema} {${this.quebraLinha}`;
+        const modificador = declaracao.estrangeira
+            ? 'estrangeira '
+            : declaracao.abstrata
+                ? 'abstrata '
+                : '';
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}classe ${modificador}${declaracao.simbolo.lexema} {${this.quebraLinha}`;
         this.indentacaoAtual += this.tamanhoIndentacao;
         for (let propriedade of declaracao.propriedades) {
             this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${propriedade.nome.lexema}: ${propriedade.tipo || 'qualquer'}${this.quebraLinha}`;
@@ -15777,7 +16046,24 @@ class FormatadorDelegua {
         this.codigoFormatado += `${this.quebraLinha}`;
         for (let metodo of declaracao.metodos) {
             this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}${metodo.simbolo.lexema}`;
-            this.visitarExpressaoFuncaoConstruto(metodo.funcao);
+            if (declaracao.estrangeira) {
+                // Métodos estrangeiros: emitir apenas a assinatura, sem corpo.
+                this.codigoFormatado += `(`;
+                for (let argumento of metodo.funcao.parametros) {
+                    this.codigoFormatado += `${argumento.nome.lexema}: ${argumento.tipoDado || 'qualquer'}, `;
+                }
+                if (metodo.funcao.parametros.length > 0) {
+                    this.codigoFormatado = this.codigoFormatado.slice(0, -2);
+                }
+                this.codigoFormatado += `)`;
+                if (metodo.funcao.tipoExplicito && metodo.funcao.tipo) {
+                    this.codigoFormatado += `: ${metodo.funcao.tipo}`;
+                }
+                this.codigoFormatado += this.quebraLinha;
+            }
+            else {
+                this.visitarExpressaoFuncaoConstruto(metodo.funcao);
+            }
         }
         this.indentacaoAtual -= this.tamanhoIndentacao;
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
@@ -15822,6 +16108,9 @@ class FormatadorDelegua {
     visitarDeclaracaoDeExpressao(declaracao) {
         this.codigoFormatado += ' '.repeat(this.indentacaoAtual);
         this.formatarDeclaracaoOuConstruto(declaracao.expressao);
+        if (!this.codigoFormatado.endsWith(this.quebraLinha)) {
+            this.codigoFormatado += this.quebraLinha;
+        }
     }
     visitarDeclaracaoDefinicaoFuncao(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}função `;
@@ -15833,7 +16122,13 @@ class FormatadorDelegua {
     visitarDeclaracaoEnquanto(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}enquanto `;
         this.formatarDeclaracaoOuConstruto(declaracao.condicao);
-        this.formatarDeclaracaoOuConstruto(declaracao.corpo);
+        this.codigoFormatado += ` {${this.quebraLinha}`;
+        this.indentacaoAtual += this.tamanhoIndentacao;
+        for (let declaracaoBloco of declaracao.corpo.declaracoes) {
+            this.formatarDeclaracaoOuConstruto(declaracaoBloco);
+        }
+        this.indentacaoAtual -= this.tamanhoIndentacao;
+        this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}}${this.quebraLinha}`;
     }
     visitarDeclaracaoEscolha(declaracao) {
         this.codigoFormatado += `${' '.repeat(this.indentacaoAtual)}escolha `;
@@ -16256,7 +16551,7 @@ class FormatadorDelegua {
         this.formatarDeclaracaoOuConstruto(expressao.valor);
     }
     visitarExpressaoUnaria(expressao) {
-        let operador;
+        let operador = '';
         switch (expressao.operador.tipo) {
             case delegua_1.default.INCREMENTAR:
                 operador = `++`;
@@ -16301,6 +16596,12 @@ class FormatadorDelegua {
             case construtos_1.AcessoIndiceVariavel:
                 this.visitarExpressaoAcessoIndiceVariavel(declaracaoOuConstruto);
                 break;
+            case construtos_1.AcessoMetodo:
+                this.visitarExpressaoAcessoMetodo(declaracaoOuConstruto);
+                break;
+            case construtos_1.AcessoPropriedade:
+                this.visitarExpressaoAcessoPropriedade(declaracaoOuConstruto);
+                break;
             case construtos_1.AcessoMetodoOuPropriedade:
                 this.visitarExpressaoAcessoMetodoOuPropriedade(declaracaoOuConstruto);
                 break;
@@ -16346,6 +16647,9 @@ class FormatadorDelegua {
             case declaracoes_1.Enquanto:
                 this.visitarDeclaracaoEnquanto(declaracaoOuConstruto);
                 break;
+            case declaracoes_1.Extensao:
+                this.visitarDeclaracaoExtensao(declaracaoOuConstruto);
+                break;
             case declaracoes_1.Escreva:
                 this.visitarDeclaracaoEscreva(declaracaoOuConstruto);
                 break;
@@ -16370,6 +16674,9 @@ class FormatadorDelegua {
             case declaracoes_1.Importar:
                 this.visitarDeclaracaoImportar(declaracaoOuConstruto);
                 break;
+            case declaracoes_1.InterfaceDeclaracao:
+                this.visitarDeclaracaoInterface(declaracaoOuConstruto);
+                break;
             case construtos_1.ImportarComoConstruto:
                 this.visitarExpressaoImportar(declaracaoOuConstruto);
                 break;
@@ -18229,6 +18536,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
     }
     constructor(simboloOriginal, superClasses, metodos, propriedades) {
         super();
+        this.dialetoRequerExpansaoPropriedadesEspacoMemoria = false;
         this.simboloOriginal = simboloOriginal;
         if (Array.isArray(superClasses)) {
             this.superClasses = superClasses;
@@ -18250,6 +18558,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         this.propriedades = propriedades || [];
         this.dialetoRequerDeclaracaoPropriedades = false;
         this.abstrata = false;
+        this.estrangeira = false;
         this.classeEstatica = false;
         this.metodosAbstratos = [];
         this.acessoMetodos = {};
@@ -18272,7 +18581,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
                 }
             }
             if (candidato === null) {
-                throw new excecoes_1.ErroEmTempoDeExecucao(null, 'Hierarquia de classes inconsistente: não foi possível calcular o OReM (C3).');
+                throw new excecoes_1.ErroEmTempoDeExecucao(undefined, 'Hierarquia de classes inconsistente: não foi possível calcular o OReM (C3).');
             }
             resultado.push(candidato);
             for (const lista of listas) {
@@ -18420,6 +18729,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         return new metodo_polimorfico_1.MetodoPolimorfico(nome, todasSobrecargas);
     }
     encontrarPropriedade(nome) {
+        var _a;
         if (nome in this.propriedades) {
             return this.propriedades[nome];
         }
@@ -18429,7 +18739,7 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
             }
         }
         if (this.dialetoRequerDeclaracaoPropriedades) {
-            throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${this.simboloOriginal.lexema}.`);
+            throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Propriedade "${nome}" não declarada na classe ${(_a = this.simboloOriginal) === null || _a === void 0 ? void 0 : _a.lexema}.`);
         }
         return undefined;
     }
@@ -18460,13 +18770,16 @@ class DescritorTipoClasse extends chamavel_1.Chamavel {
         return inicializador ? inicializador.aridade() : 0;
     }
     async chamar(visitante, argumentos) {
-        var _a, _b;
+        var _a, _b, _c;
         if (this.classeEstatica) {
             throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Não é possível instanciar a classe estática '${(_a = this.simboloOriginal) === null || _a === void 0 ? void 0 : _a.lexema}'.`);
         }
         if (this.abstrata) {
             throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Não é possível instanciar a classe abstrata '${(_b = this.simboloOriginal) === null || _b === void 0 ? void 0 : _b.lexema}'.`);
         }
+        if (this.estrangeira) {
+            throw new excecoes_1.ErroEmTempoDeExecucao(this.simboloOriginal, `Não é possível instanciar a classe estrangeira '${(_c = this.simboloOriginal) === null || _c === void 0 ? void 0 : _c.lexema}' diretamente.`);
+        }
         const instancia = new objeto_delegua_classe_1.ObjetoDeleguaClasse(this);
         const inicializador = this.encontrarMetodo('construtor');
         if (inicializador) {
@@ -20847,6 +21160,7 @@ class InterpretadorBase {
         descritorTipoClasse.obtenedoresEstaticos = obtenedoresEstaticos;
         descritorTipoClasse.definidoresEstaticos = definidoresEstaticos;
         descritorTipoClasse.abstrata = declaracao.abstrata;
+        descritorTipoClasse.estrangeira = declaracao.estrangeira;
         descritorTipoClasse.classeEstatica = declaracao.classeEstatica;
         descritorTipoClasse.metodosAbstratos = metodosAbstratos;
         descritorTipoClasse.acessoMetodos = acessoMetodos;
@@ -20887,9 +21201,9 @@ class InterpretadorBase {
         }
         // Verifica se a subclasse concreta implementa todos os métodos abstratos
         // da(s) superclasse(s) abstrata(s).
-        if (!declaracao.abstrata) {
+        if (!declaracao.abstrata && !declaracao.estrangeira) {
             for (const superClasse of superClassesResolvidas) {
-                if (superClasse.abstrata) {
+                if (superClasse.abstrata || superClasse.estrangeira) {
                     superClasse.verificarImplementacaoAbstrata(descritorTipoClasse);
                 }
             }
@@ -27325,6 +27639,7 @@ exports.palavrasReservadasDelegua = {
     enquanto: delegua_1.default.ENQUANTO,
     extensao: delegua_1.default.EXTENSAO,
     extensão: delegua_1.default.EXTENSAO,
+    estrangeira: delegua_1.default.ESTRANGEIRA,
     estatica: delegua_1.default.ESTATICO,
     estática: delegua_1.default.ESTATICO,
     estatico: delegua_1.default.ESTATICO,
@@ -27658,6 +27973,7 @@ exports.default = {
     DOIS_PONTOS: 'DOIS_PONTOS',
     E: 'E',
     ELVIS: 'ELVIS',
+    ESTRANGEIRA: 'ESTRANGEIRA',
     EXTENSAO: 'EXTENSAO',
     EM: 'EM',
     ENQUANTO: 'ENQUANTO',
@@ -44366,6 +44682,17 @@ class TradutorElixir {
     converterNomeModulo(nome) {
         return nome.charAt(0).toUpperCase() + nome.slice(1);
     }
+    mapearTipoParaTypespec(tipo) {
+        switch (tipo) {
+            case 'texto': return 'String.t()';
+            case 'numero':
+            case 'inteiro': return 'integer()';
+            case 'real': return 'float()';
+            case 'logico': return 'boolean()';
+            case 'vazio': return 'no_return()';
+            default: return 'term()';
+        }
+    }
     /**
      * Gera nome único para variável temporária
      */
@@ -44450,16 +44777,27 @@ class TradutorElixir {
         this.aumentarIndentacao();
         const moduloAnterior = this.moduloAtual;
         this.moduloAtual = nomeModulo;
-        // Extrair campos do struct do construtor
-        const camposStruct = await this.extrairCamposStruct(declaracao);
-        if (camposStruct.length > 0) {
-            resultado += this.adicionarIndentacao();
-            resultado += `defstruct [${camposStruct.join(', ')}]\n\n`;
+        if (declaracao.estrangeira) {
+            // Classe estrangeira: emitir @callback para cada método, definindo a interface esperada do módulo.
+            resultado += this.adicionarIndentacao() + `@moduledoc "Classe estrangeira — implementação externa."\n`;
+            for (const metodo of declaracao.metodos) {
+                const params = metodo.funcao.parametros.map(() => 'term()').join(', ');
+                const retorno = this.mapearTipoParaTypespec(metodo.funcao.tipo);
+                resultado += this.adicionarIndentacao() + `@callback ${metodo.simbolo.lexema}(${params}) :: ${retorno}\n`;
+            }
         }
-        // Traduzir métodos
-        for (const metodo of declaracao.metodos) {
-            const traducaoMetodo = await this.traduzirMetodoClasse(metodo, nomeModulo);
-            resultado += traducaoMetodo + '\n\n';
+        else {
+            // Extrair campos do struct do construtor
+            const camposStruct = await this.extrairCamposStruct(declaracao);
+            if (camposStruct.length > 0) {
+                resultado += this.adicionarIndentacao();
+                resultado += `defstruct [${camposStruct.join(', ')}]\n\n`;
+            }
+            // Traduzir métodos
+            for (const metodo of declaracao.metodos) {
+                const traducaoMetodo = await this.traduzirMetodoClasse(metodo, nomeModulo);
+                resultado += traducaoMetodo + '\n\n';
+            }
         }
         this.diminuirIndentacao();
         resultado += this.adicionarIndentacao() + 'end';
@@ -46061,9 +46399,10 @@ class TradutorMermaidJs {
             : undefined;
         const linha = declaracao.linha;
         // Cria arestas de entrada e saída para a classe
-        const textoInicio = `Classe${nomeClasse}Inicio[Início: Classe ${nomeClasse}]`;
+        const rotulo = declaracao.estrangeira ? 'Classe Estrangeira' : 'Classe';
+        const textoInicio = `Classe${nomeClasse}Inicio[Início: ${rotulo} ${nomeClasse}]`;
         const arestaInicial = new mermaid_1.ArestaFluxograma(declaracao, textoInicio);
-        const textoFim = `Classe${nomeClasse}Fim[Fim: Classe ${nomeClasse}]`;
+        const textoFim = `Classe${nomeClasse}Fim[Fim: ${rotulo} ${nomeClasse}]`;
         const arestaFinal = new mermaid_1.ArestaFluxograma(declaracao, textoFim);
         // Cria o subgrafo da classe
         const subgrafo = new mermaid_1.SubgrafoClasse(nomeClasse, linha, arestaInicial, arestaFinal, superClasse);