Linters

To see a list of supported linters and which linters are enabled/disabled:

Copy
golangci-lint help linters

Enabled by Default

Disabled by Default

Linters Configuration

asasalint

Check for pass []any as any in variadic func(...any).

Copy
linters:
  settings:
    asasalint:
      # To specify a set of function names to exclude.
      # The values are merged with the builtin exclusions.
      # The builtin exclusions can be disabled by setting `use-builtin-exclusions` to `false`.
      # Default: ["^(fmt|log|logger|t|)\.(Print|Fprint|Sprint|Fatal|Panic|Error|Warn|Warning|Info|Debug|Log)(|f|ln)$"]
      exclude:
        - Append
        - \.Wrapf
      # To enable/disable the asasalint builtin exclusions of function names.
      # See the default value of `exclude` to get the builtin exclusions.
      # Default: true
      use-builtin-exclusions: false

bidichk

Checks for dangerous unicode character sequences.

Copy
linters:
  settings:
    bidichk:
      # The following configurations check for all mentioned invisible Unicode runes.
      # All runes are enabled by default.
      left-to-right-embedding: false
      right-to-left-embedding: false
      pop-directional-formatting: false
      left-to-right-override: false
      right-to-left-override: false
      left-to-right-isolate: false
      right-to-left-isolate: false
      first-strong-isolate: false
      pop-directional-isolate: false

copyloopvar

A linter detects places where loop variables are copied.

Copy
linters:
  settings:
    copyloopvar:
      # Check all assigning the loop variable to another variable.
      # Default: false
      check-alias: true

cyclop

Checks function and package cyclomatic complexity.

Copy
linters:
  settings:
    cyclop:
      # The maximal code complexity to report.
      # Default: 10
      max-complexity: 10
      # The maximal average package complexity.
      # If it's higher than 0.0 (float) the check is enabled.
      # Default: 0.0
      package-average: 0.5

decorder

Check declaration order and count of types, constants, variables and functions.

Copy
linters:
  settings:
    decorder:
      # Required order of `type`, `const`, `var` and `func` declarations inside a file.
      # Default: types before constants before variables before functions.
      dec-order:
        - type
        - const
        - var
        - func
      # If true, underscore vars (vars with "_" as the name) will be ignored at all checks.
      # Default: false (underscore vars are not ignored)
      ignore-underscore-vars: false
      # If true, order of declarations is not checked at all.
      # Default: true (disabled)
      disable-dec-order-check: false
      # If true, `init` func can be anywhere in file (does not have to be declared before all other functions).
      # Default: true (disabled)
      disable-init-func-first-check: false
      # If true, multiple global `type`, `const` and `var` declarations are allowed.
      # Default: true (disabled)
      disable-dec-num-check: false
      # If true, type declarations will be ignored for dec num check.
      # Default: false (type statements are not ignored)
      disable-type-dec-num-check: false
      # If true, const declarations will be ignored for dec num check.
      # Default: false (const statements are not ignored)
      disable-const-dec-num-check: false
      # If true, var declarations will be ignored for dec num check.
      # Default: false (var statements are not ignored)
      disable-var-dec-num-check: false

depguard

Go linter that checks if package imports are in a list of acceptable packages.

Copy
linters:
  settings:
    depguard:
      # Rules to apply.
      #
      # Variables:
      # - File Variables
      #   Use an exclamation mark `!` to negate a variable.
      #   Example: `!$test` matches any file that is not a go test file.
      #
      #   `$all` - matches all go files
      #   `$test` - matches all go test files
      #
      # - Package Variables
      #
      #   `$gostd` - matches all of go's standard library (Pulled from `GOROOT`)
      #
      # Default (applies if no custom rules are defined): Only allow $gostd in all files.
      rules:
        # Name of a rule.
        main:
          # Defines package matching behavior. Available modes:
          # - `original`: allowed if it doesn't match the deny list and either matches the allow list or the allow list is empty.
          # - `strict`: allowed only if it matches the allow list and either doesn't match the deny list or the allow rule is more specific (longer) than the deny rule.
          # - `lax`: allowed if it doesn't match the deny list or the allow rule is more specific (longer) than the deny rule.
          # Default: "original"
          list-mode: lax
          # List of file globs that will match this list of settings to compare against.
          # By default, if a path is relative, it is relative to the directory where the golangci-lint command is executed.
          # The placeholder '${base-path}' is substituted with a path relative to the mode defined with `run.relative-path-mode`.
          # The placeholder '${config-path}' is substituted with a path relative to the configuration file.
          # Default: $all
          files:
            - "!**/*_a _file.go"
          # List of allowed packages.
          # Entries can be a variable (starting with $), a string prefix, or an exact match (if ending with $).
          # Default: []
          allow:
            - $gostd
            - github.com/OpenPeeDeeP
          # List of packages that are not allowed.
          # Entries can be a variable (starting with $), a string prefix, or an exact match (if ending with $).
          # Default: []
          deny:
            - pkg: "math/rand$"
              desc: use math/rand/v2
            - pkg: "github.com/sirupsen/logrus"
              desc: not allowed
            - pkg: "github.com/pkg/errors"
              desc: Should be replaced by standard lib errors package

dogsled

Checks assignments with too many blank identifiers (e.g. x, , , _, := f()).

Copy
linters:
  settings:
    dogsled:
      # Checks assignments with too many blank identifiers.
      # Default: 2
      max-blank-identifiers: 3

dupl

Detects duplicate fragments of code.

Copy
linters:
  settings:
    dupl:
      # Tokens count to trigger issue.
      # Default: 150
      threshold: 100

dupword

Checks for duplicate words in the source code.

Copy
linters:
  settings:
    dupword:
      # Keywords for detecting duplicate words.
      # If this list is not empty, only the words defined in this list will be detected.
      # Default: []
      keywords:
        - "the"
        - "and"
        - "a"
      # Keywords used to ignore detection.
      # Default: []
      ignore:
        - "0C0C"

errcheck

Errcheck is a program for checking for unchecked errors in Go code. These unchecked errors can be critical bugs in some cases.

Copy
linters:
  settings:
    errcheck:
      # Report about not checking of errors in type assertions: `a := b.(MyStruct)`.
      # Such cases aren't reported by default.
      # Default: false
      check-type-assertions: true
      # report about assignment of errors to blank identifier: `num, _ := strconv.Atoi(numStr)`.
      # Such cases aren't reported by default.
      # Default: false
      check-blank: true
      # To disable the errcheck built-in exclude list.
      # See `-excludeonly` option in https://github.com/kisielk/errcheck#excluding-functions for details.
      # Default: false
      disable-default-exclusions: true
      # List of functions to exclude from checking, where each entry is a single function to exclude.
      # See https://github.com/kisielk/errcheck#excluding-functions for details.
      exclude-functions:
        - io/ioutil.ReadFile
        - io.Copy(*bytes.Buffer)
        - io.Copy(os.Stdout)

errchkjson

Checks types passed to the json encoding functions. Reports unsupported types and reports occurrences where the check for the returned error can be omitted.

