Back to godoc.org
honnef.co/go/tools / staticcheck

Package staticcheck

v0.0.1 (2020.1.5)
Latest Go to latest
Published: 5 days ago | License: MIT | Module: honnef.co/go/tools

Overview

Package staticcheck contains a linter for Go source code.

Index

Package Files

Constants

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"
)

Variables

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

	"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},
	},
	"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},
	},

	"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},
	},

	"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),

	"SA4022": {
		Run:      CheckAddressIsNil,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
	},
})
var Docs = map[string]*lint.Documentation{
	"SA1000": {
		Title: `Invalid regular expression`,
		Since: "2017.1",
	},

	"SA1001": {
		Title: `Invalid template`,
		Since: "2017.1",
	},

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

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

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

		Since: "2017.1",
	},

	"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",
	},

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

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

	"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",
	},

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

	"SA1015": {
		Title: "" /* 135 byte string literal not displayed */,
		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

	"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",
	},

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

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

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

		Since: "2017.1",
	},

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

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

		Since: "2017.1",
	},

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

	"SA1026": {
		Title: `Cannot marshal channels or functions`,
		Since: "2019.2",
	},

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

		Since: "2019.2",
	},

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

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

		Since: "2020.1",
	},

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

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

		Since: "2017.1",
	},

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

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

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

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

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

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

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

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

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

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

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

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

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

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

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

	"SA4014": {
		Title: "" /* 149 byte string literal not displayed */,
		Since: "2017.1",
	},

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

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

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

	"SA4018": {
		Title: `Self-assignment of variables`,
		Since: "2017.1",
	},

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

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

		Since: "2019.2",
	},

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

	"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",
	},

	"SA5000": {
		Title: `Assignment to nil map`,
		Since: "2017.1",
	},

	"SA5001": {
		Title: `Defering Close before checking for a possible error`,
		Since: "2017.1",
	},

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

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

		Since: "2017.1",
	},

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

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

		Since: "2017.1",
	},

	"SA5006": {
		Title: `Slice index out of bounds`,
		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

	"SA5008": {
		Title: `Invalid struct tag`,
		Since: "2019.2",
	},

	"SA5009": {
		Title: `Invalid Printf call`,
		Since: "2019.2",
	},

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

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

		Since: "2020.1",
	},

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

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

		Since: "2020.1",
	},

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

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

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

		Since: "2017.1",
	},

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

		Since: "2019.2",
	},

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

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

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

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

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

		Since: "2019.1",
	},

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

		Since: "2019.2",
	},
}

func CanBinaryMarshal

func CanBinaryMarshal(pass *analysis.Pass, v Value) bool

func CheckAddressIsNil

func CheckAddressIsNil(pass *analysis.Pass) (interface{}, error)

func CheckArgOverwritten

func CheckArgOverwritten(pass *analysis.Pass) (interface{}, error)

func CheckBenchmarkN

func CheckBenchmarkN(pass *analysis.Pass) (interface{}, error)

func CheckCanonicalHeaderKey

func CheckCanonicalHeaderKey(pass *analysis.Pass) (interface{}, error)

func CheckConcurrentTesting

func CheckConcurrentTesting(pass *analysis.Pass) (interface{}, error)

func CheckCyclicFinalizer

func CheckCyclicFinalizer(pass *analysis.Pass) (interface{}, error)

func CheckDeferInInfiniteLoop

func CheckDeferInInfiniteLoop(pass *analysis.Pass) (interface{}, error)

func CheckDeferLock

func CheckDeferLock(pass *analysis.Pass) (interface{}, error)

func CheckDeprecated

func CheckDeprecated(pass *analysis.Pass) (interface{}, error)

func CheckDoubleNegation

func CheckDoubleNegation(pass *analysis.Pass) (interface{}, error)

func CheckDubiousDeferInChannelRangeLoop

func CheckDubiousDeferInChannelRangeLoop(pass *analysis.Pass) (interface{}, error)

func CheckDuplicateBuildConstraints

func CheckDuplicateBuildConstraints(pass *analysis.Pass) (interface{}, error)

func CheckEarlyDefer

func CheckEarlyDefer(pass *analysis.Pass) (interface{}, error)

func CheckEmptyBranch

func CheckEmptyBranch(pass *analysis.Pass) (interface{}, error)

func CheckEmptyCriticalSection

func CheckEmptyCriticalSection(pass *analysis.Pass) (interface{}, error)

func CheckExec

func CheckExec(pass *analysis.Pass) (interface{}, error)

func CheckExtremeComparison

func CheckExtremeComparison(pass *analysis.Pass) (interface{}, error)

func CheckImpossibleTypeAssertion

func CheckImpossibleTypeAssertion(pass *analysis.Pass) (interface{}, error)

func CheckIneffectiveAppend

func CheckIneffectiveAppend(pass *analysis.Pass) (interface{}, error)

func CheckIneffectiveCopy

func CheckIneffectiveCopy(pass *analysis.Pass) (interface{}, error)

func CheckIneffectiveLoop

func CheckIneffectiveLoop(pass *analysis.Pass) (interface{}, error)

func CheckInfiniteEmptyLoop

