golangci-lint が 0 issues で通す違反

level=info msg="[runner] processing took 8.095041ms with stages: diff: 7.985846ms, source_code: 41.076µs, nolint_filter: 32.08µs, (中略) fixer: 411ns, (中略) exclusion_rules: 301ns, exclusion_paths: 292ns, severity-rules: 120ns"

-n, --new   Show only new issues: if there are unstaged changes or untracked files, only those changes are analyzed, else only changes in HEAD~ are analyzed.
            For CI setups, prefer --new-from-rev=HEAD~, as --new can skip linting the current patch if any scripts generate unstaged files before golangci-lint runs.

# .golangci.yaml
version: "2"
linters:
  default: none
  enable: [errcheck, unused]
issues:
  new: true

// old.go (1 つ目のコミット)
package n

import "os"

func helper() {}

func Old() {
	helper()
	os.Remove("old.txt")
}

// new.go (2 つ目のコミット)
package n

import "os"

func New() {
	os.Remove("new.txt")
}

$ golangci-lint run
new.go:6:11: Error return value of `os.Remove` is not checked (errcheck)
1 issues:

$ golangci-lint run --new=false
new.go:6:11: Error return value of `os.Remove` is not checked (errcheck)
old.go:9:11: Error return value of `os.Remove` is not checked (errcheck)
2 issues:

 func helper() {}
 
 func Old() {
-	helper()
 	os.Remove("old.txt")
 }

$ golangci-lint run
0 issues.
(exit 0)

$ golangci-lint run --new=false
new.go:6:11: Error return value of `os.Remove` is not checked (errcheck)
old.go:8:11: Error return value of `os.Remove` is not checked (errcheck)
old.go:5:6: func helper is unused (unused)
3 issues:

$ golangci-lint run --new-from-rev=HEAD --whole-files
old.go:8:11: Error return value of `os.Remove` is not checked (errcheck)
old.go:5:6: func helper is unused (unused)
2 issues:

$ git clone --depth 1 file:///path/to/repo shallow && cd shallow
$ golangci-lint run
level=warning msg="[runner] Can't process results by diff processor: can't prepare diff by revgrep: could not read git repo: error executing \"git diff --color=never --no-ext-diff --default-prefix --relative HEAD~ --\": exit status 128: fatal: bad revision 'HEAD~'\n"
new.go:6:11: Error return value of `os.Remove` is not checked (errcheck)
old.go:9:11: Error return value of `os.Remove` is not checked (errcheck)
2 issues:

lint:     ; golangci-lint run              # 手元: 差分のみ
lint-all: ; golangci-lint run --new=false  # CI: 全件

# .golangci.yaml
version: "2"
linters:
  default: none
  enable: [modernize]
issues:
  new: true
  fix: true

// main.go
package main

import "fmt"

func main() {
	n := 3
	for i := 0; i < n; i++ {
		fmt.Println(i)
	}
}

$ golangci-lint run --new=false --fix=false
main.go:7:6: rangeint: for loop can be modernized using range over int (modernize)
1 issues:
(exit 1)

$ golangci-lint run --new=false
0 issues.
(exit 0)