Copy
linters:
  settings:
    errchkjson:
      # With check-error-free-encoding set to true, errchkjson does warn about errors
      # from json encoding functions that are safe to be ignored,
      # because they are not possible to happen.
      #
      # if check-error-free-encoding is set to true and errcheck linter is enabled,
      # it is recommended to add the following exceptions to prevent from false positives:
      #
      #     linters:
      #       settings:
      #         errcheck:
      #           exclude-functions:
      #             - encoding/json.Marshal
      #             - encoding/json.MarshalIndent
      #
      # Default: false
      check-error-free-encoding: true
      # Issue on struct encoding that doesn't have exported fields.
      # Default: false
      report-no-exported: false

errorlint

Errorlint is a linter for that can be used to find code that will cause problems with the error wrapping scheme introduced in Go 1.13.

Copy
linters:
  settings:
    errorlint:
      # Check whether fmt.Errorf uses the %w verb for formatting errors.
      # See the https://github.com/polyfloyd/go-errorlint for caveats.
      # Default: true
      errorf: false
      # Permit more than 1 %w verb, valid per Go 1.20 (requires `errorf: true`).
      # Default: true
      errorf-multi: false
      # Check for plain type assertions and type switches.
      # Default: true
      asserts: false
      # Check for plain error comparisons.
      # Default: true
      comparison: false
      # Allowed errors.
      # Default: []
      allowed-errors:
        - err: "io.EOF"
          fun: "example.com/pkg.Read"
      # Allowed error "wildcards".
      # Default: []
      allowed-errors-wildcard:
        - err: "example.com/pkg.ErrMagic"
          fun: "example.com/pkg.Magic"

exhaustive

Check exhaustiveness of enum switch statements.

Copy
linters:
  settings:
    exhaustive:
      # Program elements to check for exhaustiveness.
      # Default: [ switch ]
      check:
        - switch
        - map
      # Presence of "default" case in switch statements satisfies exhaustiveness,
      # even if all enum members are not listed.
      # Default: false
      default-signifies-exhaustive: true
      # Enum members matching the supplied regex do not have to be listed in
      # switch statements to satisfy exhaustiveness.
      # Default: ""
      ignore-enum-members: "Example.+"
      # Enum types matching the supplied regex do not have to be listed in
      # switch statements to satisfy exhaustiveness.
      # Default: ""
      ignore-enum-types: "Example.+"
      # Consider enums only in package scopes, not in inner scopes.
      # Default: false
      package-scope-only: true
      # Only run exhaustive check on switches with "//exhaustive:enforce" comment.
      # Default: false
      explicit-exhaustive-switch: true
      # Only run exhaustive check on map literals with "//exhaustive:enforce" comment.
      # Default: false
      explicit-exhaustive-map: true
      # Switch statement requires default case even if exhaustive.
      # Default: false
      default-case-required: true

exhaustruct

Checks if all structure fields are initialized.

Copy
linters:
  settings:
    exhaustruct:
      # List of regular expressions to match struct packages and their names.
      # Regular expressions must match complete canonical struct package/name/structname.
      # If this list is empty, all structs are tested.
      # Default: []
      include:
        - '.+\.Test'
        - 'example\.com/package\.ExampleStruct[\d]{1,2}'
      # List of regular expressions to exclude struct packages and their names from checks.
      # Regular expressions must match complete canonical struct package/name/structname.
      # Default: []
      exclude:
        - '.+/cobra\.Command$'

fatcontext

Detects nested contexts in loops and function literals.

Copy
linters:
  settings:
    fatcontext:
      # Check for potential fat contexts in struct pointers.
      # May generate false positives.
      # Default: false
      check-struct-pointers: true

forbidigo

Forbids identifiers.

Copy
linters:
  settings:
    forbidigo:
      # Forbid the following identifiers (list of regexp).
      # Default: ["^(fmt\\.Print(|f|ln)|print|println)$"]
      forbid:
        # Built-in bootstrapping functions.
        - pattern: ^print(ln)?$
        # Optional message that gets included in error reports.
        - pattern: ^fmt\.Print.*$
          msg: Do not commit print statements.
        # Alternatively, put messages at the end of the regex, surrounded by `(# )?`.
        # Escape any special characters. Those messages get included in error reports.
        - pattern: 'fmt\.Print.*(# Do not commit print statements\.)?'
        # Forbid spew Dump, whether it is called as function or method.
        # Depends on analyze-types below.
        - pattern: ^spew\.(ConfigState\.)?Dump$
        # The package name might be ambiguous.
        # The full import path can be used as additional criteria.
        # Depends on analyze-types below.
        - pattern: ^v1.Dump$
          pkg: ^example.com/pkg/api/v1$
      # Exclude godoc examples from forbidigo checks.
      # Default: true
      exclude-godoc-examples: false
      # Instead of matching the literal source code,
      # use type information to replace expressions with strings that contain the package name
      # and (for methods and fields) the type name.
      # This makes it possible to handle import renaming and forbid struct fields and methods.
      # Default: false
      analyze-types: true

funcorder

Checks the order of functions, methods, and constructors.

Copy
linters:
  settings:
    funcorder:
      # Checks that constructors are placed after the structure declaration.
      # Default: true
      constructor: false
      # Checks if the exported methods of a structure are placed before the non-exported ones.
      # Default: true
      struct-method: false

funlen

Checks for long functions.

Copy
linters:
  settings:
    funlen:
      # Checks the number of lines in a function.
      # If lower than 0, disable the check.
      # Default: 60
      lines: -1
      # Checks the number of statements in a function.
      # If lower than 0, disable the check.
      # Default: 40
      statements: -1
      # Ignore comments when counting lines.
      # Default: true
      ignore-comments: false

ginkgolinter

Enforces standards of using ginkgo and gomega.

Copy
linters:
  settings:
    ginkgolinter:
      # Suppress the wrong length assertion warning.
      # Default: false
      suppress-len-assertion: true
      # Suppress the wrong nil assertion warning.
      # Default: false
      suppress-nil-assertion: true
      # Suppress the wrong error assertion warning.
      # Default: false
      suppress-err-assertion: true
      # Suppress the wrong comparison assertion warning.
      # Default: false
      suppress-compare-assertion: true
      # Suppress the function all in async assertion warning.
      # Default: false
      suppress-async-assertion: true
      # Suppress warning for comparing values from different types, like `int32` and `uint32`.
      # Default: false
      suppress-type-compare-assertion: true
      # Trigger warning for ginkgo focus containers like `FDescribe`, `FContext`, `FWhen` or `FIt`.
      # Default: false
      forbid-focus-container: true
      # Don't trigger warnings for HaveLen(0)
      # Default: false
      allow-havelen-zero: true
      # Force using `Expect` with `To`, `ToNot` or `NotTo`.
      # Reject using `Expect` with `Should` or `ShouldNot`.
      # Default: false
      force-expect-to: true
      # Best effort validation of async intervals (timeout and polling).
      # Ignored the `suppress-async-assertion` is true.
      # Default: false
      validate-async-intervals: true
      # Trigger a warning for variable assignments in ginkgo containers like `Describe`, `Context` and `When`, instead of in `BeforeEach()`.
      # Default: false
      forbid-spec-pollution: true
      # Force using the Succeed matcher for error functions, and the HaveOccurred matcher for non-function error values.
      # Default: false
      force-succeed: true

gochecksumtype

Run exhaustiveness checks on Go "sum types".