func CheckInfiniteEmptyLoop(pass *analysis.Pass) (interface{}, error)

func CheckInfiniteRecursion

func CheckInfiniteRecursion(pass *analysis.Pass) (interface{}, error)

func CheckLeakyTimeTick

func CheckLeakyTimeTick(pass *analysis.Pass) (interface{}, error)

func CheckLhsRhsIdentical

func CheckLhsRhsIdentical(pass *analysis.Pass) (interface{}, error)

func CheckLoopCondition

func CheckLoopCondition(pass *analysis.Pass) (interface{}, error)

func CheckLoopEmptyDefault

func CheckLoopEmptyDefault(pass *analysis.Pass) (interface{}, error)

func CheckMapBytesKey

func CheckMapBytesKey(pass *analysis.Pass) (interface{}, error)

func CheckMaybeNil

func CheckMaybeNil(pass *analysis.Pass) (interface{}, error)

func CheckMissingEnumTypesInDeclaration

func CheckMissingEnumTypesInDeclaration(pass *analysis.Pass) (interface{}, error)

func CheckNaNComparison

func CheckNaNComparison(pass *analysis.Pass) (interface{}, error)

func CheckNilContext

func CheckNilContext(pass *analysis.Pass) (interface{}, error)

func CheckNilMaps

func CheckNilMaps(pass *analysis.Pass) (interface{}, error)

func CheckNonOctalFileMode

func CheckNonOctalFileMode(pass *analysis.Pass) (interface{}, error)

func CheckPredeterminedBooleanExprs

func CheckPredeterminedBooleanExprs(pass *analysis.Pass) (interface{}, error)

func CheckPureFunctions

func CheckPureFunctions(pass *analysis.Pass) (interface{}, error)

func CheckRangeStringRunes

func CheckRangeStringRunes(pass *analysis.Pass) (interface{}, error)

func CheckRepeatedIfElse

func CheckRepeatedIfElse(pass *analysis.Pass) (interface{}, error)

func CheckScopedBreak

func CheckScopedBreak(pass *analysis.Pass) (interface{}, error)

func CheckSeeker

func CheckSeeker(pass *analysis.Pass) (interface{}, error)

func CheckSelfAssignment

func CheckSelfAssignment(pass *analysis.Pass) (interface{}, error)

func CheckSillyBitwiseOps

func CheckSillyBitwiseOps(pass *analysis.Pass) (interface{}, error)

func CheckSillyRegexp

func CheckSillyRegexp(pass *analysis.Pass) (interface{}, error)

func CheckSingleArgAppend

func CheckSingleArgAppend(pass *analysis.Pass) (interface{}, error)

func CheckStructTags

func CheckStructTags(pass *analysis.Pass) (interface{}, error)

func CheckTemplate

func CheckTemplate(pass *analysis.Pass) (interface{}, error)

func CheckTestMainExit

func CheckTestMainExit(pass *analysis.Pass) (interface{}, error)

func CheckTimeSleepConstant

func CheckTimeSleepConstant(pass *analysis.Pass) (interface{}, error)

func CheckTimerResetReturnValue

func CheckTimerResetReturnValue(pass *analysis.Pass) (interface{}, error)

func CheckToLowerToUpperComparison

func CheckToLowerToUpperComparison(pass *analysis.Pass) (interface{}, error)

func CheckUnreachableTypeCases

func CheckUnreachableTypeCases(pass *analysis.Pass) (interface{}, error)

func CheckUnreadVariableValues

func CheckUnreadVariableValues(pass *analysis.Pass) (interface{}, error)

func CheckUnsafePrintf

func CheckUnsafePrintf(pass *analysis.Pass) (interface{}, error)

func CheckUntrappableSignal

func CheckUntrappableSignal(pass *analysis.Pass) (interface{}, error)

func CheckWaitgroupAdd

func CheckWaitgroupAdd(pass *analysis.Pass) (interface{}, error)

func CheckWriterBufferModified

func CheckWriterBufferModified(pass *analysis.Pass) (interface{}, error)

func ConvertedFrom

func ConvertedFrom(v Value, typ string) bool

ConvertedFrom reports whether value v was converted from type typ.

func ConvertedFromInt

func ConvertedFromInt(v Value) bool

func InvalidUTF8

func InvalidUTF8(v Value) bool

func Pointer

func Pointer(v Value) bool

func UnbufferedChannel

func UnbufferedChannel(v Value) bool

func UniqueStringCutset

func UniqueStringCutset(v Value) bool

func ValidHostPort

func ValidHostPort(v Value) bool

func ValidateRegexp

func ValidateRegexp(v Value) error

func ValidateTimeLayout

func ValidateTimeLayout(v Value) error

func ValidateURL

func ValidateURL(v Value) error

type Argument

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

func (*Argument) Invalid

func (arg *Argument) Invalid(msg string)

type Call

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

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

func (*Call) Invalid

func (c *Call) Invalid(msg string)

type CallCheck

type CallCheck func(call *Call)

func RepeatZeroTimes

func RepeatZeroTimes(name string, arg int) CallCheck

type Value

type Value struct {
	Value ir.Value
}
Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier