Referência de Diagnósticos

A igualdade entre floats é imprecisa. Use `~=` (tolerância adaptativa), `!~=`, ou `math.approx_eq_abs/_rel(...)`. Para comparações exatas, use o tipo `decimal`.

Uma variável `let` ou parâmetro nunca é lida. Prefixe o nome com `_` para silenciar o lint intencionalmente.

Uma função top-level nunca é chamada e não está marcada com `pub`, `@test`, `@bench`, `@export`, rota HTTP ou `main`.

Um nome importado nunca é referenciado no arquivo.

Um `let` re-vincula um nome de um escopo externo. Shadowing às vezes é intencional; renomeie um dos bindings para silenciar o aviso.

Código depois de `return`, `break` ou `continue` é inalcançável.

Funções/variáveis usam `snake_case`; structs/enums/traits/efeitos usam `PascalCase`.

Uma função ou tipo anotado com `@must_use` retornou um valor que o chamador descartou. Vincule-o (`let _ = ...`) ou consuma-o.

Uma função anotada com `@deprecated` foi chamada. A mensagem da anotação explica a substituição.

Um bloco `loop`/`while true` não tem nenhum `break`/`return` alcançável.

Um uso de `Some(...)` / `None` / `?.` / `??` que parece um erro de digitação ou mau uso da API de opcional.

Um `match` sobre um enum não cobre todas as variantes e não tem um braço curinga `_`.

Um padrão nunca casa porque um braço anterior já o cobre.

Configurado via lint config do projeto. O padrão é permissivo; aperte no CI se quiser limites rígidos.

Aninhamento profundo prejudica a legibilidade. Extraia helpers ou use guard clauses com return cedo.

Listas longas de parâmetros são um code-smell. Considere agrupar parâmetros relacionados em uma struct.

Quebre a função em helpers menores.

Apenas `@repr(C)`, `@repr(packed)`, `@repr(transparent)` e `@repr(zolo)` são reconhecidos.

`transparent` só se aplica a structs newtype com um único campo.

`@layout` só tem efeito junto com um `@repr` explícito.

Alinhamento deve ser uma potência de dois positiva.

Regras de alinhamento de hardware exigem valores que sejam potência de dois (1, 2, 4, 8, ...).

O alinhamento solicitado excede o máximo suportado pela plataforma alvo.

O tamanho não pode ser zero nem negativo.

O lexer chegou ao fim do arquivo (ou da linha, em certos contextos) antes de encontrar a aspa de fechamento da string.

O parser esperava um token específico (por exemplo `}`, `)`, identificador, tipo) mas encontrou outra coisa. Geralmente uma chave, parêntese ou pontuação ausente.

Um token apareceu onde a gramática não permite — tipicamente um símbolo perdido, palavra-chave digitada errada ou separador ausente na linha anterior.

Um erro de parsing que não casou com nenhum classificador específico. Leia a mensagem do diagnóstico para a causa precisa.

Um comentário `<!-- -->` foi escrito entre `<` e `>`, onde o próprio HTML também não permite. Dentro da tag, use os comentários de Zolo: `//` ou `/* */`. Nos filhos de um elemento, `<!-- -->` funciona normalmente.

`<style>` e `<script>` são raw text elements: o conteúdo corre verbatim até o `</style>`/`</script>` correspondente, sem markup aninhado e sem interpolação `{expr}`. Chegar ao fim do arquivo antes desse fechamento reporta TE139 em vez da mensagem genérica "unclosed element" — geralmente uma tag de fechamento esquecida, ou uma string no formato `</tag` dentro do conteúdo (por exemplo, um literal de string JS) que fechou o bloco cedo demais.

Equivalente a `TE001`. Emitido pelo classificador legado quando o novo typeck não anexou um código.

Alias legado para `TE100`.

Alias legado para `TE101`.

Alias legado para `TE004`. A variável foi declarada com `let`; use `let mut` para permitir reatribuição.

Alias legado para `TE102`.