Copy
linters:
  settings:
    gochecksumtype:
      # Presence of `default` case in switch statements satisfies exhaustiveness, if all members are not listed.
      # Default: true
      default-signifies-exhaustive: false
      # Include shared interfaces in the exhaustiveness check.
      # Default: false
      include-shared-interfaces: true

gocognit

Computes and checks the cognitive complexity of functions.

Copy
linters:
  settings:
    gocognit:
      # Minimal code complexity to report.
      # Default: 30 (but we recommend 10-20)
      min-complexity: 10

goconst

Finds repeated strings that could be replaced by a constant.

Copy
linters:
  settings:
    goconst:
      # Minimal length of string constant.
      # Default: 3
      min-len: 2
      # Minimum occurrences of constant string count to trigger issue.
      # Default: 3
      min-occurrences: 2
      # Look for existing constants matching the values.
      # Default: true
      match-constant: false
      # Search also for duplicated numbers.
      # Default: false
      numbers: true
      # Minimum value, only works with `goconst.numbers`.
      # Default: 3
      min: 2
      # Maximum value, only works with `goconst.numbers`.
      # Default: 3
      max: 2
      # Ignore when constant is not used as function argument.
      # Default: true
      ignore-calls: false
      # Exclude strings matching the given regular expression.
      # Default: ""
      ignore-string-values:
        - 'foo.+'
      # Detects constants with identical values.
      # Default: false
      find-duplicates: true
      # Evaluates of constant expressions like Prefix + "suffix".
      # Default: false
      eval-const-expressions: true

gocritic

Provides diagnostics that check for bugs, performance and style issues.
Extensible without recompilation through dynamic rules.
Dynamic rules are written declaratively with AST patterns, filters, report message and optional suggestion.

