@yakuzaa/jade-compiler 0.1.2 → 0.1.4

package/dist/semantic/type_checker.js

@@ -24,12 +24,12 @@ export class TypeChecker {
         'contem': 'booleano',
         'adicionar': 'vazio',
         'remover': 'vazio',
-        'obter': 'T', // tipo do elemento
+        'obter': 'qualquer', // tipo do elemento — sem suporte a genéricos ainda
         'filtrar': 'lista', // lista.filtrar(condicao) -> lista<T>
         'ordenar': 'lista', // lista.ordenar(campo) -> lista<T>
-        'primeiro': 'T', // lista.primeiro() -> T
-        'ultimo': 'T', // lista.ultimo() -> T
-        'vazia': 'booleano' // lista.vazia() -> booleano
+        'primeiro': 'qualquer', // tipo do elemento — sem suporte a genéricos ainda
+        'ultimo': 'qualquer', // tipo do elemento — sem suporte a genéricos ainda
+        'vazia': 'booleano'
     };
     // ── Verificações principais ──────────────────────────────
     verificarPrograma(node) {
@@ -70,7 +70,7 @@ export class TypeChecker {
                     // Ciclo encontrado
                     const ciclo = [...caminho, vizinho].join(' → ');
                     this.erro(`Ciclo de eventos detectado: ${ciclo}. ` +
-                        `Isso causaria loop infinito em runtime.`, 0, 0);
+                        `Isso causaria loop infinito em runtime.`, 0, 0, 'Redesenhe o fluxo de eventos para evitar que um evento dispare outro que eventualmente o re-dispare');
                     return true;
                 }
             }
