staticcheck

package
v0.0.0-...-1f0868a Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 30, 2019 License: MIT Imports: 37 Imported by: 0

Documentation

Overview

Package staticcheck contains a linter for Go source code.

Index

Constants

View Source 
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

View Source 
var Analyzers = map[string]*analysis.Analyzer{
	"SA1000": {
		Name:     "SA1000",
		Run:      callChecker(checkRegexpRules),
		Doc:      docSA1000,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1001": {
		Name:     "SA1001",
		Run:      CheckTemplate,
		Doc:      docSA1001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1002": {
		Name:     "SA1002",
		Run:      callChecker(checkTimeParseRules),
		Doc:      docSA1002,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1003": {
		Name:     "SA1003",
		Run:      callChecker(checkEncodingBinaryRules),
		Doc:      docSA1003,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1004": {
		Name:     "SA1004",
		Run:      CheckTimeSleepConstant,
		Doc:      docSA1004,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1005": {
		Name:     "SA1005",
		Run:      CheckExec,
		Doc:      docSA1005,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1006": {
		Name:     "SA1006",
		Run:      CheckUnsafePrintf,
		Doc:      docSA1006,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1007": {
		Name:     "SA1007",
		Run:      callChecker(checkURLsRules),
		Doc:      docSA1007,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1008": {
		Name:     "SA1008",
		Run:      CheckCanonicalHeaderKey,
		Doc:      docSA1008,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1010": {
		Name:     "SA1010",
		Run:      callChecker(checkRegexpFindAllRules),
		Doc:      docSA1010,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1011": {
		Name:     "SA1011",
		Run:      callChecker(checkUTF8CutsetRules),
		Doc:      docSA1011,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1012": {
		Name:     "SA1012",
		Run:      CheckNilContext,
		Doc:      docSA1012,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1013": {
		Name:     "SA1013",
		Run:      CheckSeeker,
		Doc:      docSA1013,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1014": {
		Name:     "SA1014",
		Run:      callChecker(checkUnmarshalPointerRules),
		Doc:      docSA1014,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1015": {
		Name:     "SA1015",
		Run:      CheckLeakyTimeTick,
		Doc:      docSA1015,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1016": {
		Name:     "SA1016",
		Run:      CheckUntrappableSignal,
		Doc:      docSA1016,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1017": {
		Name:     "SA1017",
		Run:      callChecker(checkUnbufferedSignalChanRules),
		Doc:      docSA1017,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1018": {
		Name:     "SA1018",
		Run:      callChecker(checkStringsReplaceZeroRules),
		Doc:      docSA1018,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1019": {
		Name:     "SA1019",
		Run:      CheckDeprecated,
		Doc:      docSA1019,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Deprecated},
		Flags:    newFlagSet(),
	},
	"SA1020": {
		Name:     "SA1020",
		Run:      callChecker(checkListenAddressRules),
		Doc:      docSA1020,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1021": {
		Name:     "SA1021",
		Run:      callChecker(checkBytesEqualIPRules),
		Doc:      docSA1021,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1023": {
		Name:     "SA1023",
		Run:      CheckWriterBufferModified,
		Doc:      docSA1023,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1024": {
		Name:     "SA1024",
		Run:      callChecker(checkUniqueCutsetRules),
		Doc:      docSA1024,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1025": {
		Name:     "SA1025",
		Run:      CheckTimerResetReturnValue,
		Doc:      docSA1025,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA1026": {
		Name:     "SA1026",
		Run:      callChecker(checkUnsupportedMarshal),
		Doc:      docSA1026,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA1027": {
		Name:     "SA1027",
		Run:      callChecker(checkAtomicAlignment),
		Doc:      docSA1027,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},

	"SA2000": {
		Name:     "SA2000",
		Run:      CheckWaitgroupAdd,
		Doc:      docSA2000,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA2001": {
		Name:     "SA2001",
		Run:      CheckEmptyCriticalSection,
		Doc:      docSA2001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA2002": {
		Name:     "SA2002",
		Run:      CheckConcurrentTesting,
		Doc:      docSA2002,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA2003": {
		Name:     "SA2003",
		Run:      CheckDeferLock,
		Doc:      docSA2003,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},

	"SA3000": {
		Name:     "SA3000",
		Run:      CheckTestMainExit,
		Doc:      docSA3000,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA3001": {
		Name:     "SA3001",
		Run:      CheckBenchmarkN,
		Doc:      docSA3001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},

	"SA4000": {
		Name:     "SA4000",
		Run:      CheckLhsRhsIdentical,
		Doc:      docSA4000,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.TokenFile, facts.Generated},
		Flags:    newFlagSet(),
	},
	"SA4001": {
		Name:     "SA4001",
		Run:      CheckIneffectiveCopy,
		Doc:      docSA4001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4002": {
		Name:     "SA4002",
		Run:      CheckDiffSizeComparison,
		Doc:      docSA4002,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA4003": {
		Name:     "SA4003",
		Run:      CheckExtremeComparison,
		Doc:      docSA4003,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4004": {
		Name:     "SA4004",
		Run:      CheckIneffectiveLoop,
		Doc:      docSA4004,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4006": {
		Name:     "SA4006",
		Run:      CheckUnreadVariableValues,
		Doc:      docSA4006,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4008": {
		Name:     "SA4008",
		Run:      CheckLoopCondition,
		Doc:      docSA4008,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4009": {
		Name:     "SA4009",
		Run:      CheckArgOverwritten,
		Doc:      docSA4009,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4010": {
		Name:     "SA4010",
		Run:      CheckIneffectiveAppend,
		Doc:      docSA4010,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4011": {
		Name:     "SA4011",
		Run:      CheckScopedBreak,
		Doc:      docSA4011,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4012": {
		Name:     "SA4012",
		Run:      CheckNaNComparison,
		Doc:      docSA4012,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4013": {
		Name:     "SA4013",
		Run:      CheckDoubleNegation,
		Doc:      docSA4013,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4014": {
		Name:     "SA4014",
		Run:      CheckRepeatedIfElse,
		Doc:      docSA4014,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4015": {
		Name:     "SA4015",
		Run:      callChecker(checkMathIntRules),
		Doc:      docSA4015,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA4016": {
		Name:     "SA4016",
		Run:      CheckSillyBitwiseOps,
		Doc:      docSA4016,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, facts.TokenFile},
		Flags:    newFlagSet(),
	},
	"SA4017": {
		Name:     "SA4017",
		Run:      CheckPureFunctions,
		Doc:      docSA4017,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, facts.Purity},
		Flags:    newFlagSet(),
	},
	"SA4018": {
		Name:     "SA4018",
		Run:      CheckSelfAssignment,
		Doc:      docSA4018,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
		Flags:    newFlagSet(),
	},
	"SA4019": {
		Name:     "SA4019",
		Run:      CheckDuplicateBuildConstraints,
		Doc:      docSA4019,
		Requires: []*analysis.Analyzer{facts.Generated},
		Flags:    newFlagSet(),
	},
	"SA4020": {
		Name:     "SA4020",
		Run:      CheckUnreachableTypeCases,
		Doc:      docSA4020,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA4021": {
		Name:     "SA4021",
		Run:      CheckSingleArgAppend,
		Doc:      docSA4021,
		Requires: []*analysis.Analyzer{inspect.Analyzer, facts.Generated, facts.TokenFile},
		Flags:    newFlagSet(),
	},

	"SA5000": {
		Name:     "SA5000",
		Run:      CheckNilMaps,
		Doc:      docSA5000,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5001": {
		Name:     "SA5001",
		Run:      CheckEarlyDefer,
		Doc:      docSA5001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5002": {
		Name:     "SA5002",
		Run:      CheckInfiniteEmptyLoop,
		Doc:      docSA5002,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5003": {
		Name:     "SA5003",
		Run:      CheckDeferInInfiniteLoop,
		Doc:      docSA5003,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5004": {
		Name:     "SA5004",
		Run:      CheckLoopEmptyDefault,
		Doc:      docSA5004,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5005": {
		Name:     "SA5005",
		Run:      CheckCyclicFinalizer,
		Doc:      docSA5005,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5007": {
		Name:     "SA5007",
		Run:      CheckInfiniteRecursion,
		Doc:      docSA5007,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5008": {
		Name:     "SA5008",
		Run:      CheckStructTags,
		Doc:      docSA5008,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA5009": {
		Name:     "SA5009",
		Run:      callChecker(checkPrintfRules),
		Doc:      docSA5009,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},

	"SA6000": {
		Name:     "SA6000",
		Run:      callChecker(checkRegexpMatchLoopRules),
		Doc:      docSA6000,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA6001": {
		Name:     "SA6001",
		Run:      CheckMapBytesKey,
		Doc:      docSA6001,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA6002": {
		Name:     "SA6002",
		Run:      callChecker(checkSyncPoolValueRules),
		Doc:      docSA6002,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer},
		Flags:    newFlagSet(),
	},
	"SA6003": {
		Name:     "SA6003",
		Run:      CheckRangeStringRunes,
		Doc:      docSA6003,
		Requires: []*analysis.Analyzer{buildssa.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA6005": {
		Name:     "SA6005",
		Run:      CheckToLowerToUpperComparison,
		Doc:      docSA6005,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},

	"SA9001": {
		Name:     "SA9001",
		Run:      CheckDubiousDeferInChannelRangeLoop,
		Doc:      docSA9001,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA9002": {
		Name:     "SA9002",
		Run:      CheckNonOctalFileMode,
		Doc:      docSA9002,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},
	"SA9003": {
		Name:     "SA9003",
		Run:      CheckEmptyBranch,
		Doc:      docSA9003,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, facts.TokenFile, facts.Generated},
		Flags:    newFlagSet(),
	},
	"SA9004": {
		Name:     "SA9004",
		Run:      CheckMissingEnumTypesInDeclaration,
		Doc:      docSA9004,
		Requires: []*analysis.Analyzer{inspect.Analyzer},
		Flags:    newFlagSet(),
	},

	"SA9005": {
		Name:     "SA9005",
		Run:      callChecker(checkNoopMarshal),
		Doc:      docSA9005,
		Requires: []*analysis.Analyzer{buildssa.Analyzer, valueRangesAnalyzer, facts.Generated, facts.TokenFile},
		Flags:    newFlagSet(),
	},
}

Functions

func CanBinaryMarshal 

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

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 CheckDiffSizeComparison 

func CheckDiffSizeComparison(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 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 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 IntValue 

func IntValue(v Value, z vrp.Z) 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

Types

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 ssa.CallInstruction
	Args  []*Argument

	Parent *ssa.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 ssa.Value
	Range vrp.Range
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.