Copy
linters:
  settings:
    gocritic:
      # Disable all checks.
      # Default: false
      disable-all: true
      # Which checks should be enabled in addition to default checks; can't be combined with 'disabled-checks'.
      # By default, list of stable checks is used (https://go-critic.com/overview#checks-overview):
      #   appendAssign, argOrder, assignOp, badCall, badCond, captLocal, caseOrder, codegenComment, commentFormatting,
      #   defaultCaseOrder, deprecatedComment, dupArg, dupBranchBody, dupCase, dupSubExpr, elseif, exitAfterDefer,
      #   flagDeref, flagName, ifElseChain, mapKey, newDeref, offBy1, regexpMust, singleCaseSwitch, sloppyLen,
      #   sloppyTypeAssert, switchTrue, typeSwitchVar, underef, unlambda, unslice, valSwap, wrapperFunc
      # To see which checks are enabled run `GL_DEBUG=gocritic golangci-lint run --enable=gocritic`.
      enabled-checks:
        # Detects suspicious append result assignments.
        # https://go-critic.com/overview.html#appendassign
        - appendAssign
        # Detects `append` chains to the same slice that can be done in a single `append` call.
        # https://go-critic.com/overview.html#appendcombine
        - appendCombine
        # Detects suspicious arguments order.
        # https://go-critic.com/overview.html#argorder
        - argOrder
        # Detects assignments that can be simplified by using assignment operators.
        # https://go-critic.com/overview.html#assignop
        - assignOp
        # Detects suspicious function calls.
        # https://go-critic.com/overview.html#badcall
        - badCall
        # Detects suspicious condition expressions.
        # https://go-critic.com/overview.html#badcond
        - badCond
        # Detects suspicious mutex lock/unlock operations.
        # https://go-critic.com/overview.html#badlock
        - badLock
        # Detects suspicious regexp patterns.
        # https://go-critic.com/overview.html#badregexp
        - badRegexp
        # Detects bad usage of sort package.
        # https://go-critic.com/overview.html#badsorting
        - badSorting
        # Detects bad usage of sync.OnceFunc.
        # https://go-critic.com/overview.html#badsynconcefunc
        - badSyncOnceFunc
        # Detects bool expressions that can be simplified.
        # https://go-critic.com/overview.html#boolexprsimplify
        - boolExprSimplify
        # Detects when predeclared identifiers are shadowed in assignments.
        # https://go-critic.com/overview.html#builtinshadow
        - builtinShadow
        # Detects top-level declarations that shadow the predeclared identifiers.
        # https://go-critic.com/overview.html#builtinshadowdecl
        - builtinShadowDecl
        # Detects capitalized names for local variables.
        # https://go-critic.com/overview.html#captlocal
        - captLocal
        # Detects erroneous case order inside switch statements.
        # https://go-critic.com/overview.html#caseorder
        - caseOrder
        # Detects malformed 'code generated' file comments.
        # https://go-critic.com/overview.html#codegencomment
        - codegenComment
        # Detects comments with non-idiomatic formatting.
        # https://go-critic.com/overview.html#commentformatting
        - commentFormatting
        # Detects commented-out code inside function bodies.
        # https://go-critic.com/overview.html#commentedoutcode
        - commentedOutCode
        # Detects commented-out imports.
        # https://go-critic.com/overview.html#commentedoutimport
        - commentedOutImport
        # Detects when default case in switch isn't on 1st or last position.
        # https://go-critic.com/overview.html#defaultcaseorder
        - defaultCaseOrder
        # Detects loops inside functions that use defer.
        # https://go-critic.com/overview.html#deferinloop
        - deferInLoop
        # Detects deferred function literals that can be simplified.
        # https://go-critic.com/overview.html#deferunlambda
        - deferUnlambda
        # Detects malformed 'deprecated' doc-comments.
        # https://go-critic.com/overview.html#deprecatedcomment
        - deprecatedComment
        # Detects comments that silence go lint complaints about doc-comment.
        # https://go-critic.com/overview.html#docstub
        - docStub
        # Detects suspicious duplicated arguments.
        # https://go-critic.com/overview.html#duparg
        - dupArg
        # Detects duplicated branch bodies inside conditional statements.
        # https://go-critic.com/overview.html#dupbranchbody
        - dupBranchBody
        # Detects duplicated case clauses inside switch or select statements.
        # https://go-critic.com/overview.html#dupcase
        - dupCase
        # Detects multiple imports of the same package under different aliases.
        # https://go-critic.com/overview.html#dupimport
        - dupImport
        # Detects suspicious duplicated sub-expressions.
        # https://go-critic.com/overview.html#dupsubexpr
        - dupSubExpr
        # Detects suspicious formatting strings usage.
        # https://go-critic.com/overview.html#dynamicfmtstring
        - dynamicFmtString
        # Detects else with nested if statement that can be replaced with else-if.
        # https://go-critic.com/overview.html#elseif
        - elseif
        # Detects suspicious empty declarations blocks.
        # https://go-critic.com/overview.html#emptydecl
        - emptyDecl
        # Detects fallthrough that can be avoided by using multi case values.
        # https://go-critic.com/overview.html#emptyfallthrough
        - emptyFallthrough
        # Detects empty string checks that can be written more idiomatically.
        # https://go-critic.com/overview.html#emptystringtest
        - emptyStringTest
        # Detects unoptimal strings/bytes case-insensitive comparison.
        # https://go-critic.com/overview.html#equalfold
        - equalFold
        # Detects unwanted dependencies on the evaluation order.
        # https://go-critic.com/overview.html#evalorder
        - evalOrder
        # Detects calls to exit/fatal inside functions that use defer.
        # https://go-critic.com/overview.html#exitafterdefer
        - exitAfterDefer
        # Detects exposed methods from sync.Mutex and sync.RWMutex.
        # https://go-critic.com/overview.html#exposedsyncmutex
        - exposedSyncMutex
        # Detects suspicious reassignment of error from another package.
        # https://go-critic.com/overview.html#externalerrorreassign
        - externalErrorReassign
        # Detects problems in filepath.Join() function calls.
        # https://go-critic.com/overview.html#filepathjoin
        - filepathJoin
        # Detects immediate dereferencing of `flag` package pointers.
        # https://go-critic.com/overview.html#flagderef
        - flagDeref
        # Detects suspicious flag names.
        # https://go-critic.com/overview.html#flagname
        - flagName
        # Detects hex literals that have mixed case letter digits.
        # https://go-critic.com/overview.html#hexliteral
        - hexLiteral
        # Detects nil usages in http.NewRequest calls, suggesting http.NoBody as an alternative.
        # https://go-critic.com/overview.html#httpnobody
        - httpNoBody
        # Detects params that incur excessive amount of copying.
        # https://go-critic.com/overview.html#hugeparam
        - hugeParam
        # Detects repeated if-else statements and suggests to replace them with switch statement.
        # https://go-critic.com/overview.html#ifelsechain
        - ifElseChain
        # Detects when imported package names shadowed in the assignments.
        # https://go-critic.com/overview.html#importshadow
        - importShadow
        # Detects strings.Index calls that may cause unwanted allocs.
        # https://go-critic.com/overview.html#indexalloc
        - indexAlloc
        # Detects non-assignment statements inside if/switch init clause.
        # https://go-critic.com/overview.html#initclause
        - initClause
        # Detects suspicious map literal keys.
        # https://go-critic.com/overview.html#mapkey
        - mapKey
        # Detects method expression call that can be replaced with a method call.
        # https://go-critic.com/overview.html#methodexprcall
        - methodExprCall
        # Finds where nesting level could be reduced.
        # https://go-critic.com/overview.html#nestingreduce
        - nestingReduce
        # Detects immediate dereferencing of `new` expressions.
        # https://go-critic.com/overview.html#newderef
        - newDeref
        # Detects return statements those results evaluate to nil.
        # https://go-critic.com/overview.html#nilvalreturn
        - nilValReturn
        # Detects old-style octal literals.
        # https://go-critic.com/overview.html#octalliteral
        - octalLiteral
        # Detects various off-by-one kind of errors.
        # https://go-critic.com/overview.html#offby1
        - offBy1
        # Detects if function parameters could be combined by type and suggest the way to do it.
        # https://go-critic.com/overview.html#paramtypecombine
        - paramTypeCombine
        # Detects expressions like []rune(s)[0] that may cause unwanted rune slice allocation.
        # https://go-critic.com/overview.html#preferdecoderune
        - preferDecodeRune
        # Detects concatenation with os.PathSeparator which can be replaced with filepath.Join.
        # https://go-critic.com/overview.html#preferfilepathjoin
        - preferFilepathJoin
        # Detects fmt.Sprint(f/ln) calls which can be replaced with fmt.Fprint(f/ln).
        # https://go-critic.com/overview.html#preferfprint
        - preferFprint
        # Detects w.Write or io.WriteString calls which can be replaced with w.WriteString.
        # https://go-critic.com/overview.html#preferstringwriter
        - preferStringWriter
        # Detects WriteRune calls with rune literal argument that is single byte and reports to use WriteByte instead.
        # https://go-critic.com/overview.html#preferwritebyte
        - preferWriteByte
        # Detects input and output parameters that have a type of pointer to referential type.
        # https://go-critic.com/overview.html#ptrtorefparam
        - ptrToRefParam
        # Detects append all its data while range it.
        # https://go-critic.com/overview.html#rangeappendall
        - rangeAppendAll
        # Detects expensive copies of `for` loop range expressions.
        # https://go-critic.com/overview.html#rangeexprcopy
        - rangeExprCopy
        # Detects loops that copy big objects during each iteration.
        # https://go-critic.com/overview.html#rangevalcopy
        - rangeValCopy
        # Detects redundant fmt.Sprint calls.
        # https://go-critic.com/overview.html#redundantsprint
        - redundantSprint
        # Detects `regexp.Compile*` that can be replaced with `regexp.MustCompile*`.
        # https://go-critic.com/overview.html#regexpmust
        - regexpMust
        # Detects suspicious regexp patterns.
        # https://go-critic.com/overview.html#regexppattern
        - regexpPattern
        # Detects regexp patterns that can be simplified.
        # https://go-critic.com/overview.html#regexpsimplify
        - regexpSimplify
        # Detects suspicious http.Error call without following return.
        # https://go-critic.com/overview.html#returnafterhttperror
        - returnAfterHttpError
        # Runs user-defined rules using ruleguard linter.
        # https://go-critic.com/overview.html#ruleguard
        - ruleguard
        # Detects switch statements that could be better written as if statement.
        # https://go-critic.com/overview.html#singlecaseswitch
        - singleCaseSwitch
        # Detects slice clear loops, suggests an idiom that is recognized by the Go compiler.
        # https://go-critic.com/overview.html#sliceclear
        - sliceClear
        # Detects usage of `len` when result is obvious or doesn't make sense.
        # https://go-critic.com/overview.html#sloppylen
        - sloppyLen
        # Detects suspicious/confusing re-assignments.
        # https://go-critic.com/overview.html#sloppyreassign
        - sloppyReassign
        # Detects redundant type assertions.
        # https://go-critic.com/overview.html#sloppytypeassert
        - sloppyTypeAssert
        # Detects suspicious sort.Slice calls.
        # https://go-critic.com/overview.html#sortslice
        - sortSlice
        # Detects "%s" formatting directives that can be replaced with %q.
        # https://go-critic.com/overview.html#sprintfquotedstring
        - sprintfQuotedString
        # Detects issue in Query() and Exec() calls.
        # https://go-critic.com/overview.html#sqlquery
        - sqlQuery
        # Detects string concat operations that can be simplified.
        # https://go-critic.com/overview.html#stringconcatsimplify
        - stringConcatSimplify
        # Detects redundant conversions between string and []byte.
        # https://go-critic.com/overview.html#stringxbytes
        - stringXbytes
        # Detects strings.Compare usage.
        # https://go-critic.com/overview.html#stringscompare
        - stringsCompare
        # Detects switch-over-bool statements that use explicit `true` tag value.
        # https://go-critic.com/overview.html#switchtrue
        - switchTrue
        # Detects sync.Map load+delete operations that can be replaced with LoadAndDelete.
        # https://go-critic.com/overview.html#syncmaploadanddelete
        - syncMapLoadAndDelete
        # Detects manual conversion to milli- or microseconds.
        # https://go-critic.com/overview.html#timeexprsimplify
        - timeExprSimplify
        # Detects TODO comments without detail/assignee.
        # https://go-critic.com/overview.html#todocommentwithoutdetail
        - todoCommentWithoutDetail
        # Detects function with too many results.
        # https://go-critic.com/overview.html#toomanyresultschecker
        - tooManyResultsChecker
        # Detects potential truncation issues when comparing ints of different sizes.
        # https://go-critic.com/overview.html#truncatecmp
        - truncateCmp
        # Detects repeated type assertions and suggests to replace them with type switch statement.
        # https://go-critic.com/overview.html#typeassertchain
        - typeAssertChain
        # Detects method declarations preceding the type definition itself.
        # https://go-critic.com/overview.html#typedeffirst
        - typeDefFirst
        # Detects type switches that can benefit from type guard clause with variable.
        # https://go-critic.com/overview.html#typeswitchvar
        - typeSwitchVar
        # Detects unneeded parenthesis inside type expressions and suggests to remove them.
        # https://go-critic.com/overview.html#typeunparen
        - typeUnparen
        # Detects unchecked errors in if statements.
        # https://go-critic.com/overview.html#uncheckedinlineerr
        - uncheckedInlineErr
        # Detects dereference expressions that can be omitted.
        # https://go-critic.com/overview.html#underef
        - underef
        # Detects redundant statement labels.
        # https://go-critic.com/overview.html#unlabelstmt
        - unlabelStmt
        # Detects function literals that can be simplified.
        # https://go-critic.com/overview.html#unlambda
        - unlambda
        # Detects unnamed results that may benefit from names.
        # https://go-critic.com/overview.html#unnamedresult
        - unnamedResult
        # Detects unnecessary braced statement blocks.
        # https://go-critic.com/overview.html#unnecessaryblock
        - unnecessaryBlock
        # Detects redundantly deferred calls.
        # https://go-critic.com/overview.html#unnecessarydefer
        - unnecessaryDefer
        # Detects slice expressions that can be simplified to sliced expression itself.
        # https://go-critic.com/overview.html#unslice
        - unslice
        # Detects value swapping code that are not using parallel assignment.
        # https://go-critic.com/overview.html#valswap
        - valSwap
        # Detects conditions that are unsafe due to not being exhaustive.
        # https://go-critic.com/overview.html#weakcond
        - weakCond
        # Ensures that `//nolint` comments include an explanation.
        # https://go-critic.com/overview.html#whynolint
        - whyNoLint
        # Detects function calls that can be replaced with convenience wrappers.
        # https://go-critic.com/overview.html#wrapperfunc
        - wrapperFunc
        # Detects Yoda style expressions and suggests to replace them.
        # https://go-critic.com/overview.html#yodastyleexpr
        - yodaStyleExpr
      # Enable all checks.
      # Default: false
      enable-all: true
      # Which checks should be disabled; can't be combined with 'enabled-checks'.
      # Default: []
      disabled-checks:
        - appendAssign
        - appendCombine
        - argOrder
        - assignOp
        - badCall
        - badCond
        - badLock
        - badRegexp
        - badSorting
        - badSyncOnceFunc
        - boolExprSimplify
        - builtinShadow
        - builtinShadowDecl
        - captLocal
        - caseOrder
        - codegenComment
        - commentFormatting
        - commentedOutCode
        - commentedOutImport
        - defaultCaseOrder
        - deferInLoop
        - deferUnlambda
        - deprecatedComment
        - docStub
        - dupArg
        - dupBranchBody
        - dupCase
        - dupImport
        - dupSubExpr
        - dynamicFmtString
        - elseif
        - emptyDecl
        - emptyFallthrough
        - emptyStringTest
        - equalFold
        - evalOrder
        - exitAfterDefer
        - exposedSyncMutex
        - externalErrorReassign
        - filepathJoin
        - flagDeref
        - flagName
        - hexLiteral
        - httpNoBody
        - hugeParam
        - ifElseChain
        - importShadow
        - indexAlloc
        - initClause
        - mapKey
        - methodExprCall
        - nestingReduce
        - newDeref
        - nilValReturn
        - octalLiteral
        - offBy1
        - paramTypeCombine
        - preferDecodeRune
        - preferFilepathJoin
        - preferFprint
        - preferStringWriter
        - preferWriteByte
        - ptrToRefParam
        - rangeAppendAll
        - rangeExprCopy
        - rangeValCopy
        - redundantSprint
        - regexpMust
        - regexpPattern
        - regexpSimplify
        - returnAfterHttpError
        - ruleguard
        - singleCaseSwitch
        - sliceClear
        - sloppyLen
        - sloppyReassign
        - sloppyTypeAssert
        - sortSlice
        - sprintfQuotedString
        - sqlQuery
        - stringConcatSimplify
        - stringXbytes
        - stringsCompare
        - switchTrue
        - syncMapLoadAndDelete
        - timeExprSimplify
        - todoCommentWithoutDetail
        - tooManyResultsChecker
        - truncateCmp
        - typeAssertChain
        - typeDefFirst
        - typeSwitchVar
        - typeUnparen
        - uncheckedInlineErr
        - underef
        - unlabelStmt
        - unlambda
        - unnamedResult
        - unnecessaryBlock
        - unnecessaryDefer
        - unslice
        - valSwap
        - weakCond
        - whyNoLint
        - wrapperFunc
        - yodaStyleExpr
      # Enable multiple checks by tags in addition to default checks.
      # Run `GL_DEBUG=gocritic golangci-lint run --enable=gocritic` to see all tags and checks.
      # See https://github.com/go-critic/go-critic#usage -> section "Tags".
      # Default: []
      enabled-tags:
        - diagnostic
        - style
        - performance
        - experimental
        - opinionated
      disabled-tags:
        - diagnostic
        - style
        - performance
        - experimental
        - opinionated
      # Settings passed to gocritic.
      # The settings key is the name of a supported gocritic checker.
      # The list of supported checkers can be found at https://go-critic.com/overview.
      settings:
        # Must be valid enabled check name.
        captLocal:
          # Whether to restrict checker to params only.
          # Default: true
          paramsOnly: false
        commentedOutCode:
          # Min length of the comment that triggers a warning.
          # Default: 15
          minLength: 50
        elseif:
          # Whether to skip balanced if-else pairs.
          # Default: true
          skipBalanced: false
        hugeParam:
          # Size in bytes that makes the warning trigger.
          # Default: 80
          sizeThreshold: 70
        ifElseChain:
          # Min number of if-else blocks that makes the warning trigger.
          # Default: 2
          minThreshold: 4
        nestingReduce:
          # Min number of statements inside a branch to trigger a warning.
          # Default: 5
          bodyWidth: 4
        rangeExprCopy:
          # Size in bytes that makes the warning trigger.
          # Default: 512
          sizeThreshold: 516
          # Whether to check test functions
          # Default: true
          skipTestFuncs: false
        rangeValCopy:
          # Size in bytes that makes the warning trigger.
          # Default: 128
          sizeThreshold: 32
          # Whether to check test functions.
          # Default: true
          skipTestFuncs: false
        ruleguard:
          # Enable debug to identify which 'Where' condition was rejected.
          # The value of the parameter is the name of a function in a ruleguard file.
          #
          # When a rule is evaluated:
          # If:
          #   The Match() clause is accepted; and
          #   One of the conditions in the Where() clause is rejected,
          # Then:
          #   ruleguard prints the specific Where() condition that was rejected.
          #
          # The option is passed to the ruleguard 'debug-group' argument.
          # Default: ""
          debug: 'emptyDecl'
          # Determines the behavior when an error occurs while parsing ruleguard files.
          # If flag is not set, log error and skip rule files that contain an error.
          # If flag is set, the value must be a comma-separated list of error conditions.
          # - 'all':    fail on all errors.
          # - 'import': ruleguard rule imports a package that cannot be found.
          # - 'dsl':    gorule file does not comply with the ruleguard DSL.
          # Default: ""
          failOn: dsl,import
          # Comma-separated list of file paths containing ruleguard rules.
          # By default, if a path is relative, it is relative to the directory where the golangci-lint command is executed.
          # The placeholder '${base-path}' is substituted with a path relative to the mode defined with `run.relative-path-mode`.
          # The placeholder '${config-path}' is substituted with a path relative to the configuration file.
          # Glob patterns such as 'rules-*.go' may be specified.
          # Default: ""
          rules: '${base-path}/ruleguard/rules-*.go,${base-path}/myrule1.go'
          # Comma-separated list of enabled groups or skip empty to enable everything.
          # Tags can be defined with # character prefix.
          # Default: "<all>"
          enable: "myGroupName,#myTagName"
          # Comma-separated list of disabled groups or skip empty to enable everything.
          # Tags can be defined with # character prefix.
          # Default: ""
          disable: "myGroupName,#myTagName"
        tooManyResultsChecker:
          # Maximum number of results.
          # Default: 5
          maxResults: 10
        truncateCmp:
          # Whether to skip int/uint/uintptr types.
          # Default: true
          skipArchDependent: false
        underef:
          # Whether to skip (*x).method() calls where x is a pointer receiver.
          # Default: true
          skipRecvDeref: false
        unnamedResult:
          # Whether to check exported functions.
          # Default: false
          checkExported: true