@@ -117,9 +117,9 @@ export class TypeChecker {
         }
     }
     registrarImportacao(node) {
-        try {
-            if (node.alias) {
-                // importar financeiro como fin → registra 'fin' como namespace do módulo
+        if (node.alias) {
+            // importar financeiro como fin → registra 'fin' como namespace do módulo
+            if (!this.tabela.buscar(node.alias)) {
                 this.tabela.declarar({
                     nome: node.alias,
                     kind: 'entidade',
@@ -129,8 +129,11 @@ export class TypeChecker {
                     escopo: this.tabela.escopoAtual()
                 });
             }
-            else if (node.item && !node.wildcard) {
-                // importar estoque.Produto → registra 'Produto' como tipo externo conhecido
+        }
+        else if (node.item && !node.wildcard) {
+            // importar estoque.Produto → registra 'Produto' como tipo externo conhecido
+            // Se já declarado localmente, o símbolo local tem precedência (não substituir)
+            if (!this.tabela.buscar(node.item)) {
                 this.tabela.declarar({
                     nome: node.item,
                     kind: 'classe',
@@ -140,12 +143,10 @@ export class TypeChecker {
                     escopo: this.tabela.escopoAtual()
                 });
             }
-            // Wildcard (importar vendas.*) — não é possível registrar símbolos
-            // específicos sem resolver o módulo; aceito silenciosamente por enquanto.
         }
-        catch {
-            // Silenciar conflito de nome se o tipo já foi declarado localmente.
-            // A precedência é do símbolo local.
+        else if (node.wildcard) {
+            // Wildcard bloqueado — ambíguo e inseguro
+            this.erro(`Import wildcard 'importar ${node.modulo}.*' não é permitido`, node.line, node.column, `Importe apenas o que precisa: 'importar ${node.modulo}.NomeDoTipo'`);
         }
     }
     registrarClasse(node) {
@@ -243,7 +244,7 @@ export class TypeChecker {
         // Verificar superclasse
         if (node.superClasse) {
             if (!this.tipoExiste(node.superClasse)) {
-                this.erro(`Superclasse '${node.superClasse}' não encontrada`, node.line, node.column);
+                this.erro(`Superclasse '${node.superClasse}' não encontrada`, node.line, node.column, `Declare a classe '${node.superClasse}' antes de usá-la como superclasse, ou verifique se o nome está correto`);
             }
             else {
                 // Registrar superclasse para verificação de herança
@@ -253,7 +254,7 @@ export class TypeChecker {
         // Verificar interfaces
         for (const interfaceNome of node.interfaces) {
             if (!this.tipoExiste(interfaceNome)) {
-                this.erro(`Interface '${interfaceNome}' não encontrada`, node.line, node.column);
+                this.erro(`Interface '${interfaceNome}' não encontrada`, node.line, node.column, `Declare a interface '${interfaceNome}' antes de usá-la com 'implements'`);
             }
         }
         // Registrar campos e métodos
@@ -284,7 +285,7 @@ export class TypeChecker {
                 temId = true;
             }
             if (!this.tipoExiste(tipoCampo)) {
-                this.erro(`Tipo '${tipoCampo}' não existe`, campo.line, campo.column);
+                this.erro(`Tipo '${tipoCampo}' não existe`, campo.line, campo.column, this.dicaTipoNaoExiste(tipoCampo));
             }
             const simbolo = {
                 nome: campo.nome,
@@ -299,7 +300,7 @@ export class TypeChecker {
             this.tabela.registrarCampo(node.nome, campo.nome, tipoCampo);
         }
         if (!temId) {
-            this.erro(`Entidade '${node.nome}' deve ter exatamente um campo do tipo 'id'`, node.line, node.column);
+            this.erro(`Entidade '${node.nome}' deve ter exatamente um campo do tipo 'id'`, node.line, node.column, `Adicione 'id: id' à entidade '${node.nome}' para que ela possa ser salva e buscada`);
         }
         this.tabela.sairEscopo();
     }
@@ -322,7 +323,7 @@ export class TypeChecker {
         for (const parametro of node.parametros) {
             const tipoParam = this.tipoParaString(parametro.tipo);
             if (!this.tipoExiste(tipoParam)) {
-                this.erro(`Tipo '${tipoParam}' não existe`, parametro.line, parametro.column);
+                this.erro(`Tipo '${tipoParam}' não existe`, parametro.line, parametro.column, this.dicaTipoNaoExiste(tipoParam));
             }
             tiposParams.push(tipoParam);
             const simbolo = {
@@ -345,7 +346,7 @@ export class TypeChecker {
             // Se tipoRetorno != void, verificar se bloco termina com Retorno
             if (tipoRetorno !== 'vazio') {
                 if (!this.verificarRetornoEmTodosCaminhos(node.corpo)) {
-                    this.erro(`Função '${node.nome}' deve retornar valor em todos os caminhos`, node.line, node.column);
+                    this.erro(`Função '${node.nome}' deve retornar valor em todos os caminhos`, node.line, node.column, `Certifique-se que todos os ramos do 'se/senao' terminam com 'retornar valor'`);
                 }
             }
         }
@@ -356,7 +357,7 @@ export class TypeChecker {
         // Verificar se evento existe
         const evento = this.tabela.buscar(node.evento);
         if (!evento || evento.kind !== 'evento') {
-            this.erro(`Evento '${node.evento}' não encontrado`, node.line, node.column);
+            this.erro(`Evento '${node.evento}' não encontrado`, node.line, node.column, `Declare o evento antes de escutá-lo: 'evento ${node.evento}'`);
             return; // Retorna para não continuar com um evento inválido
         }
         // Entrar no escopo do ouvinte
@@ -393,7 +394,7 @@ export class TypeChecker {
         for (const campo of node.campos) {
             const tipoCampo = this.tipoParaString(campo.tipo);
             if (!this.tipoExiste(tipoCampo)) {
-                this.erro(`Tipo '${tipoCampo}' não existe`, campo.line, campo.column);
+                this.erro(`Tipo '${tipoCampo}' não existe`, campo.line, campo.column, 'Use um tipo válido para o campo do evento: texto, numero, decimal, booleano, data, hora ou id');
             }
             const simbolo = {
                 nome: campo.nome,
@@ -431,13 +432,15 @@ export class TypeChecker {
         // Verificar se a condição é booleana
         const tipoCondicao = this.resolverTipo(node.condicao);
         if (tipoCondicao !== 'booleano') {
-            this.erro(`Condição da regra '${node.nome}' deve ser booleana, recebido '${tipoCondicao}'`, node.condicao.line, node.condicao.column);
+            this.erro(`Condição da regra '${node.nome}' deve ser booleana, recebido '${tipoCondicao}'`, node.condicao.line, node.condicao.column, "A condição deve resultar em verdadeiro/falso, ex: `quando produto.estoque < 10` ou `quando cliente.ativo`");
         }
-        // Verificar o bloco então
+        this.tabela.entrarEscopo('regra_entao');
         this.verificarBloco(node.entao);
-        // Verificar o bloco senão (se existir)
+        this.tabela.sairEscopo();
         if (node.senao) {
+            this.tabela.entrarEscopo('regra_senao');
             this.verificarBloco(node.senao);
+            this.tabela.sairEscopo();
         }
     }
     verificarImportacao(_node) {
@@ -493,20 +496,20 @@ export class TypeChecker {
         if (node.tipo) {
             tipoDeclarado = this.tipoParaString(node.tipo);
             if (!this.tipoExiste(tipoDeclarado)) {
-                this.erro(`Tipo '${tipoDeclarado}' não existe`, node.line, node.column);
+                this.erro(`Tipo '${tipoDeclarado}' não existe`, node.line, node.column, this.dicaTipoNaoExiste(tipoDeclarado));
             }
         }
         if (node.inicializador) {
             const tipoInicializador = this.resolverTipo(node.inicializador);
             if (tipoDeclarado && !this.tiposCompatíveis(tipoDeclarado, tipoInicializador)) {
-                this.erro(`Tipo incompatível: esperado '${tipoDeclarado}', recebido '${tipoInicializador}'`, node.line, node.column);
+                this.erro(`Tipo incompatível: esperado '${tipoDeclarado}', recebido '${tipoInicializador}'`, node.line, node.column, `Converta o valor para '${tipoDeclarado}' ou mude o tipo declarado da variável`);
             }
             if (!tipoDeclarado) {
                 tipoDeclarado = tipoInicializador;
             }
         }
         else if (!tipoDeclarado) {
-            this.erro(`Variável '${node.nome}' precisa de tipo ou inicializador`, node.line, node.column);
+            this.erro(`Variável '${node.nome}' precisa de tipo ou inicializador`, node.line, node.column, `Declare com tipo: 'variavel ${node.nome}: numero', ou com valor: 'variavel ${node.nome} = 0'`);
         }
         const simbolo = {
             nome: node.nome,
@@ -520,7 +523,7 @@ export class TypeChecker {
             this.tabela.declarar(simbolo);
         }
         catch (e) {
-            this.erro(e.message, node.line, node.column);
+            this.erro(e.message, node.line, node.column, `Renomeie a variável '${node.nome}' ou remova a declaração duplicada`);
         }
     }
     verificarAtribuicao(node) {
@@ -528,11 +531,11 @@ export class TypeChecker {
         if (typeof node.alvo === 'string') {
             const simbolo = this.tabela.buscar(node.alvo);
             if (!simbolo) {
-                this.erro(`Variável '${node.alvo}' não declarada`, node.line, node.column);
+                this.erro(`Variável '${node.alvo}' não declarada`, node.line, node.column, `Declare a variável antes de usá-la: 'variavel ${node.alvo}: tipo'`);
                 return;
             }
             if (!this.tiposCompatíveis(simbolo.tipo, tipoValor)) {
-                this.erro(`Tipo incompatível: esperado '${simbolo.tipo}', recebido '${tipoValor}'`, node.line, node.column);
+                this.erro(`Tipo incompatível: esperado '${simbolo.tipo}', recebido '${tipoValor}'`, node.line, node.column, `O valor atribuído não é do mesmo tipo da variável '${node.alvo}' (${simbolo.tipo})`);
             }
         }
         else {
@@ -540,46 +543,55 @@ export class TypeChecker {
             const tipoObjeto = this.resolverTipo(node.alvo.objeto);
             const objetoSimbolo = this.tabela.buscar(tipoObjeto);
             if (!objetoSimbolo || (objetoSimbolo.kind !== 'classe' && objetoSimbolo.kind !== 'entidade')) {
-                this.erro(`'${tipoObjeto}' não é uma classe ou entidade`, node.alvo.line, node.alvo.column);
+                this.erro(`'${tipoObjeto}' não é uma classe ou entidade`, node.alvo.line, node.alvo.column, "Só é possível acessar campos com '.' em entidades ou classes");
                 return;
             }
             // Verificar se campo existe e tipo compatível
             const tipoCampo = this.tabela.buscarCampo(tipoObjeto, node.alvo.membro);
             if (tipoCampo === null) {
-                this.erro(`'${tipoObjeto}' não possui campo '${node.alvo.membro}'`, node.alvo.line, node.alvo.column);
+                this.erro(`'${tipoObjeto}' não possui campo '${node.alvo.membro}'`, node.alvo.line, node.alvo.column, `Verifique o nome do campo — pode estar digitado errado. Os campos disponíveis estão na declaração da entidade '${tipoObjeto}'`);
                 return;
             }
             if (!this.tiposCompatíveis(tipoCampo, tipoValor)) {
-                this.erro(`Tipo incompatível: campo '${node.alvo.membro}' espera '${tipoCampo}', recebido '${tipoValor}'`, node.line, node.column);
+                this.erro(`Tipo incompatível: campo '${node.alvo.membro}' espera '${tipoCampo}', recebido '${tipoValor}'`, node.line, node.column, `Converta o valor para '${tipoCampo}' antes de atribuir ao campo '${node.alvo.membro}'`);
             }
         }
     }
     verificarCondicional(node) {
         const tipoCondicao = this.resolverTipo(node.condicao);
         if (tipoCondicao !== 'booleano') {
-            this.erro(`Condição do 'se' deve ser booleano, recebeu '${tipoCondicao}'`, node.condicao.line, node.condicao.column);
+            this.erro(`Condição do 'se' deve ser booleano, recebeu '${tipoCondicao}'`, node.condicao.line, node.condicao.column, "Use uma comparação: `se x > 0`, `se produto.ativo`, `se nome == \"João\"`");
         }
+        // Cada branch tem seu próprio escopo — evita vazamento de variáveis entre branches
+        this.tabela.entrarEscopo('se');
         this.verificarBloco(node.entao);
+        this.tabela.sairEscopo();
         if (node.senao) {
+            this.tabela.entrarEscopo('senao');
             this.verificarBloco(node.senao);
+            this.tabela.sairEscopo();
         }
     }
     verificarEnquanto(node) {
         const tipoCondicao = this.resolverTipo(node.condicao);
         if (tipoCondicao !== 'booleano') {
-            this.erro(`Condição do 'enquanto' deve ser booleano, recebeu '${tipoCondicao}'`, node.condicao.line, node.condicao.column);
+            this.erro(`Condição do 'enquanto' deve ser booleano, recebeu '${tipoCondicao}'`, node.condicao.line, node.condicao.column, "Use uma condição booleana, ex: `enquanto i < 10` ou `enquanto cliente.ativo`");
         }
+        // Corpo do enquanto tem escopo próprio
+        this.tabela.entrarEscopo('enquanto');
         this.verificarBloco(node.corpo);
+        this.tabela.sairEscopo();
     }
     verificarPara(node) {
         const tipoIteravel = this.resolverTipo(node.iteravel);
         if (!tipoIteravel.startsWith('lista<')) {
-            this.erro(`Iterável do 'para' deve ser do tipo 'lista<T>', recebeu '${tipoIteravel}'`, node.iteravel.line, node.iteravel.column);
+            this.erro(`Iterável do 'para' deve ser do tipo 'lista<T>', recebeu '${tipoIteravel}'`, node.iteravel.line, node.iteravel.column, "O 'para' itera sobre listas, ex: `para produto em listaProdutos` onde listaProdutos é do tipo lista<Produto>");
             return;
         }
         // Extrair tipo do elemento: lista<Tipo> -> Tipo
         const tipoElemento = tipoIteravel.substring(6, tipoIteravel.length - 1);
-        // Declarar variável de iteração
+        // Variável de iteração e corpo do loop têm escopo próprio — não vaza para fora
+        this.tabela.entrarEscopo('para');
         const simbolo = {
             nome: node.variavel,
             kind: 'variavel',
@@ -592,34 +604,35 @@ export class TypeChecker {
             this.tabela.declarar(simbolo);
         }
         catch (e) {
-            this.erro(e.message, node.line, node.column);
+            this.erro(e.message, node.line, node.column, `Renomeie a variável de iteração '${node.variavel}' para evitar conflito com nome existente`);
         }
         this.verificarBloco(node.corpo);
+        this.tabela.sairEscopo();
     }
     verificarRetorno(node) {
         if (!this.funcaoAtual) {
-            this.erro(`'retornar' só pode ser usado dentro de uma função`, node.line, node.column);
+            this.erro(`'retornar' só pode ser usado dentro de uma função`, node.line, node.column, "Mova o 'retornar' para dentro de um bloco 'funcao'");
             return;
         }
         if (node.valor) {
             if (!this.funcaoAtual.tipoRetorno) {
-                this.erro(`Função '${this.funcaoAtual.nome}' não deve retornar valor`, node.line, node.column);
+                this.erro(`Função '${this.funcaoAtual.nome}' não deve retornar valor`, node.line, node.column, `Remova o valor do 'retornar', ou adicione '-> tipo' na declaração da função '${this.funcaoAtual.nome}'`);
                 return;
             }
             const tipoRetorno = this.tipoParaString(this.funcaoAtual.tipoRetorno);
             const tipoValor = this.resolverTipo(node.valor);
             if (!this.tiposCompatíveis(tipoRetorno, tipoValor)) {
-                this.erro(`Tipo incompatível: esperado '${tipoRetorno}', recebido '${tipoValor}'`, node.line, node.column);
+                this.erro(`Tipo incompatível: esperado '${tipoRetorno}', recebido '${tipoValor}'`, node.line, node.column, `O valor retornado não combina com o tipo de retorno '${tipoRetorno}' declarado na função`);
             }
         }
         else if (this.funcaoAtual.tipoRetorno) {
-            this.erro(`Função '${this.funcaoAtual.nome}' deve retornar valor`, node.line, node.column);
+            this.erro(`Função '${this.funcaoAtual.nome}' deve retornar valor`, node.line, node.column, `Adicione 'retornar valor' ao final da função, ou remova '-> ${this.tipoParaString(this.funcaoAtual.tipoRetorno)}' da declaração`);
         }
     }
     verificarEmissaoEvento(node) {
         const evento = this.tabela.buscar(node.evento);
         if (!evento || evento.kind !== 'evento') {
-            this.erro(`Evento '${node.evento}' não encontrado`, node.line, node.column);
+            this.erro(`Evento '${node.evento}' não encontrado`, node.line, node.column, `Declare o evento antes de emiti-lo: 'evento ${node.evento}'`);
             return;
         }
         // Verificar argumentos contra campos do evento
@@ -627,7 +640,7 @@ export class TypeChecker {
         if (camposEvento) {
             // Verificar quantidade de argumentos
             if (node.argumentos.length !== camposEvento.size) {
-                this.erro(`Evento '${node.evento}' espera ${camposEvento.size} argumentos, recebeu ${node.argumentos.length}`, node.line, node.column);
+                this.erro(`Evento '${node.evento}' espera ${camposEvento.size} argumentos, recebeu ${node.argumentos.length}`, node.line, node.column, `Forneça exatamente um valor para cada campo do evento na ordem declarada: emitir ${node.evento}(${Array.from(camposEvento.keys()).join(', ')})`);
                 return;
             }
             // Verificar tipo de cada argumento
@@ -638,7 +651,7 @@ export class TypeChecker {
                 const tipoArgumento = this.resolverTipo(node.argumentos[i]);
                 const [nomeCampo, tipoCampo] = camposArray[i];
                 if (!this.tiposCompatíveis(tipoCampo, tipoArgumento)) {
-                    this.erro(`Argumento '${nomeCampo}' do evento '${node.evento}' deve ser '${tipoCampo}', recebido '${tipoArgumento}'`, node.argumentos[i].line || node.line, node.argumentos[i].column || node.column);
+                    this.erro(`Argumento '${nomeCampo}' do evento '${node.evento}' deve ser '${tipoCampo}', recebido '${tipoArgumento}'`, node.argumentos[i].line || node.line, node.argumentos[i].column || node.column, `Verifique o tipo do valor fornecido para o campo '${nomeCampo}' — esperado '${tipoCampo}'`);
                 }
             }
         }
@@ -646,7 +659,7 @@ export class TypeChecker {
     verificarErro(node) {
         const tipoMensagem = this.resolverTipo(node.mensagem);
         if (tipoMensagem !== 'texto') {
-            this.erro(`Mensagem de erro deve ser do tipo 'texto', recebeu '${tipoMensagem}'`, node.line, node.column);
+            this.erro(`Mensagem de erro deve ser do tipo 'texto', recebeu '${tipoMensagem}'`, node.line, node.column, 'Use uma string entre aspas: `erro "Mensagem de erro aqui"`');
         }
     }
     verificarInstrucao(instrucao) {
@@ -708,7 +721,11 @@ export class TypeChecker {
     resolverTipoIdentificador(node) {
         const simbolo = this.tabela.buscar(node.nome);
         if (!simbolo) {
-            this.erro(`Variável '${node.nome}' não declarada`, node.line, node.column);
+            const sug = this.sugestao(node.nome, this.tabela.buscarTodosNomesVisiveis());
+            const dica = sug
+                ? `Você quis dizer '${sug}'? Declare a variável antes de usá-la: 'variavel ${node.nome}: tipo'`
+                : `Declare a variável antes de usá-la: 'variavel ${node.nome}: tipo'`;
+            this.erro(`Variável '${node.nome}' não declarada`, node.line, node.column, dica);
             return 'desconhecido';
         }
         return simbolo.tipo;
@@ -729,6 +746,13 @@ export class TypeChecker {
                     return 'decimal';
                 if (tipoEsquerda === 'numero' && tipoDireita === 'decimal')
                     return 'decimal';
+                // moeda opera com moeda ou numero (escala monetária); sempre retorna moeda
+                if (tipoEsquerda === 'moeda' && tipoDireita === 'moeda')
+                    return 'moeda';
+                if (tipoEsquerda === 'moeda' && tipoDireita === 'numero')
+                    return 'moeda';
+                if (tipoEsquerda === 'numero' && tipoDireita === 'moeda')
+                    return 'moeda';
                 if (node.operador === '+' && tipoEsquerda === 'texto' && tipoDireita === 'texto')
                     return 'texto';
                 break;
@@ -741,8 +765,8 @@ export class TypeChecker {
             case '<=':
             case '>':
             case '>=':
-                if ((tipoEsquerda === 'numero' || tipoEsquerda === 'decimal') &&
-                    (tipoDireita === 'numero' || tipoDireita === 'decimal'))
+                if ((tipoEsquerda === 'numero' || tipoEsquerda === 'decimal' || tipoEsquerda === 'moeda') &&
+                    (tipoDireita === 'numero' || tipoDireita === 'decimal' || tipoDireita === 'moeda'))
                     return 'booleano';
                 if (tipoEsquerda === 'data' && tipoDireita === 'data')
                     return 'booleano';
@@ -755,14 +779,14 @@ export class TypeChecker {
                     return 'booleano';
                 break;
         }
-        this.erro(`Operador '${node.operador}' não pode ser aplicado entre '${tipoEsquerda}' e '${tipoDireita}'`, node.line, node.column);
+        this.erro(`Operador '${node.operador}' não pode ser aplicado entre '${tipoEsquerda}' e '${tipoDireita}'`, node.line, node.column, `Operadores aritméticos (+, -, *, /) funcionam entre número/decimal. '+' também concatena dois textos. Compare apenas valores do mesmo tipo`);
         return 'desconhecido';
     }
     resolverTipoUnario(node) {
         const tipoOperando = this.resolverTipo(node.operando);
         switch (node.operador) {
             case '-':
-                if (tipoOperando === 'numero' || tipoOperando === 'decimal')
+                if (tipoOperando === 'numero' || tipoOperando === 'decimal' || tipoOperando === 'moeda')
                     return tipoOperando;
                 break;
             case 'nao':
@@ -770,19 +794,24 @@ export class TypeChecker {
                     return 'booleano';
                 break;
         }
-        this.erro(`Operador unário '${node.operador}' não pode ser aplicado ao tipo '${tipoOperando}'`, node.line, node.column);
+        this.erro(`Operador unário '${node.operador}' não pode ser aplicado ao tipo '${tipoOperando}'`, node.line, node.column, "O operador 'nao' só funciona com booleanos; o operador '-' (negação) só funciona com numero e decimal");
         return 'desconhecido';
     }
     resolverTipoChamada(node) {
         const funcao = this.tabela.buscar(node.nome);
         if (!funcao || funcao.kind !== 'funcao') {
-            this.erro(`Função '${node.nome}' não encontrada`, node.line, node.column);
+            const funcoes = this.tabela.buscarTodosNomesVisiveis();
+            const sug = this.sugestao(node.nome, funcoes);
+            const dica = sug
+                ? `Você quis dizer '${sug}'? Verifique o nome ou declare-a: 'funcao ${node.nome}()'`
+                : `A função não foi declarada. Verifique o nome ou declare-a: 'funcao ${node.nome}()'`;
+            this.erro(`Função '${node.nome}' não encontrada`, node.line, node.column, dica);
             return 'desconhecido';
         }
         // Verificar número de argumentos
         const params = this.tabela.buscarParametrosFuncao(node.nome);
         if (params !== null && node.argumentos.length !== params.length) {
-            this.erro(`Função '${node.nome}' espera ${params.length} argumentos, recebeu ${node.argumentos.length}`, node.line, node.column);
+            this.erro(`Função '${node.nome}' espera ${params.length} argumentos, recebeu ${node.argumentos.length}`, node.line, node.column, `Passe exatamente ${params.length} argumento(s) na chamada de '${node.nome}'`);
         }
         return funcao.tipo === 'vazio' ? 'vazio' : funcao.tipo;
     }
@@ -810,7 +839,7 @@ export class TypeChecker {
         }
         const tipoCampo = this.tabela.buscarCampo(tipoObjeto, node.membro);
         if (tipoCampo === null) {
-            this.erro(`'${tipoObjeto}' não possui campo '${node.membro}'`, node.line, node.column);
+            this.erro(`'${tipoObjeto}' não possui campo '${node.membro}'`, node.line, node.column, `Verifique o nome do campo — pode estar digitado errado ou não existe na entidade/classe '${tipoObjeto}'`);
             return 'desconhecido';
         }
         return tipoCampo;
@@ -821,14 +850,28 @@ export class TypeChecker {
     tiposCompatíveis(esperado, recebido) {
         if (esperado === recebido)
             return true;
+        // 'desconhecido' suprime cascata de erros — erro já foi reportado na origem
+        if (esperado === 'desconhecido' || recebido === 'desconhecido')
+            return true;
+        // Strip modificadores opcionais/obrigatórios para comparação de base
+        const baseEsperado = esperado.replace(/[?!]$/, '');
+        const baseRecebido = recebido.replace(/[?!]$/, '');
+        if (baseEsperado === baseRecebido)
+            return true;
+        // 'qualquer' é compatível com qualquer tipo (escape hatch)
+        if (baseEsperado === 'qualquer' || baseRecebido === 'qualquer')
+            return true;
         // decimal aceita numero
-        if (esperado === 'decimal' && recebido === 'numero')
+        if (baseEsperado === 'decimal' && baseRecebido === 'numero')
+            return true;
+        // moeda aceita decimal (interop com valores monetários vindos de APIs)
+        if (baseEsperado === 'moeda' && baseRecebido === 'decimal')
             return true;
         // id aceita numero (IDs podem ser representados como números)
-        if (esperado === 'id' && recebido === 'numero')
+        if (baseEsperado === 'id' && baseRecebido === 'numero')
             return true;
         // Verificar herança de classes
-        if (this.verificarHeranca(esperado, recebido))
+        if (this.verificarHeranca(baseEsperado, baseRecebido))
             return true;
         return false;
     }
@@ -896,21 +939,24 @@ export class TypeChecker {
     }
     // Verifica se um tipo existe (primitivo, classe, entidade, enum declarado)
     tipoExiste(nome) {
-        const tiposPrimitivos = ['texto', 'numero', 'decimal', 'booleano', 'data', 'hora', 'id'];
-        if (tiposPrimitivos.includes(nome))
+        // Strip modificadores opcionais (?) e obrigatórios (!) antes de validar
+        const nomeBase = nome.replace(/[?!]$/, '');
+        const tiposPrimitivos = ['texto', 'numero', 'decimal', 'moeda', 'booleano', 'data', 'hora', 'id', 'qualquer', 'vazio', 'objeto'];
+        if (tiposPrimitivos.includes(nomeBase))
             return true;
         // Verificar tipos genéricos
-        if (nome.startsWith('lista<') && nome.endsWith('>')) {
-            const elementoTipo = nome.substring(6, nome.length - 1);
+        if (nomeBase.startsWith('lista<') && nomeBase.endsWith('>')) {
+            const elementoTipo = nomeBase.substring(6, nomeBase.length - 1);
             return this.tipoExiste(elementoTipo);
         }
-        if (nome.startsWith('mapa<') && nome.endsWith('>')) {
-            const partes = nome.substring(4, nome.length - 1).split(',');
+        if (nomeBase.startsWith('mapa<') && nomeBase.endsWith('>')) {
+            // 'mapa<' tem 5 chars — substring(5) descarta corretamente o prefixo com '<'
+            const partes = nomeBase.substring(5, nomeBase.length - 1).split(',');
             if (partes.length !== 2)
                 return false;
             return this.tipoExiste(partes[0].trim()) && this.tipoExiste(partes[1].trim());
         }
-        const simbolo = this.tabela.buscar(nome);
+        const simbolo = this.tabela.buscar(nomeBase);
         return simbolo !== null && ['classe', 'entidade', 'enum', 'interface'].includes(simbolo.kind);
     }
     // Converte TipoNode em string para comparação
@@ -949,15 +995,84 @@ export class TypeChecker {
         const tiposElementosValidos = ['tabela', 'formulario', 'botao', 'card', 'modal', 'grafico'];
         for (const elem of node.elementos) {
             if (!tiposElementosValidos.includes(elem.tipo)) {
-                this.erro(`Tipo de elemento '${elem.tipo}' inválido. Use: tabela, formulario, botao ou card`, elem.line, elem.column);
+                this.erro(`Tipo de elemento '${elem.tipo}' inválido. Use: tabela, formulario, botao ou card`, elem.line, elem.column, "Tipos válidos de elementos de tela: tabela, formulario, botao, card, modal ou grafico");
+                continue;
+            }
+            // grafico requer propriedade 'entidade'
+            if (elem.tipo === 'grafico') {
+                const temEntidade = elem.propriedades.some(p => p.chave === 'entidade');
+                if (!temEntidade) {
+                    this.erro(`Elemento grafico '${elem.nome}' deve declarar a propriedade 'entidade' com a fonte de dados`, elem.line, elem.column, "Informe a entidade de dados: entidade: NomeDaEntidade");
+                }
+            }
+            // Valida referência de entidade declarada na propriedade 'entidade:'
+            const propEntidade = elem.propriedades.find(p => p.chave === 'entidade');
+            if (propEntidade && typeof propEntidade.valor === 'string') {
+                const nomeEntidade = propEntidade.valor;
+                const simbolo = this.tabela.buscar(nomeEntidade);
+                if (!simbolo || simbolo.kind !== 'entidade') {
+                    this.erro(`Entidade '${nomeEntidade}' não declarada ou não encontrada`, elem.line, elem.column, `Declare a entidade antes de usá-la: entidade ${nomeEntidade} ... fim`);
+                }
+                else {
+                    // Valida campos referenciados na propriedade 'campos:'
+                    const propCampos = elem.propriedades.find(p => p.chave === 'campos');
+                    if (propCampos) {
+                        const listaCampos = Array.isArray(propCampos.valor)
+                            ? propCampos.valor
+                            : [propCampos.valor];
+                        for (const nomeCampo of listaCampos) {
+                            const tipoCampo = this.tabela.buscarCampo(nomeEntidade, nomeCampo);
+                            if (tipoCampo === null) {
+                                this.erro(`Campo '${nomeCampo}' não existe na entidade '${nomeEntidade}'`, elem.line, elem.column, `Verifique os campos disponíveis na entidade '${nomeEntidade}' e corrija o nome`);
+                            }
+                        }
+                    }
+                }
             }
-            // Referências a entidades em tela podem vir de outros módulos —
-            // resolução completa está prevista para v0.2.0 (sistema de módulos).
         }
     }
     // Adiciona erro sem lançar exceção (continua verificando o resto)
-    erro(mensagem, linha, coluna) {
-        this.erros.push({ mensagem, linha, coluna });
+    erro(mensagem, linha, coluna, dica) {
+        this.erros.push({ mensagem, linha, coluna, dica });
+    }
+    // ── "Você quis dizer X?" ─────────────────────────────────────────────────
+    levenshtein(a, b) {
+        const m = a.length, n = b.length;
+        const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+        for (let i = 1; i <= m; i++) {
+            for (let j = 1; j <= n; j++) {
+                dp[i][j] = a[i - 1] === b[j - 1]
+                    ? dp[i - 1][j - 1]
+                    : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+            }
+        }
+        return dp[m][n];
+    }
+    // Retorna o nome mais próximo de `nome` na lista `candidatos` se distância ≤ 2
+    sugestao(nome, candidatos) {
+        let melhor;
+        let menorDist = 3;
+        for (const c of candidatos) {
+            const dist = this.levenshtein(nome.toLowerCase(), c.toLowerCase());
+            if (dist < menorDist) {
+                menorDist = dist;
+                melhor = c;
+            }
+        }
+        return melhor;
+    }
+    TIPOS_BUILTIN = ['texto', 'numero', 'decimal', 'moeda', 'booleano', 'data', 'hora', 'id'];
+    sugestaoTipo(nome) {
+        const tiposConhecidos = [
+            ...this.TIPOS_BUILTIN,
+            ...this.tabela.buscarTodosNomesVisiveis()
+        ];
+        return this.sugestao(nome, tiposConhecidos);
+    }
+    dicaTipoNaoExiste(tipo) {
+        const sug = this.sugestaoTipo(tipo);
+        const base = 'Use um tipo válido: texto, numero, decimal, moeda, booleano, data, hora, id, ou o nome de uma entidade declarada';
+        return sug ? `Você quis dizer '${sug}'? ${base}` : base;
     }
 }
 //# sourceMappingURL=type_checker.js.map