Um literal de struct omite um ou mais campos obrigatórios.

Alias legado para `TE110`.

O valor retornado não corresponde ao tipo de retorno declarado pela função.

Um nome (função, variável, campo, variante) foi declarado duas vezes no mesmo escopo.

Uma anotação de tipo se refere a um tipo que o compilador não consegue encontrar.

O valor atribuído a um binding `let` não satisfaz a anotação de tipo declarada.

O valor atribuído a um binding `const` não satisfaz a anotação de tipo declarada.

`const` exige uma expressão constant-foldable. Use `let` para valores de runtime.

Bindings `let` são imutáveis por padrão. Use `let mut x = ...` para permitir reatribuição, ou crie um novo binding com shadowing via `let`.

Operadores como `+=`, `-=`, `*=` exigem que ambos os lados sejam numéricos (ou strings, para `+=`).

A função declarou um retorno em tupla, mas a instrução `return` fornece menos valores.

A função retorna mais valores do que seu tipo de retorno único pode comportar.

Um literal de array mistura tipos incompatíveis; arrays são homogêneos.

Aritmética binária exige que ambos os operandos sejam numéricos e (em modo strict) do mesmo tipo numérico.

O nome não está declarado em nenhum escopo envolvente. O compilador anexa uma sugestão "quis dizer?" quando existe um nome similar.

O alvo de uma expressão de chamada não é um tipo invocável.

A struct não declara este campo. Sugestões "quis dizer?" são anexadas para nomes similares.

Uma anotação de tipo ou campo de variante de enum se refere a um tipo que o compilador não consegue resolver.

O tipo receptor não tem um método com esse nome. Verifique a grafia, os imports e a visibilidade do trait.

Um nome simples corresponde a um módulo conhecido da biblioteca padrão (`math`, `json`, `http`, `os`, …) que nunca foi trazido ao escopo. Diferente do TE100, o compilador reconhece o nome e diz exatamente qual linha `use` está faltando.

Um literal de struct omite um campo que não tem valor padrão nem zero-value de fallback. Todo campo sem default precisa ser fornecido explicitamente na construção.

Um struct com `@derive(Default)` tem um campo cujo tipo não possui zero-value nem default explícito, então nenhuma impl de `Default` pode ser sintetizada.

Um campo de struct foi escrito sem anotação de tipo, contando com o valor padrão para inferi-lo (`nome = valor`) — mas o tipo do padrão é ambíguo (ex.: `nil`, ou uma expressão que resolve para `any`).

O número de argumentos passados não corresponde à quantidade de parâmetros da função.

O tipo de um argumento não corresponde ao tipo do parâmetro correspondente.

Dois ou mais campos embutidos com `using` declaram um campo de mesmo nome, então um acesso `.campo` no struct externo não sabe de qual embed promovê-lo.

Um campo marcado com `using` precisa embutir outro struct — são os campos dele que são promovidos. Um escalar, ou qualquer tipo que não seja uma declaração de struct conhecida, não tem campos a promover.

Um enum optou por discriminantes numéricos (tipo de backing, ou um `= n` explícito) mas é genérico ou tem variante com payload. Discriminantes só fazem sentido para enums planos, com todas as variantes unitárias.

O discriminante de uma variante está fora da faixa do tipo de backing declarado (`enum E: u8` limita a `0..=255`), então não sobreviveria ao ida-e-volta de `to_int()`/`from_int()`.

Duas variantes do mesmo enum resolveram para o mesmo inteiro — ou dois `= n` explícitos colidem, ou um valor auto-incrementado caiu em cima de um já usado.

Sob `@stable` o auto-incremento é proibido: inserir uma variante no meio renumeraria silenciosamente todas as seguintes, quebrando a codificação que a anotação promete manter.

O discriminante `= expr` de uma variante ou não avaliou para inteiro em tempo de compilação, ou não pôde ser avaliado como constante de compilação.

