const (
	MsgInvalidHostPort = "invalid port or service name in host:port pair"
	MsgInvalidUTF8     = "argument is not a valid UTF-8 encoded string"
	MsgNonUniqueCutset = "cutset contains duplicate characters"
)

var Analyzers = lint.InitializeAnalyzers(Docs, map[string]*analysis.Analyzer{
	"SA1000": makeCallCheckerAnalyzer(checkRegexpRules),
	"SA1001": {
		Run:      CheckTemplate,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1002": makeCallCheckerAnalyzer(checkTimeParseRules),
	"SA1003": makeCallCheckerAnalyzer(checkEncodingBinaryRules),
	"SA1004": {
		Run:      CheckTimeSleepConstant,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1005": {
		Run:      CheckExec,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1006": {
		Run:      CheckUnsafePrintf,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1007": makeCallCheckerAnalyzer(checkURLsRules),
	"SA1008": {
		Run:      CheckCanonicalHeaderKey,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1010": makeCallCheckerAnalyzer(checkRegexpFindAllRules),
	"SA1011": makeCallCheckerAnalyzer(checkUTF8CutsetRules),
	"SA1012": {
		Run:      CheckNilContext,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1013": {
		Run:      CheckSeeker,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1014": makeCallCheckerAnalyzer(checkUnmarshalPointerRules),
	"SA1015": {
		Run:      CheckLeakyTimeTick,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA1016": {
		Run:      CheckUntrappableSignal,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA1017": makeCallCheckerAnalyzer(checkUnbufferedSignalChanRules),
	"SA1018": makeCallCheckerAnalyzer(checkStringsReplaceZeroRules),
	"SA1019": {
		Run:      CheckDeprecated,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Deprecated, facts.Generated},
	},
	"SA1020": makeCallCheckerAnalyzer(checkListenAddressRules),
	"SA1021": makeCallCheckerAnalyzer(checkBytesEqualIPRules),
	"SA1023": {
		Run:      CheckWriterBufferModified,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA1024": makeCallCheckerAnalyzer(checkUniqueCutsetRules),
	"SA1025": {
		Run:      CheckTimerResetReturnValue,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA1026": makeCallCheckerAnalyzer(checkUnsupportedMarshal),
	"SA1027": makeCallCheckerAnalyzer(checkAtomicAlignment),
	"SA1028": makeCallCheckerAnalyzer(checkSortSliceRules),
	"SA1029": makeCallCheckerAnalyzer(checkWithValueKeyRules),
	"SA1030": makeCallCheckerAnalyzer(checkStrconvRules),

	"SA2000": {
		Run:      CheckWaitgroupAdd,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA2001": {
		Run:      CheckEmptyCriticalSection,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA2002": {
		Run:      CheckConcurrentTesting,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA2003": {
		Run:      CheckDeferLock,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},

	"SA3000": {
		Run:      CheckTestMainExit,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA3001": {
		Run:      CheckBenchmarkN,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},

	"SA4000": {
		Run:      CheckLhsRhsIdentical,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.TokenFile, facts.Generated},
	},
	"SA4001": {
		Run:      CheckIneffectiveCopy,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4003": {
		Run:      CheckExtremeComparison,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4004": {
		Run:      CheckIneffectiveLoop,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4005": {
		Run:      CheckIneffectiveFieldAssignments,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA4006": {
		Run:      CheckUnreadVariableValues,
		Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Generated},
	},
	"SA4008": {
		Run:      CheckLoopCondition,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA4009": {
		Run:      CheckArgOverwritten,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA4010": {
		Run:      CheckIneffectiveAppend,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA4011": {
		Run:      CheckScopedBreak,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4012": {
		Run:      CheckNaNComparison,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA4013": {
		Run:      CheckDoubleNegation,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4014": {
		Run:      CheckRepeatedIfElse,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4015": makeCallCheckerAnalyzer(checkMathIntRules),
	"SA4016": {
		Run:      CheckSillyBitwiseOps,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.TokenFile},
	},
	"SA4017": {
		Run:      CheckPureFunctions,
		Requires: []*analysis.Analyzer{buildir.Analyzer, facts.Purity},
	},
	"SA4018": {
		Run:      CheckSelfAssignment,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile, facts.Purity},
	},
	"SA4019": {
		Run:      CheckDuplicateBuildConstraints,
		Requires: []*analysis.Analyzer{facts.Generated},
	},
	"SA4020": {
		Run:      CheckUnreachableTypeCases,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4021": {
		Run:      CheckSingleArgAppend,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
	},
	"SA4022": {
		Run:      CheckAddressIsNil,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4023": {
		Run:      CheckTypedNilInterface,
		Requires: []*analysis.Analyzer{buildir.Analyzer, typedness.Analysis, nilness.Analysis},
	},
	"SA4024": {
		Run:      CheckBuiltinZeroComparison,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4025": {
		Run:      CheckIntegerDivisionEqualsZero,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4026": {
		Run:      CheckNegativeZeroFloat,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA4027": {
		Run:      CheckIneffectiveURLQueryModification,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},

	"SA5000": {
		Run:      CheckNilMaps,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA5001": {
		Run:      CheckEarlyDefer,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA5002": {
		Run:      CheckInfiniteEmptyLoop,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA5003": {
		Run:      CheckDeferInInfiniteLoop,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA5004": {
		Run:      CheckLoopEmptyDefault,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA5005": {
		Run:      CheckCyclicFinalizer,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA5007": {
		Run:      CheckInfiniteRecursion,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA5008": {
		Run:      CheckStructTags,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA5009": makeCallCheckerAnalyzer(checkPrintfRules),
	"SA5010": {
		Run:      CheckImpossibleTypeAssertion,
		Requires: []*analysis.Analyzer{buildir.Analyzer, facts.TokenFile},
	},
	"SA5011": {
		Run:      CheckMaybeNil,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA5012": {
		Run:       CheckEvenSliceLength,
		FactTypes: []analysis.Fact{new(evenElements)},
		Requires:  []*analysis.Analyzer{buildir.Analyzer},
	},

	"SA6000": makeCallCheckerAnalyzer(checkRegexpMatchLoopRules),
	"SA6001": {
		Run:      CheckMapBytesKey,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA6002": makeCallCheckerAnalyzer(checkSyncPoolValueRules),
	"SA6003": {
		Run:      CheckRangeStringRunes,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"SA6005": {
		Run:      CheckToLowerToUpperComparison,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},

	"SA9001": {
		Run:      CheckDubiousDeferInChannelRangeLoop,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA9002": {
		Run:      CheckNonOctalFileMode,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"SA9003": {
		Run:      CheckEmptyBranch,
		Requires: []*analysis.Analyzer{buildir.Analyzer, facts.TokenFile, facts.Generated},
	},
	"SA9004": {
		Run:      CheckMissingEnumTypesInDeclaration,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},

	"SA9005": makeCallCheckerAnalyzer(checkNoopMarshal, facts.Generated),
	"SA9006": {
		Run:      CheckStaticBitShift,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
})

var Docs = lint.Markdownify(map[string]*lint.Documentation{
	"SA1000": {
		Title:    `Invalid regular expression`,
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1001": {
		Title:    `Invalid template`,
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1002": {
		Title:    "Invalid format in `time.Parse`",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1003": {
		Title: "Unsupported argument to functions in `encoding/binary`",
		Text:  "" /* 318 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1004": {
		Title: "Suspiciously small untyped constant in `time.Sleep`",
		Text:  "" /* 665 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1005": {
		Title: "Invalid first argument to `exec.Command`",
		Text:  "" /* 686 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1006": {
		Title: `Printf with dynamic first argument and no further arguments`,
		Text:  "" /* 623 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1007": {
		Title:    "Invalid URL in `net/url.Parse`",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1008": {
		Title: "Non-canonical key in `http.Header` map",
		Text:  "" /* 744 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1010": {
		Title: "`(*regexp.Regexp).FindAll` called with `n == 0`, which will always return zero results",
		Text: `If n >= 0, the function returns at most n matches/submatches. To
return all results, specify a negative number.`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1011": {
		Title:    "Various methods in the `strings` package expect valid UTF-8, but invalid input is provided",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1012": {
		Title:    "A nil `context.Context` is being passed to a function, consider using `context.TODO` instead",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1013": {
		Title:    "`io.Seeker.Seek` is being called with the whence constant as the first argument, but it should be the second",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1014": {
		Title:    "Non-pointer value passed to `Unmarshal` or `Decode`",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1015": {
		Title:    "" /* 143 byte string literal not displayed */,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1016": {
		Title: `Trapping a signal that cannot be trapped`,
		Text:  "" /* 278 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1017": {
		Title: "Channels used with `os/signal.Notify` should be buffered",
		Text:  "" /* 388 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1018": {
		Title: "`strings.Replace` called with `n == 0`, which does nothing",
		Text: `With n == 0, zero instances will be replaced. To replace all
instances, use a negative number, or use strings.ReplaceAll.`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1019": {
		Title:    `Using a deprecated function, variable, constant or field`,
		Since:    "2017.1",
		Severity: lint.SeverityDeprecated,
	},

	"SA1020": {
		Title:    "Using an invalid host:port pair with a `net.Listen`-related function",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1021": {
		Title: "Using `bytes.Equal` to compare two `net.IP`",
		Text:  "" /* 345 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1023": {
		Title:    "Modifying the buffer in an `io.Writer` implementation",
		Text:     `\'Write\' must not modify the slice data, even temporarily.`,
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA1024": {
		Title: `A string cutset contains duplicate characters`,
		Text:  "" /* 412 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA1025": {
		Title:    "It is not possible to use `(*time.Timer).Reset`'s return value correctly",
		Since:    "2019.1",
		Severity: lint.SeverityWarning,
	},

	"SA1026": {
		Title:    `Cannot marshal channels or functions`,
		Since:    "2019.2",
		Severity: lint.SeverityError,
	},

	"SA1027": {
		Title: `Atomic access to 64-bit variable must be 64-bit aligned`,
		Text:  "" /* 333 byte string literal not displayed */,

		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA1028": {
		Title:    "`sort.Slice` can only be used on slices",
		Text:     `The first argument of sort.Slice must be a slice.`,
		Since:    "2020.1",
		Severity: lint.SeverityError,
	},

	"SA1029": {
		Title: "Inappropriate key in call to `context.WithValue`",
		Text:  "" /* 412 byte string literal not displayed */,

		Since:    "2020.1",
		Severity: lint.SeverityWarning,
	},

	"SA1030": {
		Title: "Invalid argument in call to a `strconv` function",
		Text:  "" /* 133 byte string literal not displayed */,

		Since:    "2021.1",
		Severity: lint.SeverityError,
	},

	"SA2000": {
		Title:    "`sync.WaitGroup.Add` called inside the goroutine, leading to a race condition",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA2001": {
		Title: `Empty critical section, did you mean to defer the unlock?`,
		Text:  "" /* 540 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA2002": {
		Title:    "Called `testing.T.FailNow` or `SkipNow` in a goroutine, which isn't allowed",
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA2003": {
		Title:    "Deferred `Lock` right after locking, likely meant to defer `Unlock` instead",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA3000": {
		Title: "`TestMain` doesn't call `os.Exit`, hiding test failures",
		Text:  "" /* 371 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA3001": {
		Title: "Assigning to `b.N` in benchmarks distorts the results",
		Text:  "" /* 233 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA4000": {
		Title:    `Boolean expression has identical expressions on both sides`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4001": {
		Title:    "`&*x` gets simplified to `x`, it does not copy `x`",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4002": {
		Title:    `Comparing strings with known different sizes has predictable results`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4003": {
		Title:    `Comparing unsigned values against negative values is pointless`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4004": {
		Title:    `The loop exits unconditionally after one iteration`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4005": {
		Title:    `Field assignment that will never be observed. Did you mean to use a pointer receiver?`,
		Since:    "2021.1",
		Severity: lint.SeverityWarning,
	},

	"SA4006": {
		Title:    `A value assigned to a variable is never read before being overwritten. Forgotten error check or dead code?`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4008": {
		Title:    `The variable in the loop condition never changes, are you incrementing the wrong variable?`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4009": {
		Title:    `A function argument is overwritten before its first use`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4010": {
		Title:    "The result of `append` will never be observed anywhere",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4011": {
		Title:    `Break statement with no effect. Did you mean to break out of an outer loop?`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4012": {
		Title:    `Comparing a value against NaN even though no value is equal to NaN`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4013": {
		Title:    "Negating a boolean twice (`!!b`) is the same as writing `b`. This is either redundant, or a typo.",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4014": {
		Title:    "" /* 151 byte string literal not displayed */,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4015": {
		Title:    "Calling functions like `math.Ceil` on floats converted from integers doesn't do anything useful",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4016": {
		Title:    "Certain bitwise operations, such as `x ^ 0`, do not do anything useful",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4017": {
		Title:    `A pure function's return value is discarded, making the call pointless`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4018": {
		Title:    `Self-assignment of variables`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4019": {
		Title:    `Multiple, identical build constraints in the same file`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA4020": {
		Title: `Unreachable case clause in a type switch`,
		Text:  "" /* 1555 byte string literal not displayed */,

		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA4021": {
		Title:    "`x = append(y)` is equivalent to `x = y`",
		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA4022": {
		Title:    `Comparing the address of a variable against nil`,
		Text:     `Code such as \'if &x == nil\' is meaningless, because taking the address of a variable always yields a non-nil pointer.`,
		Since:    "2020.1",
		Severity: lint.SeverityWarning,
	},

	"SA4023": {
		Title: `Impossible comparison of interface value with untyped nil`,
		Text:  "" /* 2418 byte string literal not displayed */,

		Since:    "2020.2",
		Severity: lint.SeverityWarning,
	},

	"SA4024": {
		Title: `Checking for impossible return value from a builtin function`,
		Text:  "" /* 234 byte string literal not displayed */,

		Since:    "2021.1",
		Severity: lint.SeverityWarning,
	},

	"SA4025": {
		Title: "Integer division of literals that results in zero",
		Text:  "" /* 509 byte string literal not displayed */,

		Since:    "2021.1",
		Severity: lint.SeverityWarning,
	},

	"SA4026": {
		Title: "Go constants cannot express negative zero",
		Text:  "" /* 438 byte string literal not displayed */,

		Since:    "2021.1",
		Severity: lint.SeverityWarning,
	},
	"SA4027": {
		Title: "(*net/url.URL).Query returns a copy, modifying it doesn't change the URL",
		Text:  "" /* 354 byte string literal not displayed */,

		Since:    "2021.1",
		Severity: lint.SeverityWarning,
	},

	"SA5000": {
		Title:    `Assignment to nil map`,
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA5001": {
		Title:    "Deferring `Close` before checking for a possible error",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5002": {
		Title:    "The empty for loop (`for {}`) spins and can block the scheduler",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5003": {
		Title: `Defers in infinite loops will never execute`,
		Text:  "" /* 174 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5004": {
		Title:    "`for { select { ...` with an empty default branch spins",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5005": {
		Title: `The finalizer references the finalized object, preventing garbage collection`,
		Text:  "" /* 656 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5006": {
		Title:    `Slice index out of bounds`,
		Since:    "2017.1",
		Severity: lint.SeverityError,
	},

	"SA5007": {
		Title: `Infinite recursive call`,
		Text:  "" /* 447 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA5008": {
		Title:    `Invalid struct tag`,
		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA5009": {
		Title:    `Invalid Printf call`,
		Since:    "2019.2",
		Severity: lint.SeverityError,
	},

	"SA5010": {
		Title: `Impossible type assertion`,

		Text: "" /* 690 byte string literal not displayed */,

		Since:    "2020.1",
		Severity: lint.SeverityWarning,
	},

	"SA5011": {
		Title: `Possible nil pointer dereference`,

		Text: "" /* 1832 byte string literal not displayed */,

		Since:    "2020.1",
		Severity: lint.SeverityWarning,
	},

	"SA5012": {
		Title: "Passing odd-sized slice to function expecting even size",
		Text:  "" /* 301 byte string literal not displayed */,

		Since:    "2020.2",
		Severity: lint.SeverityError,
	},

	"SA6000": {
		Title:    "Using `regexp.Match` or related in a loop, should use `regexp.Compile`",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA6001": {
		Title: `Missing an optimization opportunity when indexing maps by byte slices`,

		Text: "" /* 818 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA6002": {
		Title: "Storing non-pointer values in `sync.Pool` allocates memory",
		Text:  "" /* 600 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA6003": {
		Title: `Converting a string to a slice of runes before ranging over it`,
		Text:  "" /* 579 byte string literal not displayed */,

		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA6005": {
		Title: "Inefficient string comparison with `strings.ToLower` or `strings.ToUpper`",
		Text:  "" /* 781 byte string literal not displayed */,

		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA9001": {
		Title:    `Defers in range loops may not run when you expect them to`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA9002": {
		Title:    "Using a non-octal `os.FileMode` that looks like it was meant to be in octal.",
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA9003": {
		Title:    `Empty body in an if or else branch`,
		Since:    "2017.1",
		Severity: lint.SeverityWarning,
	},

	"SA9004": {
		Title: `Only the first constant has an explicit type`,

		Text: "" /* 1687 byte string literal not displayed */,

		Since:    "2019.1",
		Severity: lint.SeverityWarning,
	},

	"SA9005": {
		Title: `Trying to marshal a struct with no public fields nor custom marshaling`,
		Text:  "" /* 370 byte string literal not displayed */,

		Since:    "2019.2",
		Severity: lint.SeverityWarning,
	},

	"SA9006": {
		Title: `Dubious bit shifting of a fixed size integer value`,
		Text:  "" /* 512 byte string literal not displayed */,

		Since:    "2020.2",
		Severity: lint.SeverityWarning,
	},
})

type Argument struct {
	Value Value
	// contains filtered or unexported fields
}

type Call struct {
	Pass  *analysis.Pass
	Instr ir.CallInstruction
	Args  []*Argument

	Parent *ir.Function
	// contains filtered or unexported fields
}

type CallCheck func(call *Call)

type Value struct {
	Value ir.Value
}