var Analyzers = lintutil.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},
	},
})

var Docs = 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:  "" /* 151 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: `Raw string literals use ` + "`" + "" /* 340 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:  "" /* 260 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:  "" /* 152 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:  "" /* 413 byte string literal not displayed */,

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

	"S1019": {
		Title: `Simplify make call by omitting redundant arguments`,
		Text:  "" /* 191 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:  "" /* 152 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:  "" /* 158 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:  "" /* 252 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:  "" /* 190 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",
	},
}