gocyclo

Computes and checks the cyclomatic complexity of functions.

Copy
linters:
  settings:
    gocyclo:
      # Minimal code complexity to report.
      # Default: 30 (but we recommend 10-20)
      min-complexity: 10

godot

Check if comments end in a period.

Copy
linters:
  settings:
    godot:
      # Comments to be checked: `declarations`, `toplevel`, `noinline` or `all`.
      # Default: declarations
      scope: toplevel
      # List of regexps for excluding particular comment lines from check.
      # Default: []
      exclude:
        # Exclude todo and fixme comments.
        - "^fixme:"
        - "^todo:"
      # Check that each sentence ends with a period.
      # Default: true
      period: false
      # Check that each sentence starts with a capital letter.
      # Default: false
      capital: true

godox

Detects usage of FIXME, TODO and other keywords inside comments.

Copy
linters:
  settings:
    godox:
      # Report any comments starting with keywords, this is useful for TODO or FIXME comments that
      # might be left in the code accidentally and should be resolved before merging.
      # Default: ["TODO", "BUG", "FIXME"]
      keywords:
        - NOTE
        - OPTIMIZE # marks code that should be optimized before merging
        - HACK # marks hack-around that should be removed before merging

goheader

Checks if file header matches to pattern.

Copy
linters:
  settings:
    goheader:
      # Supports two types 'const` and `regexp`.
      # Values can be used recursively.
      # Default: {}
      values:
        const:
          # Define here const type values in format k:v.
          # For example:
          COMPANY: MY COMPANY
        regexp:
          # Define here regexp type values.
          # for example:
          AUTHOR: .*@mycompany\.com
      # The template used for checking.
      # Put here copyright header template for source code files.
      # Note: {{ YEAR }} is a builtin value that returns the year relative to the current machine time.
      # Default: ""
      template: |-
        {{ AUTHOR }} {{ COMPANY }} {{ YEAR }}
        SPDX-License-Identifier: Apache-2.0

        Licensed under the Apache License, Version 2.0 (the "License");
        you may not use this file except in compliance with the License.
        You may obtain a copy of the License at:

          http://www.apache.org/licenses/LICENSE-2.0

        Unless required by applicable law or agreed to in writing, software
        distributed under the License is distributed on an "AS IS" BASIS,
        WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
        See the License for the specific language governing permissions and
        limitations under the License.
      # As alternative of directive 'template', you may put the path to file with the template source.
      # Useful if you need to load the template from a specific file.
      # By default, if a path is relative, it is relative to the directory where the golangci-lint command is executed.
      # The placeholder '${base-path}' is substituted with a path relative to the mode defined with `run.relative-path-mode`.
      # The placeholder '${config-path}' is substituted with a path relative to the configuration file.
      # Default: ""
      template-path: /path/to/my/template.tmpl