$ git diff
-	for i := 0; i < n; i++ {
+	for i := range n {

golangci-lint run --new=false --fix=false
git diff --exit-code   # linter がソースを書き換えていたら exit 1

// main.go (抜粋。行番号付き)
15	_ = exec.Command(bin())                          // 1. 抑止なし
16	_ = exec.Command(bin())                          //nosec
17	_ = exec.Command(bin())                          // #nosec
18	_ = exec.Command(bin())                          // #nosec G204 -- 呼び出し元を信頼する
19	_ = exec.Command(bin())                          //nolint:gosec // 呼び出し元を信頼する
20	_ = exec.Command(bin())                          //nolint:errcheck
21	_ = exec.CommandContext(ctx, argv[0], argv[1:]...) // #nosec G204 -- 呼び出し元を信頼する
22	_ = exec.CommandContext(ctx, argv[0], argv[1:]...) // #nosec G204,G702 -- 呼び出し元を信頼する

// store.go
package b

func Save(id string) error { return nil }

// store_dev_test.go
//go:build devfirestore

package b

import "testing"

func TestSaveDev(t *testing.T) {
	if err := Save("x"); err != nil {
		t.Fatal(err)
	}
}

$ golangci-lint run
0 issues.
(exit 0)

$ go vet ./...
(exit 0)

$ golangci-lint run --build-tags=devfirestore
store.go:1: : # example.com/b [example.com/b.test]
./store_dev_test.go:8:12: undefined: Save (typecheck)
package b
1 issues:
* typecheck: 1
(exit 1)

run:
  build-tags:
    - devfirestore

// s.go
package s

import "errors"

var userId = 1

func Get() (int, error) {
	if userId == 0 {
		return 0, errors.New("Not found.")
	}
	return userId, nil
}

// s_test.go
package s

import "errors"

var testUserId = 2

func check() error { return errors.New("Bad input.") }

# 既定
s.go:9:13: ST1005: error strings should not end with punctuation or newlines (staticcheck)
1 issues:

# checks: [all]
s.go:1:1: ST1000: at least one file in a package should have a package comment (staticcheck)
s.go:5:5: ST1003: var userId should be userID (staticcheck)
s.go:9:13: ST1005: error strings should not end with punctuation or newlines (staticcheck)
s_test.go:5:5: ST1003: var testUserId should be testUserID (staticcheck)
4 issues:

linters:
  settings:
    staticcheck:
      checks: [all, -ST1000]

// main.go
package main

import (
	"context"
	"log/slog"
)

type handler struct{ lg *slog.Logger }

func main() {
	ctx := context.Background()
	slog.Info("a")
	slog.Default().InfoContext(ctx, "b")
	lg := slog.Default()
	lg.InfoContext(ctx, "c")
	h := handler{lg: lg}
	h.lg.WarnContext(ctx, "d")
}

linters:
  settings:
    forbidigo:
      analyze-types: true
      forbid:
        - pattern: ^slog\.Logger\.(Debug|Info|Warn|Error|Log)(Context|Attrs)?$
        - pattern: ^slog\.(Debug|Info|Warn|Error)(Context)?$

main.go:12:2: use of `slog.Info` forbidden by pattern `^slog\.(Debug|Info|Warn|Error)(Context)?$` (forbidigo)
main.go:13:2: use of `slog.Default().InfoContext` forbidden by pattern `^slog\.Logger\.(Debug|Info|Warn|Error|Log)(Context|Attrs)?$` (forbidigo)
main.go:15:2: use of `lg.InfoContext` forbidden by pattern `^slog\.Logger\.(Debug|Info|Warn|Error|Log)(Context|Attrs)?$` (forbidigo)
main.go:17:2: use of `h.lg.WarnContext` forbidden by pattern `^slog\.Logger\.(Debug|Info|Warn|Error|Log)(Context|Attrs)?$` (forbidigo)
4 issues:

linters:
  settings:
    exhaustive:
      check: [switch, map]
      default-signifies-exhaustive: true   # default のある switch は網羅済み扱い

// typed.go
package e

type RequestStatus string

const (
	StatusActive   RequestStatus = "active"
	StatusCanceled RequestStatus = "canceled"
	StatusDone     RequestStatus = "done"
)

func Label(s RequestStatus) string {
	switch s {
	case StatusActive:
		return "進行中"
	case StatusCanceled:
		return "取消"
	}
	return ""
}

var labels = map[RequestStatus]string{
	StatusActive:   "進行中",
	StatusCanceled: "取消",
}

var allowedStatus = []RequestStatus{StatusActive, StatusCanceled}

func LabelWithDefault(s RequestStatus) string {
	switch s {
	case StatusActive:
		return "進行中"
	default:
		return ""
	}
}

// untyped.go
package e

const (
	PlanActive   = "active"
	PlanCanceled = "canceled"
	PlanDone     = "done"
)

func PlanLabel(s string) string {
	switch s {
	case PlanActive:
		return "進行中"
	case PlanCanceled:
		return "取消"
	}
	return ""
}

var planLabels = map[string]string{
	PlanActive:   "進行中",
	PlanCanceled: "取消",
}

var allowed = []string{PlanActive, PlanCanceled}

typed.go:12:2: missing cases in switch of type e.RequestStatus: e.StatusDone (exhaustive)
typed.go:21:14: missing keys in map of key type e.RequestStatus: e.StatusDone (exhaustive)
2 issues:

// g.go
// Package g is a sample.
package g

import "strings"

// Join joins a and b with a colon.
func Join(a, b string) string {
	var sb strings.Builder
	sb.WriteString(a + ":" + b)
	return sb.String()
}

$ golangci-lint run      # linters.default: all。非推奨 linter の警告行は省略
g.go:10:2: return with no blank line before (nlreturn)
g.go:9:2: expressions should not be cuddled with declarations or returns (wsl)
2 issues:

$ gopls check g.go
/path/to/g.go:9:2-29: Inefficient string concatenation in call to WriteString
(exit 0)

$ strings "$(command -v gopls)" | grep -c 'Inefficient string concatenation'
1
$ strings "$(command -v golangci-lint)" | grep -c 'Inefficient string concatenation'
0

lint-gopls:
	@out=$$(gopls check $$(git ls-files --cached --others --exclude-standard '*.go')); \
	if [ -n "$$out" ]; then echo "$$out"; exit 1; fi