go vet & Diagnósticos Comuns de Analisadores

go vet inspeciona o código Go em busca de construções que compilam, mas provavelmente estão erradas.

Toda equipe deve executar go vet ./... localmente e na CI, entender os diagnósticos comuns e saber quando analisadores mais profundos agregam valor.

Receita

Cartão de receita de referência rápida - pronto para copiar e colar.

# Todos os pacotes no módulo
go vet ./...
 
# Pacotes específicos
go vet ./internal/...
 
# Listar analisadores disponíveis (Go 1.26+)
go tool vet help
 
# Executar vet via test harness (algumas equipes preferem)
go test -vet=off ./...   # desabilitar vet durante o teste ao executar separadamente

Quando usar isso:

• Linha de base da CI antes de adicionar golangci-lint.
• Depurando falhas misteriosas de printf ou tags JSON.
• Após atualizar versões menores do Go (leia as notas de lançamento para novas verificações vet).
• Ensinando juniores por que o código "compila, mas parece errado".

Exemplo de Trabalho

Handler com bug:

package api
 
import (
    "encoding/json"
    "fmt"
    "net/http"
)
 
type User struct {
    Name string `json:name` // sintaxe de tag inválida
}
 
func Handler(w http.ResponseWriter, r *http.Request) {
    u := User{Name: "ada"}
    _ = json.NewEncoder(w).Encode(u)
    fmt.Printf("user %d", u.Name) // incompatibilidade de verbo de formato
}

Executar:

go vet ./...

Saída típica:

api/handler.go:12:2: fmt.Printf format %d has arg u.Name of wrong type string
api/handler.go:8:5: struct field tag `json:name` not compatible with reflect.StructTag.Get: bad syntax for struct tag pair

Código corrigido:

type User struct {
    Name string `json:"name"`
}
 
func Handler(w http.ResponseWriter, r *http.Request) {
    u := User{Name: "ada"}
    _ = json.NewEncoder(w).Encode(u)
    fmt.Printf("user %s", u.Name)
}

O que isso demonstra:

• Vet detecta erros de verbo Printf sem executar o programa.
• O analisador structtag valida a sintaxe da tag JSON antes de marshaling de surpresas em produção.
• Correções são alterações de código fonte, não supressões de linter.

Mergulho Profundo

Como Funciona

• Vet carrega pacotes usando o mesmo contexto de build do go test.
• Cada analisador é uma função registrada com o driver vet (muitos construídos sobre go/analysis).
• Diagnósticos incluem arquivo, linha e uma mensagem legível por humanos.
• Tags de build, GOOS e GOARCH afetam quais arquivos o vet examina.

Analisadores Vet Comuns (Representativo)

Relação com golangci-lint

O linter govet do golangci-lint envolve os analisadores vet e pode habilitar verificações adicionais.

Executar go vet sozinho é mais simples em scripts; golangci-lint centraliza severidade e exclusões.

# Trecho de .golangci.yml
linters:
  enable:
    - govet
linters-settings:
  govet:
    enable-all: true

Notas do Go

// Exemplo de copylocks - vet sinaliza a cópia de sync.Mutex
type Bad struct {
    mu sync.Mutex
}
 
func use(b Bad) { // vet: passa o lock por valor
    b.mu.Lock()
}

Prefira receptores de ponteiro ou não incorpore locks em structs copiadas.

Quando Vet Não é Suficiente

Armadilhas

• Assumir que vet não muda entre atualizações do Go - Novas versões menores adicionam verificações; a CI pode falhar em código legado. Correção: Leia as notas de lançamento; execute go vet no branch de atualização cedo.
• Executar vet apenas em pacotes main - Bugs se escondem em internal/. Correção: Sempre go vet ./....
• Ignorar copylocks em caminhos de alta performance - Passar structs com locks copia o estado do mutex. Correção: Use ponteiros ou redesenhe a API.
• Suprimir avisos de printf - Quase sempre um bug real. Correção: Corrija o verbo ou use %v deliberadamente com um comentário.
• Tags de build incompatíveis entre editor e CI - Vet ignora arquivos que a CI não vê. Correção: Alinhe as tags nas configurações do gopls e GOFLAGS da CI.
• Usar //nolint:govet amplamente - Esconde futuros problemas reais. Correção: Restrinja as supressões a uma única linha com um ticket de justificativa.

Alternativas

FAQs

Relacionados

• Qualidade de Código Go: Opinião por Design - visão geral da stack de qualidade
• Noções Básicas de Qualidade de Código - primeira invocação do vet
• Configuração do golangci-lint - configurações do govet
• staticcheck & golangci-lint na CI - analisadores mais profundos
• Portões de Qualidade da CI: Lint, Test, Race, Vuln - vet no pipeline

Versões da Stack: Esta página foi escrita para Go 1.26.x (GC padrão Green Tea, go fix modernizadores - verifique o patch na compilação), chi (última versão - verifique na compilação), gin (última versão - verifique na compilação), echo (última versão - verifique na compilação), google.golang.org/grpc (última versão - verifique na compilação), sigs.k8s.io/controller-runtime (última versão - verifique na compilação), kubebuilder (última versão - verifique na compilação), tinygo (última versão - verifique os alvos de placa na compilação), wazero (última versão - verifique na compilação) e golangci-lint (última versão - verifique o conjunto de linters na compilação).