gomoddirectives

Manage the use of 'replace', 'retract', and 'excludes' directives in go.mod.

Copy
linters:
  settings:
    gomoddirectives:
      # Allow local `replace` directives.
      # Default: false
      replace-local: true
      # List of allowed `replace` directives.
      # Default: []
      replace-allow-list:
        - launchpad.net/gocheck
      # Allow to not explain why the version has been retracted in the `retract` directives.
      # Default: false
      retract-allow-no-explanation: true
      # Forbid the use of the `exclude` directives.
      # Default: false
      exclude-forbidden: true
      # Forbid the use of the `toolchain` directive.
      # Default: false
      toolchain-forbidden: true
      # Defines a pattern to validate `toolchain` directive.
      # Default: '' (no match)
      toolchain-pattern: 'go1\.23\.\d+$'
      # Forbid the use of the `tool` directives.
      # Default: false
      tool-forbidden: true
      # Forbid the use of the `godebug` directive.
      # Default: false
      go-debug-forbidden: true
      # Defines a pattern to validate `go` minimum version directive.
      # Default: '' (no match)
      go-version-pattern: '\d\.\d+(\.0)?'

gomodguard

Allow and block list linter for direct Go module dependencies. This is different from depguard where there are different block types for example version constraints and module recommendations.

Copy
linters:
  settings:
    gomodguard:
      allowed:
        # List of allowed modules.
        # Default: []
        modules:
          - gopkg.in/yaml.v2
        # List of allowed module domains.
        # Default: []
        domains:
          - golang.org
      blocked:
        # List of blocked modules.
        # Default: []
        modules:
          # Blocked module.
          - github.com/uudashr/go-module:
              # Recommended modules that should be used instead. (Optional)
              recommendations:
                - golang.org/x/mod
              # Reason why the recommended module should be used. (Optional)
              reason: "`mod` is the official go.mod parser library."
        # List of blocked module version constraints.
        # Default: []
        versions:
          # Blocked module with version constraint.
          - github.com/mitchellh/go-homedir:
              # Version constraint, see https://github.com/Masterminds/semver#basic-comparisons.
              version: "< 1.1.0"
              # Reason why the version constraint exists. (Optional)
              reason: "testing if blocked version constraint works."
        # Set to true to raise lint issues for packages that are loaded from a local path via replace directive.
        # Default: false
        local-replace-directives: false

gosec

Inspects source code for security problems.