Um enum `@flags` é genérico ou tem variante com payload. `@flags` modela uma bitmask sobre um conjunto fixo e plano de variantes unitárias — não há espaço para parâmetros de tipo ou payloads.

Cada variante `@flags` precisa ser um bit novo (auto-incrementado ou potência de dois explícita) ou um composto nomeado construído só a partir de bits declarados acima dela.

O valor de uma flag está fora da faixa do tipo de backing do enum — flags em `enum: u8` param em `255` (bit 7).

Duas flags de bit único no mesmo enum `@flags` resolveram para o mesmo bit, normalmente porque receberam o mesmo valor explícito.

Um padrão de destructuring — `let Struct { … } = expr`, um `let { … }` anônimo, um padrão de parâmetro ou uma atribuição com destructuring de struct — nomeia um campo que o struct não tem.

O bloco `else` pode cair para fora. Se caísse, a execução seguiria para os bindings do padrão com um valor que NÃO casou — por isso todo caminho pelo `else` precisa retornar, panicar, quebrar ou continuar.

O padrão pode não casar (padrão de variante de enum, padrão de tamanho de array, …) e não tem cláusula `else`. Sem ela, um valor que não casa ligaria lixo silenciosamente.

Um padrão de struct anônimo precisa saber qual struct está desestruturando, mas o tipo do valor não resolve para um struct concreto — normalmente por falta de anotação de tipo.

Um padrão de struct nomeado em posição de parâmetro (`fn f(NomeStruct { … }: T)`) nomeia um struct diferente da anotação de tipo do próprio parâmetro.

O spread final de um literal de struct (`Struct { ..origem }`) tem uma `origem` que não é struct nem record, então não há campos a espalhar.

Uma atribuição com destructuring de tupla (`(a, b, c) = expr`) tem um número de alvos diferente do número de valores de `expr`.

Operadores compostos (`+=`, `-=`, …) não têm significado por elemento quando o lado esquerdo é um padrão inteiro, e o spread `..` não faz sentido como alvo de atribuição.

Um argumento nomeado (`f(nome: valor)`) não corresponde aos parâmetros declarados da função chamada — nome desconhecido ou duplicado, um argumento posicional depois de um nomeado, um parâmetro do meio pulado, ou uma chamada cuja assinatura não é conhecida localmente.

O placeholder `_` só é válido como argumento direto na chamada do lado direito (RHS) de um estágio de pipe `|>`/`?>` (no máximo um por estágio), ou como a cabeça de uma cadeia de campo/método/índice usada como argumento de chamada (`_.campo`). Um `_` solto, um segundo `_` no mesmo estágio de pipe, ou `_` como lado esquerdo de um pipe são todos rejeitados.

Um enum real e declarado foi identificado para este ponto — como base de `EnumName::variante`, ou como tipo do valor testado por um pattern com atalho `.variante` — mas o nome da variante não corresponde a nenhuma variante declarada. Uma sugestão "quis dizer?" é incluída na mensagem quando existe um nome próximo.

O atalho `.Variante` descobre seu enum a partir do tipo esperado pela posição onde aparece, e esta posição não fornece nada utilizável — nenhum tipo esperado (um `let` sem anotação, um argumento de uma função cuja assinatura não é conhecida), um parâmetro genérico ainda não fixado, ou um tipo que não é um enum. Anote a variável ou escreva a forma qualificada `Enum::Variante`.

O atalho `.Variante` resolveu seu enum a partir do tipo esperado pela posição, mas esse enum não tem nenhuma variante com esse nome. Uma sugestão "quis dizer?" é incluída quando existe um nome próximo. A forma de pattern do mesmo erro reporta `TE133` em vez deste código.

O nome faz parte do prelúdio sempre-em-escopo da VM, mas o backend native/LLVM não tem implementação para ele. Compilar assim mesmo faria o nome virar `nil` silenciosamente e sair com 0 — por isso o build falha.

