var Analyzers = lint.InitializeAnalyzers(Docs, map[string]*analysis.Analyzer{
	"S1000": {
		Run:      CheckSingleCaseSelect,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1001": {
		Run:      CheckLoopCopy,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1002": {
		Run:      CheckIfBoolCmp,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1003": {
		Run:      CheckStringsContains,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1004": {
		Run:      CheckBytesCompare,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1005": {
		Run:      CheckUnnecessaryBlank,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1006": {
		Run:      CheckForTrue,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1007": {
		Run:      CheckRegexpRaw,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1008": {
		Run:      CheckIfReturn,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1009": {
		Run:      CheckRedundantNilCheckWithLen,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1010": {
		Run:      CheckSlicing,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1011": {
		Run:      CheckLoopAppend,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1012": {
		Run:      CheckTimeSince,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1016": {
		Run:      CheckSimplerStructConversion,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1017": {
		Run:      CheckTrim,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1018": {
		Run:      CheckLoopSlide,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1019": {
		Run:      CheckMakeLenCap,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1020": {
		Run:      CheckAssertNotNil,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1021": {
		Run:      CheckDeclareAssign,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1023": {
		Run:      CheckRedundantBreak,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1024": {
		Run:      CheckTimeUntil,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1025": {
		Run:      CheckRedundantSprintf,
		Requires: []*analysis.Analyzer{buildir.Analyzer, inspect.Analyzer, facts.Generated},
	},
	"S1028": {
		Run:      CheckErrorsNewSprintf,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1029": {
		Run:      CheckRangeStringRunes,
		Requires: []*analysis.Analyzer{buildir.Analyzer},
	},
	"S1030": {
		Run:      CheckBytesBufferConversions,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1031": {
		Run:      CheckNilCheckAroundRange,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1032": {
		Run:      CheckSortHelpers,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1033": {
		Run:      CheckGuardedDelete,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1034": {
		Run:      CheckSimplifyTypeSwitch,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1035": {
		Run:      CheckRedundantCanonicalHeaderKey,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1036": {
		Run:      CheckUnnecessaryGuard,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
	"S1037": {
		Run:      CheckElaborateSleep,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1038": {
		Run:      CheckPrintSprintf,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1039": {
		Run:      CheckSprintLiteral,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
	"S1040": {
		Run:      CheckSameTypeTypeAssertion,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated},
	},
})

var Docs = lint.Markdownify(map[string]*lint.Documentation{
	"S1000": {
		Title: `Use plain channel send or receive instead of single-case select`,
		Text:  "" /* 199 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1001": {
		Title: `Replace for loop with call to copy`,
		Text:  "" /* 155 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1002": {
		Title: `Omit comparison with boolean constant`,
		Text: `Before:

    if x == true {}

After:

    if x {}`,
		Since: "2017.1",
	},

	"S1003": {
		Title: "Replace call to `strings.Index` with `strings.Contains`",
		Text: `Before:

    if strings.Index(x, y) != -1 {}

After:

    if strings.Contains(x, y) {}`,
		Since: "2017.1",
	},

	"S1004": {
		Title: "Replace call to `bytes.Compare` with `bytes.Equal`",
		Text: `Before:

    if bytes.Compare(x, y) == 0 {}

After:

    if bytes.Equal(x, y) {}`,
		Since: "2017.1",
	},

	"S1005": {
		Title: `Drop unnecessary use of the blank identifier`,
		Text:  "" /* 193 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1006": {
		Title: "Use `for { ... }` for infinite loops",
		Text:  `For infinite loops, using \'for { ... }\' is the most idiomatic choice.`,
		Since: "2017.1",
	},

	"S1007": {
		Title: `Simplify regular expression by using raw string literal`,
		Text: "" /* 370 byte string literal not displayed */+
			"`" + `\A(\w+) profile: total \d+\n\z` + "`" + `)`,
		Since: "2017.1",
	},

	"S1008": {
		Title: `Simplify returning boolean expression`,
		Text: `Before:

    if <expr> {
        return true
    }
    return false

After:

    return <expr>`,
		Since: "2017.1",
	},

	"S1009": {
		Title: `Omit redundant nil check on slices`,
		Text:  "" /* 264 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1010": {
		Title: `Omit default slice index`,
		Text: `When slicing, the second index defaults to the length of the value,
making \'s[n:len(s)]\' and \'s[n:]\' equivalent.`,
		Since: "2017.1",
	},

	"S1011": {
		Title: "Use a single `append` to concatenate two slices",
		Text: `Before:

    for _, e := range y {
        x = append(x, e)
    }

After:

    x = append(x, y...)`,
		Since: "2017.1",
	},

	"S1012": {
		Title: "Replace `time.Now().Sub(x)` with `time.Since(x)`",
		Text:  "" /* 160 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1016": {
		Title: `Use a type conversion instead of manually copying struct fields`,
		Text:  "" /* 414 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1017": {
		Title: "Replace manual trimming with `strings.TrimPrefix`",
		Text:  "" /* 425 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1018": {
		Title: "Use `copy` for sliding elements",
		Text:  "" /* 261 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1019": {
		Title: "Simplify `make` call by omitting redundant arguments",
		Text:  "" /* 195 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1020": {
		Title: `Omit redundant nil check in type assertion`,
		Text: `Before:

    if _, ok := i.(T); ok && i != nil {}

After:

    if _, ok := i.(T); ok {}`,
		Since: "2017.1",
	},

	"S1021": {
		Title: `Merge variable declaration and assignment`,
		Text: `Before:

    var x uint
    x = 1

After:

    var x uint = 1`,
		Since: "2017.1",
	},

	"S1023": {
		Title: `Omit redundant control flow`,
		Text:  "" /* 270 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1024": {
		Title: "Replace `x.Sub(time.Now())` with `time.Until(x)`",
		Text:  "" /* 160 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1025": {
		Title: "Don't use `fmt.Sprintf(\"%s\", x)` unnecessarily",
		Text:  "" /* 548 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1028": {
		Title: "Simplify error construction with `fmt.Errorf`",
		Text: `Before:

    errors.New(fmt.Sprintf(...))

After:

    fmt.Errorf(...)`,
		Since: "2017.1",
	},

	"S1029": {
		Title: `Range over the string directly`,
		Text:  "" /* 424 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1030": {
		Title: "Use `bytes.Buffer.String` or `bytes.Buffer.Bytes`",
		Text:  "" /* 334 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1031": {
		Title: `Omit redundant nil check around loop`,
		Text:  "" /* 286 byte string literal not displayed */,

		Since: "2017.1",
	},

	"S1032": {
		Title: "Use `sort.Ints(x)`, `sort.Float64s(x)`, and `sort.Strings(x)`",
		Text:  "" /* 276 byte string literal not displayed */,

		Since: "2019.1",
	},

	"S1033": {
		Title: "Unnecessary guard around call to `delete`",
		Text:  `Calling \'delete\' on a nil map is a no-op.`,
		Since: "2019.2",
	},

	"S1034": {
		Title: `Use result of type assertion to simplify cases`,
		Since: "2019.2",
	},

	"S1035": {
		Title: "Redundant call to `net/http.CanonicalHeaderKey` in method call on `net/http.Header`",
		Text: `The methods on \'net/http.Header\', namely \'Add\', \'Del\', \'Get\' and \'Set\', already
canonicalize the given header name.`,
		Since: "2020.1",
	},

	"S1036": {
		Title: `Unnecessary guard around map access`,

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

		Since: "2020.1",
	},

	"S1037": {
		Title: `Elaborate way of sleeping`,
		Text:  "" /* 194 byte string literal not displayed */,

		Since: "2020.1",
	},

	"S1038": {
		Title: "Unnecessarily complex way of printing formatted string",
		Text:  `Instead of using \'fmt.Print(fmt.Sprintf(...))\', one can use \'fmt.Printf(...)\'.`,
		Since: "2020.1",
	},

	"S1039": {
		Title: "Unnecessary use of `fmt.Sprint`",
		Text:  `Calling \'fmt.Sprint\' with a single string argument is unnecessary and identical to using the string directly.`,
		Since: "2020.1",
	},
	"S1040": {
		Title: "Type assertion to current type",
		Text:  "" /* 403 byte string literal not displayed */,

		Since: "2021.1",
	},
})