Copy
linters:
  settings:
    gosec:
      # To select a subset of rules to run.
      # Available rules: https://github.com/securego/gosec#available-rules
      # Default: [] - means include all rules
      includes:
        - G101 # Look for hard coded credentials
        - G102 # Bind to all interfaces
        - G103 # Audit the use of unsafe block
        - G104 # Audit errors not checked
        - G106 # Audit the use of ssh.InsecureIgnoreHostKey
        - G107 # Url provided to HTTP request as taint input
        - G108 # Profiling endpoint automatically exposed on /debug/pprof
        - G109 # Potential Integer overflow made by strconv.Atoi result conversion to int16/32
        - G110 # Potential DoS vulnerability via decompression bomb
        - G111 # Potential directory traversal
        - G112 # Potential slowloris attack
        - G114 # Use of net/http serve function that has no support for setting timeouts
        - G115 # Potential integer overflow when converting between integer types
        - G201 # SQL query construction using format string
        - G202 # SQL query construction using string concatenation
        - G203 # Use of unescaped data in HTML templates
        - G204 # Audit use of command execution
        - G301 # Poor file permissions used when creating a directory
        - G302 # Poor file permissions used with chmod
        - G303 # Creating tempfile using a predictable path
        - G304 # File path provided as taint input
        - G305 # File traversal when extracting zip/tar archive
        - G306 # Poor file permissions used when writing to a new file
        - G307 # Poor file permissions used when creating a file with os.Create
        - G401 # Detect the usage of MD5 or SHA1
        - G402 # Look for bad TLS connection settings
        - G403 # Ensure minimum RSA key length of 2048 bits
        - G404 # Insecure random number source (rand)
        - G405 # Detect the usage of DES or RC4
        - G406 # Detect the usage of MD4 or RIPEMD160
        - G501 # Import blocklist: crypto/md5
        - G502 # Import blocklist: crypto/des
        - G503 # Import blocklist: crypto/rc4
        - G504 # Import blocklist: net/http/cgi
        - G505 # Import blocklist: crypto/sha1
        - G506 # Import blocklist: golang.org/x/crypto/md4
        - G507 # Import blocklist: golang.org/x/crypto/ripemd160
        - G601 # Implicit memory aliasing of items from a range statement
        - G602 # Slice access out of bounds
      # To specify a set of rules to explicitly exclude.
      # Available rules: https://github.com/securego/gosec#available-rules
      # Default: []
      excludes:
        - G101 # Look for hard coded credentials
        - G102 # Bind to all interfaces
        - G103 # Audit the use of unsafe block
        - G104 # Audit errors not checked
        - G106 # Audit the use of ssh.InsecureIgnoreHostKey
        - G107 # Url provided to HTTP request as taint input
        - G108 # Profiling endpoint automatically exposed on /debug/pprof
        - G109 # Potential Integer overflow made by strconv.Atoi result conversion to int16/32
        - G110 # Potential DoS vulnerability via decompression bomb
        - G111 # Potential directory traversal
        - G112 # Potential slowloris attack
        - G114 # Use of net/http serve function that has no support for setting timeouts
        - G115 # Potential integer overflow when converting between integer types
        - G201 # SQL query construction using format string
        - G202 # SQL query construction using string concatenation
        - G203 # Use of unescaped data in HTML templates
        - G204 # Audit use of command execution
        - G301 # Poor file permissions used when creating a directory
        - G302 # Poor file permissions used with chmod
        - G303 # Creating tempfile using a predictable path
        - G304 # File path provided as taint input
        - G305 # File traversal when extracting zip/tar archive
        - G306 # Poor file permissions used when writing to a new file
        - G307 # Poor file permissions used when creating a file with os.Create
        - G401 # Detect the usage of MD5 or SHA1
        - G402 # Look for bad TLS connection settings
        - G403 # Ensure minimum RSA key length of 2048 bits
        - G404 # Insecure random number source (rand)
        - G405 # Detect the usage of DES or RC4
        - G406 # Detect the usage of MD4 or RIPEMD160
        - G501 # Import blocklist: crypto/md5
        - G502 # Import blocklist: crypto/des
        - G503 # Import blocklist: crypto/rc4
        - G504 # Import blocklist: net/http/cgi
        - G505 # Import blocklist: crypto/sha1
        - G506 # Import blocklist: golang.org/x/crypto/md4
        - G507 # Import blocklist: golang.org/x/crypto/ripemd160
        - G601 # Implicit memory aliasing of items from a range statement
        - G602 # Slice access out of bounds
      # Filter out the issues with a lower severity than the given value.
      # Valid options are: low, medium, high.
      # Default: low
      severity: medium
      # Filter out the issues with a lower confidence than the given value.
      # Valid options are: low, medium, high.
      # Default: low
      confidence: medium
      # Concurrency value.
      # Default: the number of logical CPUs usable by the current process.
      concurrency: 12
      # To specify the configuration of rules.
      config:
        # Globals are applicable to all rules.
        global:
          # If true, ignore #nosec in comments (and an alternative as well).
          # Default: false
          nosec: true
          # Add an alternative comment prefix to #nosec (both will work at the same time).
          # Default: ""
          "#nosec": "#my-custom-nosec"
          # Define whether nosec issues are counted as finding or not.
          # Default: false
          show-ignored: true
          # Audit mode enables addition checks that for normal code analysis might be too nosy.
          # Default: false
          audit: true
        G101:
          # Regexp pattern for variables and constants to find.
          # Default: "(?i)passwd|pass|password|pwd|secret|token|pw|apiKey|bearer|cred"
          pattern: "(?i)example"
          # If true, complain about all cases (even with low entropy).
          # Default: false
          ignore_entropy: false
          # Maximum allowed entropy of the string.
          # Default: "80.0"
          entropy_threshold: "80.0"
          # Maximum allowed value of entropy/string length.
          # Is taken into account if entropy >= entropy_threshold/2.
          # Default: "3.0"
          per_char_threshold: "3.0"
          # Calculate entropy for first N chars of the string.
          # Default: "16"
          truncate: "32"
        # Additional functions to ignore while checking unhandled errors.
        # Following functions always ignored:
        #   bytes.Buffer:
        #     - Write
        #     - WriteByte
        #     - WriteRune
        #     - WriteString
        #   fmt:
        #     - Print
        #     - Printf
        #     - Println
        #     - Fprint
        #     - Fprintf
        #     - Fprintln
        #   strings.Builder:
        #     - Write
        #     - WriteByte
        #     - WriteRune
        #     - WriteString
        #   io.PipeWriter:
        #     - CloseWithError
        #   hash.Hash:
        #     - Write
        #   os:
        #     - Unsetenv
        # Default: {}
        G104:
          fmt:
            - Fscanf
        G111:
          # Regexp pattern to find potential directory traversal.
          # Default: "http\\.Dir\\(\"\\/\"\\)|http\\.Dir\\('\\/'\\)"
          pattern: "custom\\.Dir\\(\\)"
        # Maximum allowed permissions mode for os.Mkdir and os.MkdirAll.
        # Default: "0750"
        G301: "0750"
        # Maximum allowed permissions mode for os.OpenFile and os.Chmod.
        # Default: "0600"
        G302: "0600"
        # Maximum allowed permissions mode for os.WriteFile and ioutil.WriteFile.
        # Default: "0600"
        G306: "0600"

gosmopolitan

Report certain i18n/l10n anti-patterns in your Go codebase.