Check exclusivo de native/LLVM: um identificador simples não resolveu para nada. Sem prelúdio Lua de fallback, ele viraria `nil` silenciosamente em runtime — a classe "typo vira no-op quieto" que isso pega em tempo de build.

A tipagem strict exige que todo `let`/`const` tenha uma anotação de tipo explícita.

A tipagem strict exige que todo parâmetro de função tenha um tipo explícito.

O número de argumentos de tipo fornecidos não corresponde à quantidade de parâmetros do tipo genérico.

Um bound de trait, bloco `impl` ou cláusula `where` faz referência a um trait que o compilador não encontra.

`@(expr)` compila para uma ponte de custom property de CSS (`var(--…)`), que só existe em valores de declaração — depois do `:`, antes do `;`. Em seletor, nome de propriedade ou prelúdio de at-rule não há `var()` para a ponte compilar, e splice de texto do usuário ali é anti-feature deliberada. Mova a parte dinâmica para um valor, ou alterne classes estáticas no markup.

Um `<style children={expr}>` carrega conteúdo de runtime que o compilador não enxerga — não dá para içar nem escopar; escopar texto desconhecido seria mentira. Spec §6.1: conteúdo dinâmico precisa optar por `global` explicitamente (`<style global children={…}>`), a única forma de style que continua sendo nó de render.

Um valor de `@()` viaja como custom property de CSS, e só `str`, `int` e `float` serializam para uma. Valor tipado `bool`, `View`, map, struct ou função é rejeitado em compilação — no render viraria lixo ou sumiria. Valores sem tipo (`Any`) ficam em silêncio: este erro nunca chuta.

`@()` compila para `var(--…)`, e CSS não concatena strings em valores comuns — `var(--w)px` é erro de sintaxe que o browser descarta, não "número mais unidade". Escreva `calc(@(x) * 1px)` ou interpole a string inteira (`@(f"{x}px")` — dentro de `@()` você está de volta em Zolo). `!important`, `/` e `*` em `calc()` são vizinhos sem espaço legais.

`:global(…)` isenta um compound do carimbo de escopo hermético. Um wrapper vazio (`:global()`) não isenta nada, e um aninhado (`:global(:global(a))`) escapa de um escape — os dois só podem ser engano. Num corpo `<style global>`, `:global()` nem é sintaxe Zolo e passa intacto.

Aviso, nunca falha de build. O escopo hermético carimba cada compound com a classe do componente, então um seletor que nomeia classe/id/tag que o markup do próprio componente nunca produz é regra morta — e `:root` sob escopo é estruturalmente morto. Vem com "quis dizer?" (distância de edição ≤ 2) e o conjunto renderizado do componente. Valores dinâmicos de class/id ou chamadas `el`/`raw` abrem o conjunto e suprimem o aviso — ele nunca chuta.

Um `<style>` escopado pertence ao fn de componente que o cerca — o carimbo de classe do fn é o escopo dos seletores. Em statement top-level ou método de `impl`/`trait` não há componente, logo não há escopo. Adicione `global` (um `<style global>` estático fora de componente renderiza no lugar) ou mova para um fn de componente. Corpo com `@()` reporta isso mesmo com `global`: os valores precisam de um elemento-raiz de componente.

Todo valor de `@()` viaja como custom property de CSS no elemento-raiz do componente (o literal de elemento em posição de cauda), herdando DOM abaixo. Um componente que delega a view inteira — sem raiz de elemento própria — não dá onde os valores andarem. Faça a cauda ser um literal de elemento (um `<div>` de embrulho serve) ou remova a interpolação.

Aviso, nunca falha de build. Nomes de propriedade são checados contra uma tabela curada que vem com a toolchain (dado estático, sem download de registry); um quase-acerto volta com "quis dizer?" (distância de edição ≤ 2). Nomes começando com `-` — prefixos de vendor e custom properties `--` — nunca são checados, nem descritores de at-rule (o `src` de `@font-face`, …). Propriedade mais nova que a tabela custa um sublinhado, nunca um release.