Copy
linters:
  settings:
    gosmopolitan:
      # Allow and ignore `time.Local` usages.
      #
      # Default: false
      allow-time-local: true
      # List of fully qualified names in the `full/pkg/path.name` form, to act as "i18n escape hatches".
      # String literals inside call-like expressions to, or struct literals of those names,
      # are exempt from the writing system check.
      #
      # Default: []
      escape-hatches:
        - 'github.com/nicksnyder/go-i18n/v2/i18n.Message'
        - 'example.com/your/project/i18n/markers.Raw'
        - 'example.com/your/project/i18n/markers.OK'
        - 'example.com/your/project/i18n/markers.TODO'
        - 'command-line-arguments.Simple'
      # List of Unicode scripts to watch for any usage in string literals.
      # https://pkg.go.dev/unicode#pkg-variables
      #
      # Default: ["Han"]
      watch-for-scripts:
        - Devanagari
        - Han
        - Hangul
        - Hiragana
        - Katakana

govet

Vet examines Go source code and reports suspicious constructs. It is roughly the same as 'go vet' and uses its passes.

Copy
linters:
  settings:
    govet:
      # Disable all analyzers.
      # Default: false
      disable-all: true
      # Enable analyzers by name.
      # (In addition to default:
      #   appends, asmdecl, assign, atomic, bools, buildtag, cgocall, composites, copylocks, defers, directive, errorsas,
      #   framepointer, httpresponse, ifaceassert, loopclosure, lostcancel, nilfunc, printf, shift, sigchanyzer, slog,
      #   stdmethods, stringintconv, structtag, testinggoroutine, tests, timeformat, unmarshal, unreachable, unsafeptr,
      #   unusedresult
      # ).
      # Run `GL_DEBUG=govet golangci-lint run --enable=govet` to see default, all available analyzers, and enabled analyzers.
      # Default: []
      enable:
        # Check for missing values after append.
        - appends
        # Report mismatches between assembly files and Go declarations.
        - asmdecl
        # Check for useless assignments.
        - assign
        # Check for common mistakes using the sync/atomic package.
        - atomic
        # Check for non-64-bits-aligned arguments to sync/atomic functions.
        - atomicalign
        # Check for common mistakes involving boolean operators.
        - bools
        # Check //go:build and // +build directives.
        - buildtag
        # Detect some violations of the cgo pointer passing rules.
        - cgocall
        # Check for unkeyed composite literals.
        - composites
        # Check for locks erroneously passed by value.
        - copylocks
        # Check for calls of reflect.DeepEqual on error values.
        - deepequalerrors
        # Report common mistakes in defer statements.
        - defers
        # Check Go toolchain directives such as //go:debug.
        - directive
        # Report passing non-pointer or non-error values to errors.As.
        - errorsas
        # Find structs that would use less memory if their fields were sorted.
        - fieldalignment
        # Find calls to a particular function.
        - findcall
        # Report assembly that clobbers the frame pointer before saving it.
        - framepointer
        # Report using Go 1.22 enhanced ServeMux patterns in older Go versions.
        - httpmux
        # Check for mistakes using HTTP responses.
        - httpresponse
        # Detect impossible interface-to-interface type assertions.
        - ifaceassert
        # Check references to loop variables from within nested functions.
        - loopclosure
        # Check cancel func returned by context.WithCancel is called.
        - lostcancel
        # Check for useless comparisons between functions and nil.
        - nilfunc
        # Check for redundant or impossible nil comparisons.
        - nilness
        # Check consistency of Printf format strings and arguments.
        - printf
        # Check for comparing reflect.Value values with == or reflect.DeepEqual.
        - reflectvaluecompare
        # Check for possible unintended shadowing of variables.
        - shadow
        # Check for shifts that equal or exceed the width of the integer.
        - shift
        # Check for unbuffered channel of os.Signal.
        - sigchanyzer
        # Check for invalid structured logging calls.
        - slog
        # Check the argument type of sort.Slice.
        - sortslice
        # Check signature of methods of well-known interfaces.
        - stdmethods
        # Report uses of too-new standard library symbols.
        - stdversion
        # Check for string(int) conversions.
        - stringintconv
        # Check that struct field tags conform to reflect.StructTag.Get.
        - structtag
        # Report calls to (*testing.T).Fatal from goroutines started by a test.
        - testinggoroutine
        # Check for common mistaken usages of tests and examples.
        - tests
        # Check for calls of (time.Time).Format or time.Parse with 2006-02-01.
        - timeformat
        # Report passing non-pointer or non-interface values to unmarshal.
        - unmarshal
        # Check for unreachable code.
        - unreachable
        # Check for invalid conversions of uintptr to unsafe.Pointer.
        - unsafeptr
        # Check for unused results of calls to some functions.
        - unusedresult
        # Checks for unused writes.
        - unusedwrite
        # Check for misuses of sync.WaitGroup.
        - waitgroup
      # Enable all analyzers.
      # Default: false
      enable-all: true
      # Disable analyzers by name.
      # (In addition to default
      #   atomicalign, deepequalerrors, fieldalignment, findcall, nilness, reflectvaluecompare, shadow, sortslice,
      #   timeformat, unusedwrite
      # ).
      # Run `GL_DEBUG=govet golangci-lint run --enable=govet` to see default, all available analyzers, and enabled analyzers.
      # Default: []
      disable:
        - appends
        - asmdecl
        - assign
        - atomic
        - atomicalign
        - bools
        - buildtag
        - cgocall
        - composites
        - copylocks
        - deepequalerrors
        - defers
        - directive
        - errorsas
        - fieldalignment
        - findcall
        - framepointer
        - httpmux
        - httpresponse
        - ifaceassert
        - loopclosure
        - lostcancel
        - nilfunc
        - nilness
        - printf
        - reflectvaluecompare
        - shadow
        - shift
        - sigchanyzer
        - slog
        - sortslice
        - stdmethods
        - stdversion
        - stringintconv
        - structtag
        - testinggoroutine
        - tests
        - timeformat
        - unmarshal
        - unreachable
        - unsafeptr
        - unusedresult
        - unusedwrite
        - waitgroup
      # Settings per analyzer.
      settings:
        # Analyzer name, run `go tool vet help` to see all analyzers.
        printf:
          # Comma-separated list of print function names to check (in addition to default, see `go tool vet help printf`).
          # Default: []
          funcs:
            - (github.com/golangci/golangci-lint/v2/pkg/logutils.Log).Infof
            - (github.com/golangci/golangci-lint/v2/pkg/logutils.Log).Warnf
            - (github.com/golangci/golangci-lint/v2/pkg/logutils.Log).Errorf
            - (github.com/golangci/golangci-lint/v2/pkg/logutils.Log).Fatalf
        shadow:
          # Whether to be strict about shadowing; can be noisy.
          # Default: false
          strict: true
        unusedresult:
          # Comma-separated list of functions whose results must be used.
          # (In addition to default:
          #   context.WithCancel, context.WithDeadline, context.WithTimeout, context.WithValue, errors.New, fmt.Errorf,
          #   fmt.Sprint, fmt.Sprintf, sort.Reverse
          # ).
          # Default: []
          funcs:
            - pkg.MyFunc
          # Comma-separated list of names of methods of type func() string whose results must be used.
          # (In addition to default Error,String).
          # Default: []
          stringmethods:
            - MyMethod