Uma função genérica foi chamada com um argumento de tipo que não implementa um trait exigido por um de seus bounds.

Um operador é usado sobre um parâmetro de tipo genérico que não carrega o trait bound correspondente. Sem ele, o compilador não garante que a operação vale para todo argumento de tipo possível.

Um bound na assinatura da função nomeia um trait que o compilador não conhece.

Um operador é usado sobre um valor de struct/enum concreto cujo tipo não implementa o trait exigido. Sem ele não há método para dirigir o operador, e quebraria em runtime.

Caminhos qualificados de trait precisam ser `core::<módulo>::<Trait>` ou `std::<módulo>::<Trait>`, nomeando um `pub trait` realmente declarado ali — tanto em bound genérico quanto em cabeçalho de `impl`.

Um `impl Trait for Tipo` está sem um ou mais métodos obrigatórios (os que não têm corpo padrão). Sem eles, o despacho de método e operador quebraria em runtime.

Um método de coleção (`each`, `filter`, `len`, …) foi chamado diretamente sobre um wrapper `Result` ou `Option`. Desembrulhe-o primeiro com `?>`, `?` ou `.unwrap()`.

`?.` é encadeamento null-safe, não desembrulhamento falível. Um `Result` ou `Option` nunca é `nil`, então o encadeamento opera sobre o wrapper. Use `expr ?> .m(...)`, `let v = expr?` ou `expr!.m(...)` em vez disso.

`for x in expr` exige que `expr` produza uma sequência. Zolo itera coleções nativas e qualquer tipo que implemente `Iterator`/`IntoIterator`; um struct ou enum que não implementa nenhum dos dois não dá nada ao laço.

Um tagged template `tag"…"` não é sintaxe especial — ele se reduz a uma chamada comum a uma função chamada `tag`, e nenhuma função com esse nome está em escopo.

`parallel { … }` roda cada statement de topo como sua própria task concorrente, então todo statement do bloco precisa ser uma expressão que possa virar uma.

Uma função executa um efeito (`!io`, `!net`, `!fs`, ...) que não declarou em sua assinatura.

Um efeito foi executado mas nenhum bloco `handle` envolvente o trata.

Um bloco `handle` tenta tratar uma operação que o efeito não declarou.

Um bloco `handle` está sem a implementação de uma das operações declaradas pelo efeito.

O handler referencia um nome de operação que não existe no efeito.

Uma assinatura de função ou handler faz referência a um efeito que o compilador não encontra.

Uma chamada `perform` ou operação de handler não corresponde à assinatura declarada do efeito.

`handle … with <handler_valor>` usa um handler-valor que cobre só parte das operações do efeito. O erro aparece no `with` e nomeia as operações faltantes.

Uma chamada `perform Efeito::op(…)` passou um argumento cujo tipo não corresponde ao tipo do parâmetro declarado da operação.

A forma resumida do TE800: em vez de reportar cada `perform`, junta todos os efeitos que a função de fronteira realmente precisa e reporta todos na assinatura.

É um aviso, não uma falha de build. Um bloco `handle` usando um handler-valor com anotação explícita `handler<…>` cobre um efeito que o corpo tratado nunca realiza.

Um parâmetro genérico é usado tanto como parâmetro de tipo quanto como cauda de variável de linha numa cláusula `with` (`{Fs | e}`). Um mesmo nome não pode significar um tipo e um conjunto de efeitos extras ao mesmo tempo.

Um `perform` mira uma operação declarada `multi` (retomável mais de uma vez). Continuações multi-shot hoje são exclusivas da VM.

O parâmetro de tipo de um efeito genérico não resolveu num `perform` — nem os tipos dos argumentos nem um `with Efeito<Concreto>` deram um tipo concreto.

`h` precisa ser algo cujo tipo seja `handler<…>`. Se resolver para outra coisa, não há conjunto de braços para despachar as operações realizadas.

Uma invariante de runtime que o compilador emitiu código para verificar (por exemplo, bounds, divisão por zero em const eval) foi violada.