+++ /dev/null
-// Package staticcheck contains a linter for Go source code.
-package staticcheck // import "honnef.co/go/tools/staticcheck"
-
-import (
- "fmt"
- "go/ast"
- "go/constant"
- "go/token"
- "go/types"
- htmltemplate "html/template"
- "net/http"
- "reflect"
- "regexp"
- "regexp/syntax"
- "sort"
- "strconv"
- "strings"
- texttemplate "text/template"
- "unicode"
-
- . "honnef.co/go/tools/arg"
- "honnef.co/go/tools/code"
- "honnef.co/go/tools/deprecated"
- "honnef.co/go/tools/edit"
- "honnef.co/go/tools/facts"
- "honnef.co/go/tools/functions"
- "honnef.co/go/tools/internal/passes/buildir"
- "honnef.co/go/tools/internal/sharedcheck"
- "honnef.co/go/tools/ir"
- "honnef.co/go/tools/ir/irutil"
- "honnef.co/go/tools/lint"
- . "honnef.co/go/tools/lint/lintdsl"
- "honnef.co/go/tools/pattern"
- "honnef.co/go/tools/printf"
- "honnef.co/go/tools/report"
-
- "golang.org/x/tools/go/analysis"
- "golang.org/x/tools/go/analysis/passes/inspect"
- "golang.org/x/tools/go/ast/astutil"
- "golang.org/x/tools/go/ast/inspector"
- "golang.org/x/tools/go/types/typeutil"
-)
-
-func checkSortSlice(call *Call) {
- c := call.Instr.Common().StaticCallee()
- arg := call.Args[0]
-
- T := arg.Value.Value.Type().Underlying()
- switch T.(type) {
- case *types.Interface:
- // we don't know.
- // TODO(dh): if the value is a phi node we can look at its edges
- if k, ok := arg.Value.Value.(*ir.Const); ok && k.Value == nil {
- // literal nil, e.g. sort.Sort(nil, ...)
- arg.Invalid(fmt.Sprintf("cannot call %s on nil literal", c))
- }
- case *types.Slice:
- // this is fine
- default:
- // this is not fine
- arg.Invalid(fmt.Sprintf("%s must only be called on slices, was called on %s", c, T))
- }
-}
-
-func validRegexp(call *Call) {
- arg := call.Args[0]
- err := ValidateRegexp(arg.Value)
- if err != nil {
- arg.Invalid(err.Error())
- }
-}
-
-type runeSlice []rune
-
-func (rs runeSlice) Len() int { return len(rs) }
-func (rs runeSlice) Less(i int, j int) bool { return rs[i] < rs[j] }
-func (rs runeSlice) Swap(i int, j int) { rs[i], rs[j] = rs[j], rs[i] }
-
-func utf8Cutset(call *Call) {
- arg := call.Args[1]
- if InvalidUTF8(arg.Value) {
- arg.Invalid(MsgInvalidUTF8)
- }
-}
-
-func uniqueCutset(call *Call) {
- arg := call.Args[1]
- if !UniqueStringCutset(arg.Value) {
- arg.Invalid(MsgNonUniqueCutset)
- }
-}
-
-func unmarshalPointer(name string, arg int) CallCheck {
- return func(call *Call) {
- if !Pointer(call.Args[arg].Value) {
- call.Args[arg].Invalid(fmt.Sprintf("%s expects to unmarshal into a pointer, but the provided value is not a pointer", name))
- }
- }
-}
-
-func pointlessIntMath(call *Call) {
- if ConvertedFromInt(call.Args[0].Value) {
- call.Invalid(fmt.Sprintf("calling %s on a converted integer is pointless", code.CallName(call.Instr.Common())))
- }
-}
-
-func checkValidHostPort(arg int) CallCheck {
- return func(call *Call) {
- if !ValidHostPort(call.Args[arg].Value) {
- call.Args[arg].Invalid(MsgInvalidHostPort)
- }
- }
-}
-
-var (
- checkRegexpRules = map[string]CallCheck{
- "regexp.MustCompile": validRegexp,
- "regexp.Compile": validRegexp,
- "regexp.Match": validRegexp,
- "regexp.MatchReader": validRegexp,
- "regexp.MatchString": validRegexp,
- }
-
- checkTimeParseRules = map[string]CallCheck{
- "time.Parse": func(call *Call) {
- arg := call.Args[Arg("time.Parse.layout")]
- err := ValidateTimeLayout(arg.Value)
- if err != nil {
- arg.Invalid(err.Error())
- }
- },
- }
-
- checkEncodingBinaryRules = map[string]CallCheck{
- "encoding/binary.Write": func(call *Call) {
- arg := call.Args[Arg("encoding/binary.Write.data")]
- if !CanBinaryMarshal(call.Pass, arg.Value) {
- arg.Invalid(fmt.Sprintf("value of type %s cannot be used with binary.Write", arg.Value.Value.Type()))
- }
- },
- }
-
- checkURLsRules = map[string]CallCheck{
- "net/url.Parse": func(call *Call) {
- arg := call.Args[Arg("net/url.Parse.rawurl")]
- err := ValidateURL(arg.Value)
- if err != nil {
- arg.Invalid(err.Error())
- }
- },
- }
-
- checkSyncPoolValueRules = map[string]CallCheck{
- "(*sync.Pool).Put": func(call *Call) {
- arg := call.Args[Arg("(*sync.Pool).Put.x")]
- typ := arg.Value.Value.Type()
- if !code.IsPointerLike(typ) {
- arg.Invalid("argument should be pointer-like to avoid allocations")
- }
- },
- }
-
- checkRegexpFindAllRules = map[string]CallCheck{
- "(*regexp.Regexp).FindAll": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllIndex": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllString": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllStringIndex": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllStringSubmatch": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllStringSubmatchIndex": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllSubmatch": RepeatZeroTimes("a FindAll method", 1),
- "(*regexp.Regexp).FindAllSubmatchIndex": RepeatZeroTimes("a FindAll method", 1),
- }
-
- checkUTF8CutsetRules = map[string]CallCheck{
- "strings.IndexAny": utf8Cutset,
- "strings.LastIndexAny": utf8Cutset,
- "strings.ContainsAny": utf8Cutset,
- "strings.Trim": utf8Cutset,
- "strings.TrimLeft": utf8Cutset,
- "strings.TrimRight": utf8Cutset,
- }
-
- checkUniqueCutsetRules = map[string]CallCheck{
- "strings.Trim": uniqueCutset,
- "strings.TrimLeft": uniqueCutset,
- "strings.TrimRight": uniqueCutset,
- }
-
- checkUnmarshalPointerRules = map[string]CallCheck{
- "encoding/xml.Unmarshal": unmarshalPointer("xml.Unmarshal", 1),
- "(*encoding/xml.Decoder).Decode": unmarshalPointer("Decode", 0),
- "(*encoding/xml.Decoder).DecodeElement": unmarshalPointer("DecodeElement", 0),
- "encoding/json.Unmarshal": unmarshalPointer("json.Unmarshal", 1),
- "(*encoding/json.Decoder).Decode": unmarshalPointer("Decode", 0),
- }
-
- checkUnbufferedSignalChanRules = map[string]CallCheck{
- "os/signal.Notify": func(call *Call) {
- arg := call.Args[Arg("os/signal.Notify.c")]
- if UnbufferedChannel(arg.Value) {
- arg.Invalid("the channel used with signal.Notify should be buffered")
- }
- },
- }
-
- checkMathIntRules = map[string]CallCheck{
- "math.Ceil": pointlessIntMath,
- "math.Floor": pointlessIntMath,
- "math.IsNaN": pointlessIntMath,
- "math.Trunc": pointlessIntMath,
- "math.IsInf": pointlessIntMath,
- }
-
- checkStringsReplaceZeroRules = map[string]CallCheck{
- "strings.Replace": RepeatZeroTimes("strings.Replace", 3),
- "bytes.Replace": RepeatZeroTimes("bytes.Replace", 3),
- }
-
- checkListenAddressRules = map[string]CallCheck{
- "net/http.ListenAndServe": checkValidHostPort(0),
- "net/http.ListenAndServeTLS": checkValidHostPort(0),
- }
-
- checkBytesEqualIPRules = map[string]CallCheck{
- "bytes.Equal": func(call *Call) {
- if ConvertedFrom(call.Args[Arg("bytes.Equal.a")].Value, "net.IP") &&
- ConvertedFrom(call.Args[Arg("bytes.Equal.b")].Value, "net.IP") {
- call.Invalid("use net.IP.Equal to compare net.IPs, not bytes.Equal")
- }
- },
- }
-
- checkRegexpMatchLoopRules = map[string]CallCheck{
- "regexp.Match": loopedRegexp("regexp.Match"),
- "regexp.MatchReader": loopedRegexp("regexp.MatchReader"),
- "regexp.MatchString": loopedRegexp("regexp.MatchString"),
- }
-
- checkNoopMarshal = map[string]CallCheck{
- // TODO(dh): should we really flag XML? Even an empty struct
- // produces a non-zero amount of data, namely its type name.
- // Let's see if we encounter any false positives.
- //
- // Also, should we flag gob?
- "encoding/json.Marshal": checkNoopMarshalImpl(Arg("json.Marshal.v"), "MarshalJSON", "MarshalText"),
- "encoding/xml.Marshal": checkNoopMarshalImpl(Arg("xml.Marshal.v"), "MarshalXML", "MarshalText"),
- "(*encoding/json.Encoder).Encode": checkNoopMarshalImpl(Arg("(*encoding/json.Encoder).Encode.v"), "MarshalJSON", "MarshalText"),
- "(*encoding/xml.Encoder).Encode": checkNoopMarshalImpl(Arg("(*encoding/xml.Encoder).Encode.v"), "MarshalXML", "MarshalText"),
-
- "encoding/json.Unmarshal": checkNoopMarshalImpl(Arg("json.Unmarshal.v"), "UnmarshalJSON", "UnmarshalText"),
- "encoding/xml.Unmarshal": checkNoopMarshalImpl(Arg("xml.Unmarshal.v"), "UnmarshalXML", "UnmarshalText"),
- "(*encoding/json.Decoder).Decode": checkNoopMarshalImpl(Arg("(*encoding/json.Decoder).Decode.v"), "UnmarshalJSON", "UnmarshalText"),
- "(*encoding/xml.Decoder).Decode": checkNoopMarshalImpl(Arg("(*encoding/xml.Decoder).Decode.v"), "UnmarshalXML", "UnmarshalText"),
- }
-
- checkUnsupportedMarshal = map[string]CallCheck{
- "encoding/json.Marshal": checkUnsupportedMarshalImpl(Arg("json.Marshal.v"), "json", "MarshalJSON", "MarshalText"),
- "encoding/xml.Marshal": checkUnsupportedMarshalImpl(Arg("xml.Marshal.v"), "xml", "MarshalXML", "MarshalText"),
- "(*encoding/json.Encoder).Encode": checkUnsupportedMarshalImpl(Arg("(*encoding/json.Encoder).Encode.v"), "json", "MarshalJSON", "MarshalText"),
- "(*encoding/xml.Encoder).Encode": checkUnsupportedMarshalImpl(Arg("(*encoding/xml.Encoder).Encode.v"), "xml", "MarshalXML", "MarshalText"),
- }
-
- checkAtomicAlignment = map[string]CallCheck{
- "sync/atomic.AddInt64": checkAtomicAlignmentImpl,
- "sync/atomic.AddUint64": checkAtomicAlignmentImpl,
- "sync/atomic.CompareAndSwapInt64": checkAtomicAlignmentImpl,
- "sync/atomic.CompareAndSwapUint64": checkAtomicAlignmentImpl,
- "sync/atomic.LoadInt64": checkAtomicAlignmentImpl,
- "sync/atomic.LoadUint64": checkAtomicAlignmentImpl,
- "sync/atomic.StoreInt64": checkAtomicAlignmentImpl,
- "sync/atomic.StoreUint64": checkAtomicAlignmentImpl,
- "sync/atomic.SwapInt64": checkAtomicAlignmentImpl,
- "sync/atomic.SwapUint64": checkAtomicAlignmentImpl,
- }
-
- // TODO(dh): detect printf wrappers
- checkPrintfRules = map[string]CallCheck{
- "fmt.Errorf": func(call *Call) { checkPrintfCall(call, 0, 1) },
- "fmt.Printf": func(call *Call) { checkPrintfCall(call, 0, 1) },
- "fmt.Sprintf": func(call *Call) { checkPrintfCall(call, 0, 1) },
- "fmt.Fprintf": func(call *Call) { checkPrintfCall(call, 1, 2) },
- "golang.org/x/xerrors.Errorf": func(call *Call) { checkPrintfCall(call, 0, 1) },
- }
-
- checkSortSliceRules = map[string]CallCheck{
- "sort.Slice": checkSortSlice,
- "sort.SliceIsSorted": checkSortSlice,
- "sort.SliceStable": checkSortSlice,
- }
-
- checkWithValueKeyRules = map[string]CallCheck{
- "context.WithValue": checkWithValueKey,
- }
-)
-
-func checkPrintfCall(call *Call, fIdx, vIdx int) {
- f := call.Args[fIdx]
- var args []ir.Value
- switch v := call.Args[vIdx].Value.Value.(type) {
- case *ir.Slice:
- var ok bool
- args, ok = irutil.Vararg(v)
- if !ok {
- // We don't know what the actual arguments to the function are
- return
- }
- case *ir.Const:
- // nil, i.e. no arguments
- default:
- // We don't know what the actual arguments to the function are
- return
- }
- checkPrintfCallImpl(f, f.Value.Value, args)
-}
-
-type verbFlag int
-
-const (
- isInt verbFlag = 1 << iota
- isBool
- isFP
- isString
- isPointer
- // Verbs that accept "pseudo pointers" will sometimes dereference
- // non-nil pointers. For example, %x on a non-nil *struct will print the
- // individual fields, but on a nil pointer it will print the address.
- isPseudoPointer
- isSlice
- isAny
- noRecurse
-)
-
-var verbs = [...]verbFlag{
- 'b': isPseudoPointer | isInt | isFP,
- 'c': isInt,
- 'd': isPseudoPointer | isInt,
- 'e': isFP,
- 'E': isFP,
- 'f': isFP,
- 'F': isFP,
- 'g': isFP,
- 'G': isFP,
- 'o': isPseudoPointer | isInt,
- 'O': isPseudoPointer | isInt,
- 'p': isSlice | isPointer | noRecurse,
- 'q': isInt | isString,
- 's': isString,
- 't': isBool,
- 'T': isAny,
- 'U': isInt,
- 'v': isAny,
- 'X': isPseudoPointer | isInt | isFP | isString,
- 'x': isPseudoPointer | isInt | isFP | isString,
-}
-
-func checkPrintfCallImpl(carg *Argument, f ir.Value, args []ir.Value) {
- var msCache *typeutil.MethodSetCache
- if f.Parent() != nil {
- msCache = &f.Parent().Prog.MethodSets
- }
-
- elem := func(T types.Type, verb rune) ([]types.Type, bool) {
- if verbs[verb]&noRecurse != 0 {
- return []types.Type{T}, false
- }
- switch T := T.(type) {
- case *types.Slice:
- if verbs[verb]&isSlice != 0 {
- return []types.Type{T}, false
- }
- if verbs[verb]&isString != 0 && code.IsType(T.Elem().Underlying(), "byte") {
- return []types.Type{T}, false
- }
- return []types.Type{T.Elem()}, true
- case *types.Map:
- key := T.Key()
- val := T.Elem()
- return []types.Type{key, val}, true
- case *types.Struct:
- out := make([]types.Type, 0, T.NumFields())
- for i := 0; i < T.NumFields(); i++ {
- out = append(out, T.Field(i).Type())
- }
- return out, true
- case *types.Array:
- return []types.Type{T.Elem()}, true
- default:
- return []types.Type{T}, false
- }
- }
- isInfo := func(T types.Type, info types.BasicInfo) bool {
- basic, ok := T.Underlying().(*types.Basic)
- return ok && basic.Info()&info != 0
- }
-
- isStringer := func(T types.Type, ms *types.MethodSet) bool {
- sel := ms.Lookup(nil, "String")
- if sel == nil {
- return false
- }
- fn, ok := sel.Obj().(*types.Func)
- if !ok {
- // should be unreachable
- return false
- }
- sig := fn.Type().(*types.Signature)
- if sig.Params().Len() != 0 {
- return false
- }
- if sig.Results().Len() != 1 {
- return false
- }
- if !code.IsType(sig.Results().At(0).Type(), "string") {
- return false
- }
- return true
- }
- isError := func(T types.Type, ms *types.MethodSet) bool {
- sel := ms.Lookup(nil, "Error")
- if sel == nil {
- return false
- }
- fn, ok := sel.Obj().(*types.Func)
- if !ok {
- // should be unreachable
- return false
- }
- sig := fn.Type().(*types.Signature)
- if sig.Params().Len() != 0 {
- return false
- }
- if sig.Results().Len() != 1 {
- return false
- }
- if !code.IsType(sig.Results().At(0).Type(), "string") {
- return false
- }
- return true
- }
-
- isFormatter := func(T types.Type, ms *types.MethodSet) bool {
- sel := ms.Lookup(nil, "Format")
- if sel == nil {
- return false
- }
- fn, ok := sel.Obj().(*types.Func)
- if !ok {
- // should be unreachable
- return false
- }
- sig := fn.Type().(*types.Signature)
- if sig.Params().Len() != 2 {
- return false
- }
- // TODO(dh): check the types of the arguments for more
- // precision
- if sig.Results().Len() != 0 {
- return false
- }
- return true
- }
-
- seen := map[types.Type]bool{}
- var checkType func(verb rune, T types.Type, top bool) bool
- checkType = func(verb rune, T types.Type, top bool) bool {
- if top {
- for k := range seen {
- delete(seen, k)
- }
- }
- if seen[T] {
- return true
- }
- seen[T] = true
- if int(verb) >= len(verbs) {
- // Unknown verb
- return true
- }
-
- flags := verbs[verb]
- if flags == 0 {
- // Unknown verb
- return true
- }
-
- ms := msCache.MethodSet(T)
- if isFormatter(T, ms) {
- // the value is responsible for formatting itself
- return true
- }
-
- if flags&isString != 0 && (isStringer(T, ms) || isError(T, ms)) {
- // Check for stringer early because we're about to dereference
- return true
- }
-
- T = T.Underlying()
- if flags&(isPointer|isPseudoPointer) == 0 && top {
- T = code.Dereference(T)
- }
- if flags&isPseudoPointer != 0 && top {
- t := code.Dereference(T)
- if _, ok := t.Underlying().(*types.Struct); ok {
- T = t
- }
- }
-
- if _, ok := T.(*types.Interface); ok {
- // We don't know what's in the interface
- return true
- }
-
- var info types.BasicInfo
- if flags&isInt != 0 {
- info |= types.IsInteger
- }
- if flags&isBool != 0 {
- info |= types.IsBoolean
- }
- if flags&isFP != 0 {
- info |= types.IsFloat | types.IsComplex
- }
- if flags&isString != 0 {
- info |= types.IsString
- }
-
- if info != 0 && isInfo(T, info) {
- return true
- }
-
- if flags&isString != 0 && (code.IsType(T, "[]byte") || isStringer(T, ms) || isError(T, ms)) {
- return true
- }
-
- if flags&isPointer != 0 && code.IsPointerLike(T) {
- return true
- }
- if flags&isPseudoPointer != 0 {
- switch U := T.Underlying().(type) {
- case *types.Pointer:
- if !top {
- return true
- }
-
- if _, ok := U.Elem().Underlying().(*types.Struct); !ok {
- // TODO(dh): can this condition ever be false? For
- // *T, if T is a struct, we'll already have
- // dereferenced it, meaning the *types.Pointer
- // branch couldn't have been taken. For T that
- // aren't structs, this condition will always
- // evaluate to true.
- return true
- }
- case *types.Chan, *types.Signature:
- // Channels and functions are always treated as
- // pointers and never recursed into.
- return true
- case *types.Basic:
- if U.Kind() == types.UnsafePointer {
- return true
- }
- case *types.Interface:
- // we will already have bailed if the type is an
- // interface.
- panic("unreachable")
- default:
- // other pointer-like types, such as maps or slices,
- // will be printed element-wise.
- }
- }
-
- if flags&isSlice != 0 {
- if _, ok := T.(*types.Slice); ok {
- return true
- }
- }
-
- if flags&isAny != 0 {
- return true
- }
-
- elems, ok := elem(T.Underlying(), verb)
- if !ok {
- return false
- }
- for _, elem := range elems {
- if !checkType(verb, elem, false) {
- return false
- }
- }
-
- return true
- }
-
- k, ok := f.(*ir.Const)
- if !ok {
- return
- }
- actions, err := printf.Parse(constant.StringVal(k.Value))
- if err != nil {
- carg.Invalid("couldn't parse format string")
- return
- }
-
- ptr := 1
- hasExplicit := false
-
- checkStar := func(verb printf.Verb, star printf.Argument) bool {
- if star, ok := star.(printf.Star); ok {
- idx := 0
- if star.Index == -1 {
- idx = ptr
- ptr++
- } else {
- hasExplicit = true
- idx = star.Index
- ptr = star.Index + 1
- }
- if idx == 0 {
- carg.Invalid(fmt.Sprintf("Printf format %s reads invalid arg 0; indices are 1-based", verb.Raw))
- return false
- }
- if idx > len(args) {
- carg.Invalid(
- fmt.Sprintf("Printf format %s reads arg #%d, but call has only %d args",
- verb.Raw, idx, len(args)))
- return false
- }
- if arg, ok := args[idx-1].(*ir.MakeInterface); ok {
- if !isInfo(arg.X.Type(), types.IsInteger) {
- carg.Invalid(fmt.Sprintf("Printf format %s reads non-int arg #%d as argument of *", verb.Raw, idx))
- }
- }
- }
- return true
- }
-
- // We only report one problem per format string. Making a
- // mistake with an index tends to invalidate all future
- // implicit indices.
- for _, action := range actions {
- verb, ok := action.(printf.Verb)
- if !ok {
- continue
- }
-
- if !checkStar(verb, verb.Width) || !checkStar(verb, verb.Precision) {
- return
- }
-
- off := ptr
- if verb.Value != -1 {
- hasExplicit = true
- off = verb.Value
- }
- if off > len(args) {
- carg.Invalid(
- fmt.Sprintf("Printf format %s reads arg #%d, but call has only %d args",
- verb.Raw, off, len(args)))
- return
- } else if verb.Value == 0 && verb.Letter != '%' {
- carg.Invalid(fmt.Sprintf("Printf format %s reads invalid arg 0; indices are 1-based", verb.Raw))
- return
- } else if off != 0 {
- arg, ok := args[off-1].(*ir.MakeInterface)
- if ok {
- if !checkType(verb.Letter, arg.X.Type(), true) {
- carg.Invalid(fmt.Sprintf("Printf format %s has arg #%d of wrong type %s",
- verb.Raw, ptr, args[ptr-1].(*ir.MakeInterface).X.Type()))
- return
- }
- }
- }
-
- switch verb.Value {
- case -1:
- // Consume next argument
- ptr++
- case 0:
- // Don't consume any arguments
- default:
- ptr = verb.Value + 1
- }
- }
-
- if !hasExplicit && ptr <= len(args) {
- carg.Invalid(fmt.Sprintf("Printf call needs %d args but has %d args", ptr-1, len(args)))
- }
-}
-
-func checkAtomicAlignmentImpl(call *Call) {
- sizes := call.Pass.TypesSizes
- if sizes.Sizeof(types.Typ[types.Uintptr]) != 4 {
- // Not running on a 32-bit platform
- return
- }
- v, ok := call.Args[0].Value.Value.(*ir.FieldAddr)
- if !ok {
- // TODO(dh): also check indexing into arrays and slices
- return
- }
- T := v.X.Type().Underlying().(*types.Pointer).Elem().Underlying().(*types.Struct)
- fields := make([]*types.Var, 0, T.NumFields())
- for i := 0; i < T.NumFields() && i <= v.Field; i++ {
- fields = append(fields, T.Field(i))
- }
-
- off := sizes.Offsetsof(fields)[v.Field]
- if off%8 != 0 {
- msg := fmt.Sprintf("address of non 64-bit aligned field %s passed to %s",
- T.Field(v.Field).Name(),
- code.CallName(call.Instr.Common()))
- call.Invalid(msg)
- }
-}
-
-func checkNoopMarshalImpl(argN int, meths ...string) CallCheck {
- return func(call *Call) {
- if code.IsGenerated(call.Pass, call.Instr.Pos()) {
- return
- }
- arg := call.Args[argN]
- T := arg.Value.Value.Type()
- Ts, ok := code.Dereference(T).Underlying().(*types.Struct)
- if !ok {
- return
- }
- if Ts.NumFields() == 0 {
- return
- }
- fields := code.FlattenFields(Ts)
- for _, field := range fields {
- if field.Var.Exported() {
- return
- }
- }
- // OPT(dh): we could use a method set cache here
- ms := call.Instr.Parent().Prog.MethodSets.MethodSet(T)
- // TODO(dh): we're not checking the signature, which can cause false negatives.
- // This isn't a huge problem, however, since vet complains about incorrect signatures.
- for _, meth := range meths {
- if ms.Lookup(nil, meth) != nil {
- return
- }
- }
- arg.Invalid("struct doesn't have any exported fields, nor custom marshaling")
- }
-}
-
-func checkUnsupportedMarshalImpl(argN int, tag string, meths ...string) CallCheck {
- // TODO(dh): flag slices and maps of unsupported types
- return func(call *Call) {
- msCache := &call.Instr.Parent().Prog.MethodSets
-
- arg := call.Args[argN]
- T := arg.Value.Value.Type()
- Ts, ok := code.Dereference(T).Underlying().(*types.Struct)
- if !ok {
- return
- }
- ms := msCache.MethodSet(T)
- // TODO(dh): we're not checking the signature, which can cause false negatives.
- // This isn't a huge problem, however, since vet complains about incorrect signatures.
- for _, meth := range meths {
- if ms.Lookup(nil, meth) != nil {
- return
- }
- }
- fields := code.FlattenFields(Ts)
- for _, field := range fields {
- if !(field.Var.Exported()) {
- continue
- }
- if reflect.StructTag(field.Tag).Get(tag) == "-" {
- continue
- }
- ms := msCache.MethodSet(field.Var.Type())
- // TODO(dh): we're not checking the signature, which can cause false negatives.
- // This isn't a huge problem, however, since vet complains about incorrect signatures.
- for _, meth := range meths {
- if ms.Lookup(nil, meth) != nil {
- return
- }
- }
- switch field.Var.Type().Underlying().(type) {
- case *types.Chan, *types.Signature:
- arg.Invalid(fmt.Sprintf("trying to marshal chan or func value, field %s", fieldPath(T, field.Path)))
- }
- }
- }
-}
-
-func fieldPath(start types.Type, indices []int) string {
- p := start.String()
- for _, idx := range indices {
- field := code.Dereference(start).Underlying().(*types.Struct).Field(idx)
- start = field.Type()
- p += "." + field.Name()
- }
- return p
-}
-
-func isInLoop(b *ir.BasicBlock) bool {
- sets := functions.FindLoops(b.Parent())
- for _, set := range sets {
- if set.Has(b) {
- return true
- }
- }
- return false
-}
-
-func CheckUntrappableSignal(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- if !code.IsCallToAnyAST(pass, call,
- "os/signal.Ignore", "os/signal.Notify", "os/signal.Reset") {
- return
- }
-
- hasSigterm := false
- for _, arg := range call.Args {
- if conv, ok := arg.(*ast.CallExpr); ok && isName(pass, conv.Fun, "os.Signal") {
- arg = conv.Args[0]
- }
-
- if isName(pass, arg, "syscall.SIGTERM") {
- hasSigterm = true
- break
- }
-
- }
- for i, arg := range call.Args {
- if conv, ok := arg.(*ast.CallExpr); ok && isName(pass, conv.Fun, "os.Signal") {
- arg = conv.Args[0]
- }
-
- if isName(pass, arg, "os.Kill") || isName(pass, arg, "syscall.SIGKILL") {
- var fixes []analysis.SuggestedFix
- if !hasSigterm {
- nargs := make([]ast.Expr, len(call.Args))
- for j, a := range call.Args {
- if i == j {
- nargs[j] = Selector("syscall", "SIGTERM")
- } else {
- nargs[j] = a
- }
- }
- ncall := *call
- ncall.Args = nargs
- fixes = append(fixes, edit.Fix(fmt.Sprintf("use syscall.SIGTERM instead of %s", report.Render(pass, arg)), edit.ReplaceWithNode(pass.Fset, call, &ncall)))
- }
- nargs := make([]ast.Expr, 0, len(call.Args))
- for j, a := range call.Args {
- if i == j {
- continue
- }
- nargs = append(nargs, a)
- }
- ncall := *call
- ncall.Args = nargs
- fixes = append(fixes, edit.Fix(fmt.Sprintf("remove %s from list of arguments", report.Render(pass, arg)), edit.ReplaceWithNode(pass.Fset, call, &ncall)))
- report.Report(pass, arg, fmt.Sprintf("%s cannot be trapped (did you mean syscall.SIGTERM?)", report.Render(pass, arg)), report.Fixes(fixes...))
- }
- if isName(pass, arg, "syscall.SIGSTOP") {
- nargs := make([]ast.Expr, 0, len(call.Args)-1)
- for j, a := range call.Args {
- if i == j {
- continue
- }
- nargs = append(nargs, a)
- }
- ncall := *call
- ncall.Args = nargs
- report.Report(pass, arg, "syscall.SIGSTOP cannot be trapped", report.Fixes(edit.Fix("remove syscall.SIGSTOP from list of arguments", edit.ReplaceWithNode(pass.Fset, call, &ncall))))
- }
- }
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckTemplate(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- var kind string
- switch code.CallNameAST(pass, call) {
- case "(*text/template.Template).Parse":
- kind = "text"
- case "(*html/template.Template).Parse":
- kind = "html"
- default:
- return
- }
- sel := call.Fun.(*ast.SelectorExpr)
- if !code.IsCallToAnyAST(pass, sel.X, "text/template.New", "html/template.New") {
- // TODO(dh): this is a cheap workaround for templates with
- // different delims. A better solution with less false
- // negatives would use data flow analysis to see where the
- // template comes from and where it has been
- return
- }
- s, ok := code.ExprToString(pass, call.Args[Arg("(*text/template.Template).Parse.text")])
- if !ok {
- return
- }
- var err error
- switch kind {
- case "text":
- _, err = texttemplate.New("").Parse(s)
- case "html":
- _, err = htmltemplate.New("").Parse(s)
- }
- if err != nil {
- // TODO(dominikh): whitelist other parse errors, if any
- if strings.Contains(err.Error(), "unexpected") {
- report.Report(pass, call.Args[Arg("(*text/template.Template).Parse.text")], err.Error())
- }
- }
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-var (
- checkTimeSleepConstantPatternRns = pattern.MustParse(`(BinaryExpr duration "*" (SelectorExpr (Ident "time") (Ident "Nanosecond")))`)
- checkTimeSleepConstantPatternRs = pattern.MustParse(`(BinaryExpr duration "*" (SelectorExpr (Ident "time") (Ident "Second")))`)
-)
-
-func CheckTimeSleepConstant(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- if !code.IsCallToAST(pass, call, "time.Sleep") {
- return
- }
- lit, ok := call.Args[Arg("time.Sleep.d")].(*ast.BasicLit)
- if !ok {
- return
- }
- n, err := strconv.Atoi(lit.Value)
- if err != nil {
- return
- }
- if n == 0 || n > 120 {
- // time.Sleep(0) is a seldom used pattern in concurrency
- // tests. >120 might be intentional. 120 was chosen
- // because the user could've meant 2 minutes.
- return
- }
-
- report.Report(pass, lit,
- fmt.Sprintf("sleeping for %d nanoseconds is probably a bug; be explicit if it isn't", n), report.Fixes(
- edit.Fix("explicitly use nanoseconds", edit.ReplaceWithPattern(pass, checkTimeSleepConstantPatternRns, pattern.State{"duration": lit}, lit)),
- edit.Fix("use seconds", edit.ReplaceWithPattern(pass, checkTimeSleepConstantPatternRs, pattern.State{"duration": lit}, lit))))
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-var checkWaitgroupAddQ = pattern.MustParse(`
- (GoStmt
- (CallExpr
- (FuncLit
- _
- call@(CallExpr (Function "(*sync.WaitGroup).Add") _):_) _))`)
-
-func CheckWaitgroupAdd(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- if m, ok := Match(pass, checkWaitgroupAddQ, node); ok {
- call := m.State["call"].(ast.Node)
- report.Report(pass, call, fmt.Sprintf("should call %s before starting the goroutine to avoid a race", report.Render(pass, call)))
- }
- }
- code.Preorder(pass, fn, (*ast.GoStmt)(nil))
- return nil, nil
-}
-
-func CheckInfiniteEmptyLoop(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- loop := node.(*ast.ForStmt)
- if len(loop.Body.List) != 0 || loop.Post != nil {
- return
- }
-
- if loop.Init != nil {
- // TODO(dh): this isn't strictly necessary, it just makes
- // the check easier.
- return
- }
- // An empty loop is bad news in two cases: 1) The loop has no
- // condition. In that case, it's just a loop that spins
- // forever and as fast as it can, keeping a core busy. 2) The
- // loop condition only consists of variable or field reads and
- // operators on those. The only way those could change their
- // value is with unsynchronised access, which constitutes a
- // data race.
- //
- // If the condition contains any function calls, its behaviour
- // is dynamic and the loop might terminate. Similarly for
- // channel receives.
-
- if loop.Cond != nil {
- if code.MayHaveSideEffects(pass, loop.Cond, nil) {
- return
- }
- if ident, ok := loop.Cond.(*ast.Ident); ok {
- if k, ok := pass.TypesInfo.ObjectOf(ident).(*types.Const); ok {
- if !constant.BoolVal(k.Val()) {
- // don't flag `for false {}` loops. They're a debug aid.
- return
- }
- }
- }
- report.Report(pass, loop, "loop condition never changes or has a race condition")
- }
- report.Report(pass, loop, "this loop will spin, using 100%% CPU", report.ShortRange())
- }
- code.Preorder(pass, fn, (*ast.ForStmt)(nil))
- return nil, nil
-}
-
-func CheckDeferInInfiniteLoop(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- mightExit := false
- var defers []ast.Stmt
- loop := node.(*ast.ForStmt)
- if loop.Cond != nil {
- return
- }
- fn2 := func(node ast.Node) bool {
- switch stmt := node.(type) {
- case *ast.ReturnStmt:
- mightExit = true
- return false
- case *ast.BranchStmt:
- // TODO(dominikh): if this sees a break in a switch or
- // select, it doesn't check if it breaks the loop or
- // just the select/switch. This causes some false
- // negatives.
- if stmt.Tok == token.BREAK {
- mightExit = true
- return false
- }
- case *ast.DeferStmt:
- defers = append(defers, stmt)
- case *ast.FuncLit:
- // Don't look into function bodies
- return false
- }
- return true
- }
- ast.Inspect(loop.Body, fn2)
- if mightExit {
- return
- }
- for _, stmt := range defers {
- report.Report(pass, stmt, "defers in this infinite loop will never run")
- }
- }
- code.Preorder(pass, fn, (*ast.ForStmt)(nil))
- return nil, nil
-}
-
-func CheckDubiousDeferInChannelRangeLoop(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- loop := node.(*ast.RangeStmt)
- typ := pass.TypesInfo.TypeOf(loop.X)
- _, ok := typ.Underlying().(*types.Chan)
- if !ok {
- return
- }
- fn2 := func(node ast.Node) bool {
- switch stmt := node.(type) {
- case *ast.DeferStmt:
- report.Report(pass, stmt, "defers in this range loop won't run unless the channel gets closed")
- case *ast.FuncLit:
- // Don't look into function bodies
- return false
- }
- return true
- }
- ast.Inspect(loop.Body, fn2)
- }
- code.Preorder(pass, fn, (*ast.RangeStmt)(nil))
- return nil, nil
-}
-
-func CheckTestMainExit(pass *analysis.Pass) (interface{}, error) {
- var (
- fnmain ast.Node
- callsExit bool
- callsRun bool
- arg types.Object
- )
- fn := func(node ast.Node, push bool) bool {
- if !push {
- if fnmain != nil && node == fnmain {
- if !callsExit && callsRun {
- report.Report(pass, fnmain, "TestMain should call os.Exit to set exit code")
- }
- fnmain = nil
- callsExit = false
- callsRun = false
- arg = nil
- }
- return true
- }
-
- switch node := node.(type) {
- case *ast.FuncDecl:
- if fnmain != nil {
- return true
- }
- if !isTestMain(pass, node) {
- return false
- }
- fnmain = node
- arg = pass.TypesInfo.ObjectOf(node.Type.Params.List[0].Names[0])
- return true
- case *ast.CallExpr:
- if code.IsCallToAST(pass, node, "os.Exit") {
- callsExit = true
- return false
- }
- sel, ok := node.Fun.(*ast.SelectorExpr)
- if !ok {
- return true
- }
- ident, ok := sel.X.(*ast.Ident)
- if !ok {
- return true
- }
- if arg != pass.TypesInfo.ObjectOf(ident) {
- return true
- }
- if sel.Sel.Name == "Run" {
- callsRun = true
- return false
- }
- return true
- default:
- ExhaustiveTypeSwitch(node)
- return true
- }
- }
- pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.FuncDecl)(nil), (*ast.CallExpr)(nil)}, fn)
- return nil, nil
-}
-
-func isTestMain(pass *analysis.Pass, decl *ast.FuncDecl) bool {
- if decl.Name.Name != "TestMain" {
- return false
- }
- if len(decl.Type.Params.List) != 1 {
- return false
- }
- arg := decl.Type.Params.List[0]
- if len(arg.Names) != 1 {
- return false
- }
- return code.IsOfType(pass, arg.Type, "*testing.M")
-}
-
-func CheckExec(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- if !code.IsCallToAST(pass, call, "os/exec.Command") {
- return
- }
- val, ok := code.ExprToString(pass, call.Args[Arg("os/exec.Command.name")])
- if !ok {
- return
- }
- if !strings.Contains(val, " ") || strings.Contains(val, `\`) || strings.Contains(val, "/") {
- return
- }
- report.Report(pass, call.Args[Arg("os/exec.Command.name")],
- "first argument to exec.Command looks like a shell command, but a program name or path are expected")
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckLoopEmptyDefault(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- loop := node.(*ast.ForStmt)
- if len(loop.Body.List) != 1 || loop.Cond != nil || loop.Init != nil {
- return
- }
- sel, ok := loop.Body.List[0].(*ast.SelectStmt)
- if !ok {
- return
- }
- for _, c := range sel.Body.List {
- // FIXME this leaves behind an empty line, and possibly
- // comments in the default branch. We can't easily fix
- // either.
- if comm, ok := c.(*ast.CommClause); ok && comm.Comm == nil && len(comm.Body) == 0 {
- report.Report(pass, comm, "should not have an empty default case in a for+select loop; the loop will spin",
- report.Fixes(edit.Fix("remove empty default branch", edit.Delete(comm))))
- // there can only be one default case
- break
- }
- }
- }
- code.Preorder(pass, fn, (*ast.ForStmt)(nil))
- return nil, nil
-}
-
-func CheckLhsRhsIdentical(pass *analysis.Pass) (interface{}, error) {
- var isFloat func(T types.Type) bool
- isFloat = func(T types.Type) bool {
- switch T := T.Underlying().(type) {
- case *types.Basic:
- kind := T.Kind()
- return kind == types.Float32 || kind == types.Float64
- case *types.Array:
- return isFloat(T.Elem())
- case *types.Struct:
- for i := 0; i < T.NumFields(); i++ {
- if !isFloat(T.Field(i).Type()) {
- return false
- }
- }
- return true
- default:
- return false
- }
- }
-
- // TODO(dh): this check ignores the existence of side-effects and
- // happily flags fn() == fn() – so far, we've had nobody complain
- // about a false positive, and it's caught several bugs in real
- // code.
- fn := func(node ast.Node) {
- op := node.(*ast.BinaryExpr)
- switch op.Op {
- case token.EQL, token.NEQ:
- if isFloat(pass.TypesInfo.TypeOf(op.X)) {
- // f == f and f != f might be used to check for NaN
- return
- }
- case token.SUB, token.QUO, token.AND, token.REM, token.OR, token.XOR, token.AND_NOT,
- token.LAND, token.LOR, token.LSS, token.GTR, token.LEQ, token.GEQ:
- default:
- // For some ops, such as + and *, it can make sense to
- // have identical operands
- return
- }
-
- if reflect.TypeOf(op.X) != reflect.TypeOf(op.Y) {
- return
- }
- if report.Render(pass, op.X) != report.Render(pass, op.Y) {
- return
- }
- l1, ok1 := op.X.(*ast.BasicLit)
- l2, ok2 := op.Y.(*ast.BasicLit)
- if ok1 && ok2 && l1.Kind == token.INT && l2.Kind == l1.Kind && l1.Value == "0" && l2.Value == l1.Value && code.IsGenerated(pass, l1.Pos()) {
- // cgo generates the following function call:
- // _cgoCheckPointer(_cgoBase0, 0 == 0) – it uses 0 == 0
- // instead of true in case the user shadowed the
- // identifier. Ideally we'd restrict this exception to
- // calls of _cgoCheckPointer, but it's not worth the
- // hassle of keeping track of the stack. <lit> <op> <lit>
- // are very rare to begin with, and we're mostly checking
- // for them to catch typos such as 1 == 1 where the user
- // meant to type i == 1. The odds of a false negative for
- // 0 == 0 are slim.
- return
- }
- report.Report(pass, op, fmt.Sprintf("identical expressions on the left and right side of the '%s' operator", op.Op))
- }
- code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
- return nil, nil
-}
-
-func CheckScopedBreak(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- var body *ast.BlockStmt
- switch node := node.(type) {
- case *ast.ForStmt:
- body = node.Body
- case *ast.RangeStmt:
- body = node.Body
- default:
- ExhaustiveTypeSwitch(node)
- }
- for _, stmt := range body.List {
- var blocks [][]ast.Stmt
- switch stmt := stmt.(type) {
- case *ast.SwitchStmt:
- for _, c := range stmt.Body.List {
- blocks = append(blocks, c.(*ast.CaseClause).Body)
- }
- case *ast.SelectStmt:
- for _, c := range stmt.Body.List {
- blocks = append(blocks, c.(*ast.CommClause).Body)
- }
- default:
- continue
- }
-
- for _, body := range blocks {
- if len(body) == 0 {
- continue
- }
- lasts := []ast.Stmt{body[len(body)-1]}
- // TODO(dh): unfold all levels of nested block
- // statements, not just a single level if statement
- if ifs, ok := lasts[0].(*ast.IfStmt); ok {
- if len(ifs.Body.List) == 0 {
- continue
- }
- lasts[0] = ifs.Body.List[len(ifs.Body.List)-1]
-
- if block, ok := ifs.Else.(*ast.BlockStmt); ok {
- if len(block.List) != 0 {
- lasts = append(lasts, block.List[len(block.List)-1])
- }
- }
- }
- for _, last := range lasts {
- branch, ok := last.(*ast.BranchStmt)
- if !ok || branch.Tok != token.BREAK || branch.Label != nil {
- continue
- }
- report.Report(pass, branch, "ineffective break statement. Did you mean to break out of the outer loop?")
- }
- }
- }
- }
- code.Preorder(pass, fn, (*ast.ForStmt)(nil), (*ast.RangeStmt)(nil))
- return nil, nil
-}
-
-func CheckUnsafePrintf(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- name := code.CallNameAST(pass, call)
- var arg int
-
- switch name {
- case "fmt.Printf", "fmt.Sprintf", "log.Printf":
- arg = Arg("fmt.Printf.format")
- case "fmt.Fprintf":
- arg = Arg("fmt.Fprintf.format")
- default:
- return
- }
- if len(call.Args) != arg+1 {
- return
- }
- switch call.Args[arg].(type) {
- case *ast.CallExpr, *ast.Ident:
- default:
- return
- }
-
- alt := name[:len(name)-1]
- report.Report(pass, call,
- "printf-style function with dynamic format string and no further arguments should use print-style function instead",
- report.Fixes(edit.Fix(fmt.Sprintf("use %s instead of %s", alt, name), edit.ReplaceWithString(pass.Fset, call.Fun, alt))))
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckEarlyDefer(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- block := node.(*ast.BlockStmt)
- if len(block.List) < 2 {
- return
- }
- for i, stmt := range block.List {
- if i == len(block.List)-1 {
- break
- }
- assign, ok := stmt.(*ast.AssignStmt)
- if !ok {
- continue
- }
- if len(assign.Rhs) != 1 {
- continue
- }
- if len(assign.Lhs) < 2 {
- continue
- }
- if lhs, ok := assign.Lhs[len(assign.Lhs)-1].(*ast.Ident); ok && lhs.Name == "_" {
- continue
- }
- call, ok := assign.Rhs[0].(*ast.CallExpr)
- if !ok {
- continue
- }
- sig, ok := pass.TypesInfo.TypeOf(call.Fun).(*types.Signature)
- if !ok {
- continue
- }
- if sig.Results().Len() < 2 {
- continue
- }
- last := sig.Results().At(sig.Results().Len() - 1)
- // FIXME(dh): check that it's error from universe, not
- // another type of the same name
- if last.Type().String() != "error" {
- continue
- }
- lhs, ok := assign.Lhs[0].(*ast.Ident)
- if !ok {
- continue
- }
- def, ok := block.List[i+1].(*ast.DeferStmt)
- if !ok {
- continue
- }
- sel, ok := def.Call.Fun.(*ast.SelectorExpr)
- if !ok {
- continue
- }
- ident, ok := selectorX(sel).(*ast.Ident)
- if !ok {
- continue
- }
- if ident.Obj != lhs.Obj {
- continue
- }
- if sel.Sel.Name != "Close" {
- continue
- }
- report.Report(pass, def, fmt.Sprintf("should check returned error before deferring %s", report.Render(pass, def.Call)))
- }
- }
- code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
- return nil, nil
-}
-
-func selectorX(sel *ast.SelectorExpr) ast.Node {
- switch x := sel.X.(type) {
- case *ast.SelectorExpr:
- return selectorX(x)
- default:
- return x
- }
-}
-
-func CheckEmptyCriticalSection(pass *analysis.Pass) (interface{}, error) {
- if pass.Pkg.Path() == "sync_test" {
- // exception for the sync package's tests
- return nil, nil
- }
-
- // Initially it might seem like this check would be easier to
- // implement using IR. After all, we're only checking for two
- // consecutive method calls. In reality, however, there may be any
- // number of other instructions between the lock and unlock, while
- // still constituting an empty critical section. For example,
- // given `m.x().Lock(); m.x().Unlock()`, there will be a call to
- // x(). In the AST-based approach, this has a tiny potential for a
- // false positive (the second call to x might be doing work that
- // is protected by the mutex). In an IR-based approach, however,
- // it would miss a lot of real bugs.
-
- mutexParams := func(s ast.Stmt) (x ast.Expr, funcName string, ok bool) {
- expr, ok := s.(*ast.ExprStmt)
- if !ok {
- return nil, "", false
- }
- call, ok := expr.X.(*ast.CallExpr)
- if !ok {
- return nil, "", false
- }
- sel, ok := call.Fun.(*ast.SelectorExpr)
- if !ok {
- return nil, "", false
- }
-
- fn, ok := pass.TypesInfo.ObjectOf(sel.Sel).(*types.Func)
- if !ok {
- return nil, "", false
- }
- sig := fn.Type().(*types.Signature)
- if sig.Params().Len() != 0 || sig.Results().Len() != 0 {
- return nil, "", false
- }
-
- return sel.X, fn.Name(), true
- }
-
- fn := func(node ast.Node) {
- block := node.(*ast.BlockStmt)
- if len(block.List) < 2 {
- return
- }
- for i := range block.List[:len(block.List)-1] {
- sel1, method1, ok1 := mutexParams(block.List[i])
- sel2, method2, ok2 := mutexParams(block.List[i+1])
-
- if !ok1 || !ok2 || report.Render(pass, sel1) != report.Render(pass, sel2) {
- continue
- }
- if (method1 == "Lock" && method2 == "Unlock") ||
- (method1 == "RLock" && method2 == "RUnlock") {
- report.Report(pass, block.List[i+1], "empty critical section")
- }
- }
- }
- code.Preorder(pass, fn, (*ast.BlockStmt)(nil))
- return nil, nil
-}
-
-var (
- // cgo produces code like fn(&*_Cvar_kSomeCallbacks) which we don't
- // want to flag.
- cgoIdent = regexp.MustCompile(`^_C(func|var)_.+$`)
- checkIneffectiveCopyQ1 = pattern.MustParse(`(UnaryExpr "&" (StarExpr obj))`)
- checkIneffectiveCopyQ2 = pattern.MustParse(`(StarExpr (UnaryExpr "&" _))`)
-)
-
-func CheckIneffectiveCopy(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- if m, ok := Match(pass, checkIneffectiveCopyQ1, node); ok {
- if ident, ok := m.State["obj"].(*ast.Ident); !ok || !cgoIdent.MatchString(ident.Name) {
- report.Report(pass, node, "&*x will be simplified to x. It will not copy x.")
- }
- } else if _, ok := Match(pass, checkIneffectiveCopyQ2, node); ok {
- report.Report(pass, node, "*&x will be simplified to x. It will not copy x.")
- }
- }
- code.Preorder(pass, fn, (*ast.UnaryExpr)(nil), (*ast.StarExpr)(nil))
- return nil, nil
-}
-
-func CheckCanonicalHeaderKey(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node, push bool) bool {
- if !push {
- return false
- }
- assign, ok := node.(*ast.AssignStmt)
- if ok {
- // TODO(dh): This risks missing some Header reads, for
- // example in `h1["foo"] = h2["foo"]` – these edge
- // cases are probably rare enough to ignore for now.
- for _, expr := range assign.Lhs {
- op, ok := expr.(*ast.IndexExpr)
- if !ok {
- continue
- }
- if code.IsOfType(pass, op.X, "net/http.Header") {
- return false
- }
- }
- return true
- }
- op, ok := node.(*ast.IndexExpr)
- if !ok {
- return true
- }
- if !code.IsOfType(pass, op.X, "net/http.Header") {
- return true
- }
- s, ok := code.ExprToString(pass, op.Index)
- if !ok {
- return true
- }
- canonical := http.CanonicalHeaderKey(s)
- if s == canonical {
- return true
- }
- var fix analysis.SuggestedFix
- switch op.Index.(type) {
- case *ast.BasicLit:
- fix = edit.Fix("canonicalize header key", edit.ReplaceWithString(pass.Fset, op.Index, strconv.Quote(canonical)))
- case *ast.Ident:
- call := &ast.CallExpr{
- Fun: Selector("http", "CanonicalHeaderKey"),
- Args: []ast.Expr{op.Index},
- }
- fix = edit.Fix("wrap in http.CanonicalHeaderKey", edit.ReplaceWithNode(pass.Fset, op.Index, call))
- }
- msg := fmt.Sprintf("keys in http.Header are canonicalized, %q is not canonical; fix the constant or use http.CanonicalHeaderKey", s)
- if fix.Message != "" {
- report.Report(pass, op, msg, report.Fixes(fix))
- } else {
- report.Report(pass, op, msg)
- }
- return true
- }
- pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes([]ast.Node{(*ast.AssignStmt)(nil), (*ast.IndexExpr)(nil)}, fn)
- return nil, nil
-}
-
-func CheckBenchmarkN(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- assign := node.(*ast.AssignStmt)
- if len(assign.Lhs) != 1 || len(assign.Rhs) != 1 {
- return
- }
- sel, ok := assign.Lhs[0].(*ast.SelectorExpr)
- if !ok {
- return
- }
- if sel.Sel.Name != "N" {
- return
- }
- if !code.IsOfType(pass, sel.X, "*testing.B") {
- return
- }
- report.Report(pass, assign, fmt.Sprintf("should not assign to %s", report.Render(pass, sel)))
- }
- code.Preorder(pass, fn, (*ast.AssignStmt)(nil))
- return nil, nil
-}
-
-func CheckUnreadVariableValues(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- if code.IsExample(fn) {
- continue
- }
- node := fn.Source()
- if node == nil {
- continue
- }
- if gen, ok := code.Generator(pass, node.Pos()); ok && gen == facts.Goyacc {
- // Don't flag unused values in code generated by goyacc.
- // There may be hundreds of those due to the way the state
- // machine is constructed.
- continue
- }
-
- switchTags := map[ir.Value]struct{}{}
- ast.Inspect(node, func(node ast.Node) bool {
- s, ok := node.(*ast.SwitchStmt)
- if !ok {
- return true
- }
- v, _ := fn.ValueForExpr(s.Tag)
- switchTags[v] = struct{}{}
- return true
- })
-
- // OPT(dh): don't use a map, possibly use a bitset
- var hasUse func(v ir.Value, seen map[ir.Value]struct{}) bool
- hasUse = func(v ir.Value, seen map[ir.Value]struct{}) bool {
- if _, ok := seen[v]; ok {
- return false
- }
- if _, ok := switchTags[v]; ok {
- return true
- }
- refs := v.Referrers()
- if refs == nil {
- // TODO investigate why refs can be nil
- return true
- }
- for _, ref := range *refs {
- switch ref := ref.(type) {
- case *ir.DebugRef:
- case *ir.Sigma:
- if seen == nil {
- seen = map[ir.Value]struct{}{}
- }
- seen[v] = struct{}{}
- if hasUse(ref, seen) {
- return true
- }
- case *ir.Phi:
- if seen == nil {
- seen = map[ir.Value]struct{}{}
- }
- seen[v] = struct{}{}
- if hasUse(ref, seen) {
- return true
- }
- default:
- return true
- }
- }
- return false
- }
-
- ast.Inspect(node, func(node ast.Node) bool {
- assign, ok := node.(*ast.AssignStmt)
- if !ok {
- return true
- }
- if len(assign.Lhs) > 1 && len(assign.Rhs) == 1 {
- // Either a function call with multiple return values,
- // or a comma-ok assignment
-
- val, _ := fn.ValueForExpr(assign.Rhs[0])
- if val == nil {
- return true
- }
- refs := val.Referrers()
- if refs == nil {
- return true
- }
- for _, ref := range *refs {
- ex, ok := ref.(*ir.Extract)
- if !ok {
- continue
- }
- if !hasUse(ex, nil) {
- lhs := assign.Lhs[ex.Index]
- if ident, ok := lhs.(*ast.Ident); !ok || ok && ident.Name == "_" {
- continue
- }
- report.Report(pass, assign, fmt.Sprintf("this value of %s is never used", lhs))
- }
- }
- return true
- }
- for i, lhs := range assign.Lhs {
- rhs := assign.Rhs[i]
- if ident, ok := lhs.(*ast.Ident); !ok || ok && ident.Name == "_" {
- continue
- }
- val, _ := fn.ValueForExpr(rhs)
- if val == nil {
- continue
- }
-
- if _, ok := val.(*ir.Const); ok {
- // a zero-valued constant, for example in 'foo := []string(nil)'
- continue
- }
- if !hasUse(val, nil) {
- report.Report(pass, assign, fmt.Sprintf("this value of %s is never used", lhs))
- }
- }
- return true
- })
- }
- return nil, nil
-}
-
-func CheckPredeterminedBooleanExprs(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- binop, ok := ins.(*ir.BinOp)
- if !ok {
- continue
- }
- switch binop.Op {
- case token.GTR, token.LSS, token.EQL, token.NEQ, token.LEQ, token.GEQ:
- default:
- continue
- }
-
- xs, ok1 := consts(binop.X, nil, nil)
- ys, ok2 := consts(binop.Y, nil, nil)
- if !ok1 || !ok2 || len(xs) == 0 || len(ys) == 0 {
- continue
- }
-
- trues := 0
- for _, x := range xs {
- for _, y := range ys {
- if x.Value == nil {
- if y.Value == nil {
- trues++
- }
- continue
- }
- if constant.Compare(x.Value, binop.Op, y.Value) {
- trues++
- }
- }
- }
- b := trues != 0
- if trues == 0 || trues == len(xs)*len(ys) {
- report.Report(pass, binop, fmt.Sprintf("binary expression is always %t for all possible values (%s %s %s)", b, xs, binop.Op, ys))
- }
- }
- }
- }
- return nil, nil
-}
-
-func CheckNilMaps(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- mu, ok := ins.(*ir.MapUpdate)
- if !ok {
- continue
- }
- c, ok := mu.Map.(*ir.Const)
- if !ok {
- continue
- }
- if c.Value != nil {
- continue
- }
- report.Report(pass, mu, "assignment to nil map")
- }
- }
- }
- return nil, nil
-}
-
-func CheckExtremeComparison(pass *analysis.Pass) (interface{}, error) {
- isobj := func(expr ast.Expr, name string) bool {
- sel, ok := expr.(*ast.SelectorExpr)
- if !ok {
- return false
- }
- return code.IsObject(pass.TypesInfo.ObjectOf(sel.Sel), name)
- }
-
- fn := func(node ast.Node) {
- expr := node.(*ast.BinaryExpr)
- tx := pass.TypesInfo.TypeOf(expr.X)
- basic, ok := tx.Underlying().(*types.Basic)
- if !ok {
- return
- }
-
- var max string
- var min string
-
- switch basic.Kind() {
- case types.Uint8:
- max = "math.MaxUint8"
- case types.Uint16:
- max = "math.MaxUint16"
- case types.Uint32:
- max = "math.MaxUint32"
- case types.Uint64:
- max = "math.MaxUint64"
- case types.Uint:
- max = "math.MaxUint64"
-
- case types.Int8:
- min = "math.MinInt8"
- max = "math.MaxInt8"
- case types.Int16:
- min = "math.MinInt16"
- max = "math.MaxInt16"
- case types.Int32:
- min = "math.MinInt32"
- max = "math.MaxInt32"
- case types.Int64:
- min = "math.MinInt64"
- max = "math.MaxInt64"
- case types.Int:
- min = "math.MinInt64"
- max = "math.MaxInt64"
- }
-
- if (expr.Op == token.GTR || expr.Op == token.GEQ) && isobj(expr.Y, max) ||
- (expr.Op == token.LSS || expr.Op == token.LEQ) && isobj(expr.X, max) {
- report.Report(pass, expr, fmt.Sprintf("no value of type %s is greater than %s", basic, max))
- }
- if expr.Op == token.LEQ && isobj(expr.Y, max) ||
- expr.Op == token.GEQ && isobj(expr.X, max) {
- report.Report(pass, expr, fmt.Sprintf("every value of type %s is <= %s", basic, max))
- }
-
- if (basic.Info() & types.IsUnsigned) != 0 {
- if (expr.Op == token.LSS && code.IsIntLiteral(expr.Y, "0")) ||
- (expr.Op == token.GTR && code.IsIntLiteral(expr.X, "0")) {
- report.Report(pass, expr, fmt.Sprintf("no value of type %s is less than 0", basic))
- }
- if expr.Op == token.GEQ && code.IsIntLiteral(expr.Y, "0") ||
- expr.Op == token.LEQ && code.IsIntLiteral(expr.X, "0") {
- report.Report(pass, expr, fmt.Sprintf("every value of type %s is >= 0", basic))
- }
- } else {
- if (expr.Op == token.LSS || expr.Op == token.LEQ) && isobj(expr.Y, min) ||
- (expr.Op == token.GTR || expr.Op == token.GEQ) && isobj(expr.X, min) {
- report.Report(pass, expr, fmt.Sprintf("no value of type %s is less than %s", basic, min))
- }
- if expr.Op == token.GEQ && isobj(expr.Y, min) ||
- expr.Op == token.LEQ && isobj(expr.X, min) {
- report.Report(pass, expr, fmt.Sprintf("every value of type %s is >= %s", basic, min))
- }
- }
-
- }
- code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
- return nil, nil
-}
-
-func consts(val ir.Value, out []*ir.Const, visitedPhis map[string]bool) ([]*ir.Const, bool) {
- if visitedPhis == nil {
- visitedPhis = map[string]bool{}
- }
- var ok bool
- switch val := val.(type) {
- case *ir.Phi:
- if visitedPhis[val.Name()] {
- break
- }
- visitedPhis[val.Name()] = true
- vals := val.Operands(nil)
- for _, phival := range vals {
- out, ok = consts(*phival, out, visitedPhis)
- if !ok {
- return nil, false
- }
- }
- case *ir.Const:
- out = append(out, val)
- case *ir.Convert:
- out, ok = consts(val.X, out, visitedPhis)
- if !ok {
- return nil, false
- }
- default:
- return nil, false
- }
- if len(out) < 2 {
- return out, true
- }
- uniq := []*ir.Const{out[0]}
- for _, val := range out[1:] {
- if val.Value == uniq[len(uniq)-1].Value {
- continue
- }
- uniq = append(uniq, val)
- }
- return uniq, true
-}
-
-func CheckLoopCondition(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- cb := func(node ast.Node) bool {
- loop, ok := node.(*ast.ForStmt)
- if !ok {
- return true
- }
- if loop.Init == nil || loop.Cond == nil || loop.Post == nil {
- return true
- }
- init, ok := loop.Init.(*ast.AssignStmt)
- if !ok || len(init.Lhs) != 1 || len(init.Rhs) != 1 {
- return true
- }
- cond, ok := loop.Cond.(*ast.BinaryExpr)
- if !ok {
- return true
- }
- x, ok := cond.X.(*ast.Ident)
- if !ok {
- return true
- }
- lhs, ok := init.Lhs[0].(*ast.Ident)
- if !ok {
- return true
- }
- if x.Obj != lhs.Obj {
- return true
- }
- if _, ok := loop.Post.(*ast.IncDecStmt); !ok {
- return true
- }
-
- v, isAddr := fn.ValueForExpr(cond.X)
- if v == nil || isAddr {
- return true
- }
- switch v := v.(type) {
- case *ir.Phi:
- ops := v.Operands(nil)
- if len(ops) != 2 {
- return true
- }
- _, ok := (*ops[0]).(*ir.Const)
- if !ok {
- return true
- }
- sigma, ok := (*ops[1]).(*ir.Sigma)
- if !ok {
- return true
- }
- if sigma.X != v {
- return true
- }
- case *ir.Load:
- return true
- }
- report.Report(pass, cond, "variable in loop condition never changes")
-
- return true
- }
- Inspect(fn.Source(), cb)
- }
- return nil, nil
-}
-
-func CheckArgOverwritten(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- cb := func(node ast.Node) bool {
- var typ *ast.FuncType
- var body *ast.BlockStmt
- switch fn := node.(type) {
- case *ast.FuncDecl:
- typ = fn.Type
- body = fn.Body
- case *ast.FuncLit:
- typ = fn.Type
- body = fn.Body
- }
- if body == nil {
- return true
- }
- if len(typ.Params.List) == 0 {
- return true
- }
- for _, field := range typ.Params.List {
- for _, arg := range field.Names {
- obj := pass.TypesInfo.ObjectOf(arg)
- var irobj *ir.Parameter
- for _, param := range fn.Params {
- if param.Object() == obj {
- irobj = param
- break
- }
- }
- if irobj == nil {
- continue
- }
- refs := irobj.Referrers()
- if refs == nil {
- continue
- }
- if len(code.FilterDebug(*refs)) != 0 {
- continue
- }
-
- var assignment ast.Node
- ast.Inspect(body, func(node ast.Node) bool {
- if assignment != nil {
- return false
- }
- assign, ok := node.(*ast.AssignStmt)
- if !ok {
- return true
- }
- for _, lhs := range assign.Lhs {
- ident, ok := lhs.(*ast.Ident)
- if !ok {
- continue
- }
- if pass.TypesInfo.ObjectOf(ident) == obj {
- assignment = assign
- return false
- }
- }
- return true
- })
- if assignment != nil {
- report.Report(pass, arg, fmt.Sprintf("argument %s is overwritten before first use", arg),
- report.Related(assignment, fmt.Sprintf("assignment to %s", arg)))
- }
- }
- }
- return true
- }
- Inspect(fn.Source(), cb)
- }
- return nil, nil
-}
-
-func CheckIneffectiveLoop(pass *analysis.Pass) (interface{}, error) {
- // This check detects some, but not all unconditional loop exits.
- // We give up in the following cases:
- //
- // - a goto anywhere in the loop. The goto might skip over our
- // return, and we don't check that it doesn't.
- //
- // - any nested, unlabelled continue, even if it is in another
- // loop or closure.
- fn := func(node ast.Node) {
- var body *ast.BlockStmt
- switch fn := node.(type) {
- case *ast.FuncDecl:
- body = fn.Body
- case *ast.FuncLit:
- body = fn.Body
- default:
- ExhaustiveTypeSwitch(node)
- }
- if body == nil {
- return
- }
- labels := map[*ast.Object]ast.Stmt{}
- ast.Inspect(body, func(node ast.Node) bool {
- label, ok := node.(*ast.LabeledStmt)
- if !ok {
- return true
- }
- labels[label.Label.Obj] = label.Stmt
- return true
- })
-
- ast.Inspect(body, func(node ast.Node) bool {
- var loop ast.Node
- var body *ast.BlockStmt
- switch node := node.(type) {
- case *ast.ForStmt:
- body = node.Body
- loop = node
- case *ast.RangeStmt:
- typ := pass.TypesInfo.TypeOf(node.X)
- if _, ok := typ.Underlying().(*types.Map); ok {
- // looping once over a map is a valid pattern for
- // getting an arbitrary element.
- return true
- }
- body = node.Body
- loop = node
- default:
- return true
- }
- if len(body.List) < 2 {
- // avoid flagging the somewhat common pattern of using
- // a range loop to get the first element in a slice,
- // or the first rune in a string.
- return true
- }
- var unconditionalExit ast.Node
- hasBranching := false
- for _, stmt := range body.List {
- switch stmt := stmt.(type) {
- case *ast.BranchStmt:
- switch stmt.Tok {
- case token.BREAK:
- if stmt.Label == nil || labels[stmt.Label.Obj] == loop {
- unconditionalExit = stmt
- }
- case token.CONTINUE:
- if stmt.Label == nil || labels[stmt.Label.Obj] == loop {
- unconditionalExit = nil
- return false
- }
- }
- case *ast.ReturnStmt:
- unconditionalExit = stmt
- case *ast.IfStmt, *ast.ForStmt, *ast.RangeStmt, *ast.SwitchStmt, *ast.SelectStmt:
- hasBranching = true
- }
- }
- if unconditionalExit == nil || !hasBranching {
- return false
- }
- ast.Inspect(body, func(node ast.Node) bool {
- if branch, ok := node.(*ast.BranchStmt); ok {
-
- switch branch.Tok {
- case token.GOTO:
- unconditionalExit = nil
- return false
- case token.CONTINUE:
- if branch.Label != nil && labels[branch.Label.Obj] != loop {
- return true
- }
- unconditionalExit = nil
- return false
- }
- }
- return true
- })
- if unconditionalExit != nil {
- report.Report(pass, unconditionalExit, "the surrounding loop is unconditionally terminated")
- }
- return true
- })
- }
- code.Preorder(pass, fn, (*ast.FuncDecl)(nil), (*ast.FuncLit)(nil))
- return nil, nil
-}
-
-var checkNilContextQ = pattern.MustParse(`(CallExpr fun@(Function _) (Builtin "nil"):_)`)
-
-func CheckNilContext(pass *analysis.Pass) (interface{}, error) {
- todo := &ast.CallExpr{
- Fun: Selector("context", "TODO"),
- }
- bg := &ast.CallExpr{
- Fun: Selector("context", "Background"),
- }
- fn := func(node ast.Node) {
- m, ok := Match(pass, checkNilContextQ, node)
- if !ok {
- return
- }
-
- call := node.(*ast.CallExpr)
- fun, ok := m.State["fun"].(*types.Func)
- if !ok {
- // it might also be a builtin
- return
- }
- sig := fun.Type().(*types.Signature)
- if sig.Params().Len() == 0 {
- // Our CallExpr might've matched a method expression, like
- // (*T).Foo(nil) – here, nil isn't the first argument of
- // the Foo method, but the method receiver.
- return
- }
- if !code.IsType(sig.Params().At(0).Type(), "context.Context") {
- return
- }
- report.Report(pass, call.Args[0],
- "do not pass a nil Context, even if a function permits it; pass context.TODO if you are unsure about which Context to use", report.Fixes(
- edit.Fix("use context.TODO", edit.ReplaceWithNode(pass.Fset, call.Args[0], todo)),
- edit.Fix("use context.Background", edit.ReplaceWithNode(pass.Fset, call.Args[0], bg))))
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-var (
- checkSeekerQ = pattern.MustParse(`(CallExpr fun@(SelectorExpr _ (Ident "Seek")) [arg1@(SelectorExpr (Ident "io") (Ident (Or "SeekStart" "SeekCurrent" "SeekEnd"))) arg2])`)
- checkSeekerR = pattern.MustParse(`(CallExpr fun [arg2 arg1])`)
-)
-
-func CheckSeeker(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- if _, edits, ok := MatchAndEdit(pass, checkSeekerQ, checkSeekerR, node); ok {
- report.Report(pass, node, "the first argument of io.Seeker is the offset, but an io.Seek* constant is being used instead",
- report.Fixes(edit.Fix("swap arguments", edits...)))
- }
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckIneffectiveAppend(pass *analysis.Pass) (interface{}, error) {
- isAppend := func(ins ir.Value) bool {
- call, ok := ins.(*ir.Call)
- if !ok {
- return false
- }
- if call.Call.IsInvoke() {
- return false
- }
- if builtin, ok := call.Call.Value.(*ir.Builtin); !ok || builtin.Name() != "append" {
- return false
- }
- return true
- }
-
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- val, ok := ins.(ir.Value)
- if !ok || !isAppend(val) {
- continue
- }
-
- isUsed := false
- visited := map[ir.Instruction]bool{}
- var walkRefs func(refs []ir.Instruction)
- walkRefs = func(refs []ir.Instruction) {
- loop:
- for _, ref := range refs {
- if visited[ref] {
- continue
- }
- visited[ref] = true
- if _, ok := ref.(*ir.DebugRef); ok {
- continue
- }
- switch ref := ref.(type) {
- case *ir.Phi:
- walkRefs(*ref.Referrers())
- case *ir.Sigma:
- walkRefs(*ref.Referrers())
- case ir.Value:
- if !isAppend(ref) {
- isUsed = true
- } else {
- walkRefs(*ref.Referrers())
- }
- case ir.Instruction:
- isUsed = true
- break loop
- }
- }
- }
-
- refs := val.Referrers()
- if refs == nil {
- continue
- }
- walkRefs(*refs)
-
- if !isUsed {
- report.Report(pass, ins, "this result of append is never used, except maybe in other appends")
- }
- }
- }
- }
- return nil, nil
-}
-
-func CheckConcurrentTesting(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- gostmt, ok := ins.(*ir.Go)
- if !ok {
- continue
- }
- var fn *ir.Function
- switch val := gostmt.Call.Value.(type) {
- case *ir.Function:
- fn = val
- case *ir.MakeClosure:
- fn = val.Fn.(*ir.Function)
- default:
- continue
- }
- if fn.Blocks == nil {
- continue
- }
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- call, ok := ins.(*ir.Call)
- if !ok {
- continue
- }
- if call.Call.IsInvoke() {
- continue
- }
- callee := call.Call.StaticCallee()
- if callee == nil {
- continue
- }
- recv := callee.Signature.Recv()
- if recv == nil {
- continue
- }
- if !code.IsType(recv.Type(), "*testing.common") {
- continue
- }
- fn, ok := call.Call.StaticCallee().Object().(*types.Func)
- if !ok {
- continue
- }
- name := fn.Name()
- switch name {
- case "FailNow", "Fatal", "Fatalf", "SkipNow", "Skip", "Skipf":
- default:
- continue
- }
- // TODO(dh): don't report multiple diagnostics
- // for multiple calls to T.Fatal, but do
- // collect all of them as related information
- report.Report(pass, gostmt, fmt.Sprintf("the goroutine calls T.%s, which must be called in the same goroutine as the test", name),
- report.Related(call, fmt.Sprintf("call to T.%s", name)))
- }
- }
- }
- }
- }
- return nil, nil
-}
-
-func eachCall(fn *ir.Function, cb func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function)) {
- for _, b := range fn.Blocks {
- for _, instr := range b.Instrs {
- if site, ok := instr.(ir.CallInstruction); ok {
- if g := site.Common().StaticCallee(); g != nil {
- cb(fn, site, g)
- }
- }
- }
- }
-}
-
-func CheckCyclicFinalizer(pass *analysis.Pass) (interface{}, error) {
- cb := func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) {
- if callee.RelString(nil) != "runtime.SetFinalizer" {
- return
- }
- arg0 := site.Common().Args[Arg("runtime.SetFinalizer.obj")]
- if iface, ok := arg0.(*ir.MakeInterface); ok {
- arg0 = iface.X
- }
- load, ok := arg0.(*ir.Load)
- if !ok {
- return
- }
- v, ok := load.X.(*ir.Alloc)
- if !ok {
- return
- }
- arg1 := site.Common().Args[Arg("runtime.SetFinalizer.finalizer")]
- if iface, ok := arg1.(*ir.MakeInterface); ok {
- arg1 = iface.X
- }
- mc, ok := arg1.(*ir.MakeClosure)
- if !ok {
- return
- }
- for _, b := range mc.Bindings {
- if b == v {
- pos := lint.DisplayPosition(pass.Fset, mc.Fn.Pos())
- report.Report(pass, site, fmt.Sprintf("the finalizer closes over the object, preventing the finalizer from ever running (at %s)", pos))
- }
- }
- }
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- eachCall(fn, cb)
- }
- return nil, nil
-}
-
-/*
-func CheckSliceOutOfBounds(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- ia, ok := ins.(*ir.IndexAddr)
- if !ok {
- continue
- }
- if _, ok := ia.X.Type().Underlying().(*types.Slice); !ok {
- continue
- }
- sr, ok1 := c.funcDescs.Get(fn).Ranges[ia.X].(vrp.SliceInterval)
- idxr, ok2 := c.funcDescs.Get(fn).Ranges[ia.Index].(vrp.IntInterval)
- if !ok1 || !ok2 || !sr.IsKnown() || !idxr.IsKnown() || sr.Length.Empty() || idxr.Empty() {
- continue
- }
- if idxr.Lower.Cmp(sr.Length.Upper) >= 0 {
- report.Nodef(pass, ia, "index out of bounds")
- }
- }
- }
- }
- return nil, nil
-}
-*/
-
-func CheckDeferLock(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- instrs := code.FilterDebug(block.Instrs)
- if len(instrs) < 2 {
- continue
- }
- for i, ins := range instrs[:len(instrs)-1] {
- call, ok := ins.(*ir.Call)
- if !ok {
- continue
- }
- if !code.IsCallToAny(call.Common(), "(*sync.Mutex).Lock", "(*sync.RWMutex).RLock") {
- continue
- }
- nins, ok := instrs[i+1].(*ir.Defer)
- if !ok {
- continue
- }
- if !code.IsCallToAny(&nins.Call, "(*sync.Mutex).Lock", "(*sync.RWMutex).RLock") {
- continue
- }
- if call.Common().Args[0] != nins.Call.Args[0] {
- continue
- }
- name := shortCallName(call.Common())
- alt := ""
- switch name {
- case "Lock":
- alt = "Unlock"
- case "RLock":
- alt = "RUnlock"
- }
- report.Report(pass, nins, fmt.Sprintf("deferring %s right after having locked already; did you mean to defer %s?", name, alt))
- }
- }
- }
- return nil, nil
-}
-
-func CheckNaNComparison(pass *analysis.Pass) (interface{}, error) {
- isNaN := func(v ir.Value) bool {
- call, ok := v.(*ir.Call)
- if !ok {
- return false
- }
- return code.IsCallTo(call.Common(), "math.NaN")
- }
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- ins, ok := ins.(*ir.BinOp)
- if !ok {
- continue
- }
- if isNaN(ins.X) || isNaN(ins.Y) {
- report.Report(pass, ins, "no value is equal to NaN, not even NaN itself")
- }
- }
- }
- }
- return nil, nil
-}
-
-func CheckInfiniteRecursion(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- eachCall(fn, func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) {
- if callee != fn {
- return
- }
- if _, ok := site.(*ir.Go); ok {
- // Recursively spawning goroutines doesn't consume
- // stack space infinitely, so don't flag it.
- return
- }
-
- block := site.Block()
- canReturn := false
- for _, b := range fn.Blocks {
- if block.Dominates(b) {
- continue
- }
- if len(b.Instrs) == 0 {
- continue
- }
- if _, ok := b.Control().(*ir.Return); ok {
- canReturn = true
- break
- }
- }
- if canReturn {
- return
- }
- report.Report(pass, site, "infinite recursive call")
- })
- }
- return nil, nil
-}
-
-func objectName(obj types.Object) string {
- if obj == nil {
- return "<nil>"
- }
- var name string
- if obj.Pkg() != nil && obj.Pkg().Scope().Lookup(obj.Name()) == obj {
- s := obj.Pkg().Path()
- if s != "" {
- name += s + "."
- }
- }
- name += obj.Name()
- return name
-}
-
-func isName(pass *analysis.Pass, expr ast.Expr, name string) bool {
- var obj types.Object
- switch expr := expr.(type) {
- case *ast.Ident:
- obj = pass.TypesInfo.ObjectOf(expr)
- case *ast.SelectorExpr:
- obj = pass.TypesInfo.ObjectOf(expr.Sel)
- }
- return objectName(obj) == name
-}
-
-func CheckLeakyTimeTick(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- if code.IsMainLike(pass) || code.IsInTest(pass, fn) {
- continue
- }
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- call, ok := ins.(*ir.Call)
- if !ok || !code.IsCallTo(call.Common(), "time.Tick") {
- continue
- }
- if !functions.Terminates(call.Parent()) {
- continue
- }
- report.Report(pass, call, "using time.Tick leaks the underlying ticker, consider using it only in endless functions, tests and the main package, and use time.NewTicker here")
- }
- }
- }
- return nil, nil
-}
-
-var checkDoubleNegationQ = pattern.MustParse(`(UnaryExpr "!" single@(UnaryExpr "!" x))`)
-
-func CheckDoubleNegation(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- if m, ok := Match(pass, checkDoubleNegationQ, node); ok {
- report.Report(pass, node, "negating a boolean twice has no effect; is this a typo?", report.Fixes(
- edit.Fix("turn into single negation", edit.ReplaceWithNode(pass.Fset, node, m.State["single"].(ast.Node))),
- edit.Fix("remove double negation", edit.ReplaceWithNode(pass.Fset, node, m.State["x"].(ast.Node)))))
- }
- }
- code.Preorder(pass, fn, (*ast.UnaryExpr)(nil))
- return nil, nil
-}
-
-func CheckRepeatedIfElse(pass *analysis.Pass) (interface{}, error) {
- seen := map[ast.Node]bool{}
-
- var collectConds func(ifstmt *ast.IfStmt, conds []ast.Expr) ([]ast.Expr, bool)
- collectConds = func(ifstmt *ast.IfStmt, conds []ast.Expr) ([]ast.Expr, bool) {
- seen[ifstmt] = true
- // Bail if any if-statement has an Init statement or side effects in its condition
- if ifstmt.Init != nil {
- return nil, false
- }
- if code.MayHaveSideEffects(pass, ifstmt.Cond, nil) {
- return nil, false
- }
-
- conds = append(conds, ifstmt.Cond)
- if elsestmt, ok := ifstmt.Else.(*ast.IfStmt); ok {
- return collectConds(elsestmt, conds)
- }
- return conds, true
- }
- fn := func(node ast.Node) {
- ifstmt := node.(*ast.IfStmt)
- if seen[ifstmt] {
- // this if-statement is part of an if/else-if chain that we've already processed
- return
- }
- if ifstmt.Else == nil {
- // there can be at most one condition
- return
- }
- conds, ok := collectConds(ifstmt, nil)
- if !ok {
- return
- }
- if len(conds) < 2 {
- return
- }
- counts := map[string]int{}
- for _, cond := range conds {
- s := report.Render(pass, cond)
- counts[s]++
- if counts[s] == 2 {
- report.Report(pass, cond, "this condition occurs multiple times in this if/else if chain")
- }
- }
- }
- code.Preorder(pass, fn, (*ast.IfStmt)(nil))
- return nil, nil
-}
-
-func CheckSillyBitwiseOps(pass *analysis.Pass) (interface{}, error) {
- // FIXME(dh): what happened here?
- if false {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- ins, ok := ins.(*ir.BinOp)
- if !ok {
- continue
- }
-
- if c, ok := ins.Y.(*ir.Const); !ok || c.Value == nil || c.Value.Kind() != constant.Int || c.Uint64() != 0 {
- continue
- }
- switch ins.Op {
- case token.AND, token.OR, token.XOR:
- default:
- // we do not flag shifts because too often, x<<0 is part
- // of a pattern, x<<0, x<<8, x<<16, ...
- continue
- }
- path, _ := astutil.PathEnclosingInterval(code.File(pass, ins), ins.Pos(), ins.Pos())
- if len(path) == 0 {
- continue
- }
-
- if node, ok := path[0].(*ast.BinaryExpr); !ok || !code.IsIntLiteral(node.Y, "0") {
- continue
- }
-
- switch ins.Op {
- case token.AND:
- report.Report(pass, ins, "x & 0 always equals 0")
- case token.OR, token.XOR:
- report.Report(pass, ins, fmt.Sprintf("x %s 0 always equals x", ins.Op))
- }
- }
- }
- }
- }
- fn := func(node ast.Node) {
- binop := node.(*ast.BinaryExpr)
- b, ok := pass.TypesInfo.TypeOf(binop).Underlying().(*types.Basic)
- if !ok {
- return
- }
- if (b.Info() & types.IsInteger) == 0 {
- return
- }
- switch binop.Op {
- case token.AND, token.OR, token.XOR:
- default:
- // we do not flag shifts because too often, x<<0 is part
- // of a pattern, x<<0, x<<8, x<<16, ...
- return
- }
- switch y := binop.Y.(type) {
- case *ast.Ident:
- obj, ok := pass.TypesInfo.ObjectOf(y).(*types.Const)
- if !ok {
- return
- }
- if v, _ := constant.Int64Val(obj.Val()); v != 0 {
- return
- }
- path, _ := astutil.PathEnclosingInterval(code.File(pass, obj), obj.Pos(), obj.Pos())
- if len(path) < 2 {
- return
- }
- spec, ok := path[1].(*ast.ValueSpec)
- if !ok {
- return
- }
- if len(spec.Names) != 1 || len(spec.Values) != 1 {
- // TODO(dh): we could support this
- return
- }
- ident, ok := spec.Values[0].(*ast.Ident)
- if !ok {
- return
- }
- if !isIota(pass.TypesInfo.ObjectOf(ident)) {
- return
- }
- switch binop.Op {
- case token.AND:
- report.Report(pass, node,
- fmt.Sprintf("%s always equals 0; %s is defined as iota and has value 0, maybe %s is meant to be 1 << iota?", report.Render(pass, binop), report.Render(pass, binop.Y), report.Render(pass, binop.Y)))
- case token.OR, token.XOR:
- report.Report(pass, node,
- fmt.Sprintf("%s always equals %s; %s is defined as iota and has value 0, maybe %s is meant to be 1 << iota?", report.Render(pass, binop), report.Render(pass, binop.X), report.Render(pass, binop.Y), report.Render(pass, binop.Y)))
- }
- case *ast.BasicLit:
- if !code.IsIntLiteral(binop.Y, "0") {
- return
- }
- switch binop.Op {
- case token.AND:
- report.Report(pass, node, fmt.Sprintf("%s always equals 0", report.Render(pass, binop)))
- case token.OR, token.XOR:
- report.Report(pass, node, fmt.Sprintf("%s always equals %s", report.Render(pass, binop), report.Render(pass, binop.X)))
- }
- default:
- return
- }
- }
- code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
- return nil, nil
-}
-
-func isIota(obj types.Object) bool {
- if obj.Name() != "iota" {
- return false
- }
- c, ok := obj.(*types.Const)
- if !ok {
- return false
- }
- return c.Pkg() == nil
-}
-
-func CheckNonOctalFileMode(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- call := node.(*ast.CallExpr)
- sig, ok := pass.TypesInfo.TypeOf(call.Fun).(*types.Signature)
- if !ok {
- return
- }
- n := sig.Params().Len()
- for i := 0; i < n; i++ {
- typ := sig.Params().At(i).Type()
- if !code.IsType(typ, "os.FileMode") {
- continue
- }
-
- lit, ok := call.Args[i].(*ast.BasicLit)
- if !ok {
- continue
- }
- if len(lit.Value) == 3 &&
- lit.Value[0] != '0' &&
- lit.Value[0] >= '0' && lit.Value[0] <= '7' &&
- lit.Value[1] >= '0' && lit.Value[1] <= '7' &&
- lit.Value[2] >= '0' && lit.Value[2] <= '7' {
-
- v, err := strconv.ParseInt(lit.Value, 10, 64)
- if err != nil {
- continue
- }
- report.Report(pass, call.Args[i], fmt.Sprintf("file mode '%s' evaluates to %#o; did you mean '0%s'?", lit.Value, v, lit.Value),
- report.Fixes(edit.Fix("fix octal literal", edit.ReplaceWithString(pass.Fset, call.Args[i], "0"+lit.Value))))
- }
- }
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckPureFunctions(pass *analysis.Pass) (interface{}, error) {
- pure := pass.ResultOf[facts.Purity].(facts.PurityResult)
-
-fnLoop:
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- if code.IsInTest(pass, fn) {
- params := fn.Signature.Params()
- for i := 0; i < params.Len(); i++ {
- param := params.At(i)
- if code.IsType(param.Type(), "*testing.B") {
- // Ignore discarded pure functions in code related
- // to benchmarks. Instead of matching BenchmarkFoo
- // functions, we match any function accepting a
- // *testing.B. Benchmarks sometimes call generic
- // functions for doing the actual work, and
- // checking for the parameter is a lot easier and
- // faster than analyzing call trees.
- continue fnLoop
- }
- }
- }
-
- for _, b := range fn.Blocks {
- for _, ins := range b.Instrs {
- ins, ok := ins.(*ir.Call)
- if !ok {
- continue
- }
- refs := ins.Referrers()
- if refs == nil || len(code.FilterDebug(*refs)) > 0 {
- continue
- }
-
- callee := ins.Common().StaticCallee()
- if callee == nil {
- continue
- }
- if callee.Object() == nil {
- // TODO(dh): support anonymous functions
- continue
- }
- if _, ok := pure[callee.Object().(*types.Func)]; ok {
- if pass.Pkg.Path() == "fmt_test" && callee.Object().(*types.Func).FullName() == "fmt.Sprintf" {
- // special case for benchmarks in the fmt package
- continue
- }
- report.Report(pass, ins, fmt.Sprintf("%s is a pure function but its return value is ignored", callee.Name()))
- }
- }
- }
- }
- return nil, nil
-}
-
-func CheckDeprecated(pass *analysis.Pass) (interface{}, error) {
- deprs := pass.ResultOf[facts.Deprecated].(facts.DeprecatedResult)
-
- // Selectors can appear outside of function literals, e.g. when
- // declaring package level variables.
-
- var tfn types.Object
- stack := 0
- fn := func(node ast.Node, push bool) bool {
- if !push {
- stack--
- return false
- }
- stack++
- if stack == 1 {
- tfn = nil
- }
- if fn, ok := node.(*ast.FuncDecl); ok {
- tfn = pass.TypesInfo.ObjectOf(fn.Name)
- }
- sel, ok := node.(*ast.SelectorExpr)
- if !ok {
- return true
- }
-
- obj := pass.TypesInfo.ObjectOf(sel.Sel)
- if obj.Pkg() == nil {
- return true
- }
- if pass.Pkg == obj.Pkg() || obj.Pkg().Path()+"_test" == pass.Pkg.Path() {
- // Don't flag stuff in our own package
- return true
- }
- if depr, ok := deprs.Objects[obj]; ok {
- // Look for the first available alternative, not the first
- // version something was deprecated in. If a function was
- // deprecated in Go 1.6, an alternative has been available
- // already in 1.0, and we're targeting 1.2, it still
- // makes sense to use the alternative from 1.0, to be
- // future-proof.
- minVersion := deprecated.Stdlib[code.SelectorName(pass, sel)].AlternativeAvailableSince
- if !code.IsGoVersion(pass, minVersion) {
- return true
- }
-
- if tfn != nil {
- if _, ok := deprs.Objects[tfn]; ok {
- // functions that are deprecated may use deprecated
- // symbols
- return true
- }
- }
- report.Report(pass, sel, fmt.Sprintf("%s is deprecated: %s", report.Render(pass, sel), depr.Msg))
- return true
- }
- return true
- }
-
- fn2 := func(node ast.Node) {
- spec := node.(*ast.ImportSpec)
- var imp *types.Package
- if spec.Name != nil {
- imp = pass.TypesInfo.ObjectOf(spec.Name).(*types.PkgName).Imported()
- } else {
- imp = pass.TypesInfo.Implicits[spec].(*types.PkgName).Imported()
- }
-
- p := spec.Path.Value
- path := p[1 : len(p)-1]
- if depr, ok := deprs.Packages[imp]; ok {
- if path == "github.com/golang/protobuf/proto" {
- gen, ok := code.Generator(pass, spec.Path.Pos())
- if ok && gen == facts.ProtocGenGo {
- return
- }
- }
- report.Report(pass, spec, fmt.Sprintf("package %s is deprecated: %s", path, depr.Msg))
- }
- }
- pass.ResultOf[inspect.Analyzer].(*inspector.Inspector).Nodes(nil, fn)
- code.Preorder(pass, fn2, (*ast.ImportSpec)(nil))
- return nil, nil
-}
-
-func callChecker(rules map[string]CallCheck) func(pass *analysis.Pass) (interface{}, error) {
- return func(pass *analysis.Pass) (interface{}, error) {
- return checkCalls(pass, rules)
- }
-}
-
-func checkCalls(pass *analysis.Pass, rules map[string]CallCheck) (interface{}, error) {
- cb := func(caller *ir.Function, site ir.CallInstruction, callee *ir.Function) {
- obj, ok := callee.Object().(*types.Func)
- if !ok {
- return
- }
-
- r, ok := rules[lint.FuncName(obj)]
- if !ok {
- return
- }
- var args []*Argument
- irargs := site.Common().Args
- if callee.Signature.Recv() != nil {
- irargs = irargs[1:]
- }
- for _, arg := range irargs {
- if iarg, ok := arg.(*ir.MakeInterface); ok {
- arg = iarg.X
- }
- args = append(args, &Argument{Value: Value{arg}})
- }
- call := &Call{
- Pass: pass,
- Instr: site,
- Args: args,
- Parent: site.Parent(),
- }
- r(call)
- path, _ := astutil.PathEnclosingInterval(code.File(pass, site), site.Pos(), site.Pos())
- var astcall *ast.CallExpr
- for _, el := range path {
- if expr, ok := el.(*ast.CallExpr); ok {
- astcall = expr
- break
- }
- }
- for idx, arg := range call.Args {
- for _, e := range arg.invalids {
- if astcall != nil {
- report.Report(pass, astcall.Args[idx], e)
- } else {
- report.Report(pass, site, e)
- }
- }
- }
- for _, e := range call.invalids {
- report.Report(pass, call.Instr, e)
- }
- }
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- eachCall(fn, cb)
- }
- return nil, nil
-}
-
-func shortCallName(call *ir.CallCommon) string {
- if call.IsInvoke() {
- return ""
- }
- switch v := call.Value.(type) {
- case *ir.Function:
- fn, ok := v.Object().(*types.Func)
- if !ok {
- return ""
- }
- return fn.Name()
- case *ir.Builtin:
- return v.Name()
- }
- return ""
-}
-
-func CheckWriterBufferModified(pass *analysis.Pass) (interface{}, error) {
- // TODO(dh): this might be a good candidate for taint analysis.
- // Taint the argument as MUST_NOT_MODIFY, then propagate that
- // through functions like bytes.Split
-
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- sig := fn.Signature
- if fn.Name() != "Write" || sig.Recv() == nil || sig.Params().Len() != 1 || sig.Results().Len() != 2 {
- continue
- }
- tArg, ok := sig.Params().At(0).Type().(*types.Slice)
- if !ok {
- continue
- }
- if basic, ok := tArg.Elem().(*types.Basic); !ok || basic.Kind() != types.Byte {
- continue
- }
- if basic, ok := sig.Results().At(0).Type().(*types.Basic); !ok || basic.Kind() != types.Int {
- continue
- }
- if named, ok := sig.Results().At(1).Type().(*types.Named); !ok || !code.IsType(named, "error") {
- continue
- }
-
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- switch ins := ins.(type) {
- case *ir.Store:
- addr, ok := ins.Addr.(*ir.IndexAddr)
- if !ok {
- continue
- }
- if addr.X != fn.Params[1] {
- continue
- }
- report.Report(pass, ins, "io.Writer.Write must not modify the provided buffer, not even temporarily")
- case *ir.Call:
- if !code.IsCallTo(ins.Common(), "append") {
- continue
- }
- if ins.Common().Args[0] != fn.Params[1] {
- continue
- }
- report.Report(pass, ins, "io.Writer.Write must not modify the provided buffer, not even temporarily")
- }
- }
- }
- }
- return nil, nil
-}
-
-func loopedRegexp(name string) CallCheck {
- return func(call *Call) {
- if len(extractConsts(call.Args[0].Value.Value)) == 0 {
- return
- }
- if !isInLoop(call.Instr.Block()) {
- return
- }
- call.Invalid(fmt.Sprintf("calling %s in a loop has poor performance, consider using regexp.Compile", name))
- }
-}
-
-func CheckEmptyBranch(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- if fn.Source() == nil {
- continue
- }
- if code.IsExample(fn) {
- continue
- }
- cb := func(node ast.Node) bool {
- ifstmt, ok := node.(*ast.IfStmt)
- if !ok {
- return true
- }
- if ifstmt.Else != nil {
- b, ok := ifstmt.Else.(*ast.BlockStmt)
- if !ok || len(b.List) != 0 {
- return true
- }
- report.Report(pass, ifstmt.Else, "empty branch", report.FilterGenerated(), report.ShortRange())
- }
- if len(ifstmt.Body.List) != 0 {
- return true
- }
- report.Report(pass, ifstmt, "empty branch", report.FilterGenerated(), report.ShortRange())
- return true
- }
- Inspect(fn.Source(), cb)
- }
- return nil, nil
-}
-
-func CheckMapBytesKey(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, b := range fn.Blocks {
- insLoop:
- for _, ins := range b.Instrs {
- // find []byte -> string conversions
- conv, ok := ins.(*ir.Convert)
- if !ok || conv.Type() != types.Universe.Lookup("string").Type() {
- continue
- }
- if s, ok := conv.X.Type().(*types.Slice); !ok || s.Elem() != types.Universe.Lookup("byte").Type() {
- continue
- }
- refs := conv.Referrers()
- // need at least two (DebugRef) references: the
- // conversion and the *ast.Ident
- if refs == nil || len(*refs) < 2 {
- continue
- }
- ident := false
- // skip first reference, that's the conversion itself
- for _, ref := range (*refs)[1:] {
- switch ref := ref.(type) {
- case *ir.DebugRef:
- if _, ok := ref.Expr.(*ast.Ident); !ok {
- // the string seems to be used somewhere
- // unexpected; the default branch should
- // catch this already, but be safe
- continue insLoop
- } else {
- ident = true
- }
- case *ir.MapLookup:
- default:
- // the string is used somewhere else than a
- // map lookup
- continue insLoop
- }
- }
-
- // the result of the conversion wasn't assigned to an
- // identifier
- if !ident {
- continue
- }
- report.Report(pass, conv, "m[string(key)] would be more efficient than k := string(key); m[k]")
- }
- }
- }
- return nil, nil
-}
-
-func CheckRangeStringRunes(pass *analysis.Pass) (interface{}, error) {
- return sharedcheck.CheckRangeStringRunes(pass)
-}
-
-func CheckSelfAssignment(pass *analysis.Pass) (interface{}, error) {
- pure := pass.ResultOf[facts.Purity].(facts.PurityResult)
-
- fn := func(node ast.Node) {
- assign := node.(*ast.AssignStmt)
- if assign.Tok != token.ASSIGN || len(assign.Lhs) != len(assign.Rhs) {
- return
- }
- for i, lhs := range assign.Lhs {
- rhs := assign.Rhs[i]
- if reflect.TypeOf(lhs) != reflect.TypeOf(rhs) {
- continue
- }
- if code.MayHaveSideEffects(pass, lhs, pure) || code.MayHaveSideEffects(pass, rhs, pure) {
- continue
- }
-
- rlh := report.Render(pass, lhs)
- rrh := report.Render(pass, rhs)
- if rlh == rrh {
- report.Report(pass, assign, fmt.Sprintf("self-assignment of %s to %s", rrh, rlh), report.FilterGenerated())
- }
- }
- }
- code.Preorder(pass, fn, (*ast.AssignStmt)(nil))
- return nil, nil
-}
-
-func buildTagsIdentical(s1, s2 []string) bool {
- if len(s1) != len(s2) {
- return false
- }
- s1s := make([]string, len(s1))
- copy(s1s, s1)
- sort.Strings(s1s)
- s2s := make([]string, len(s2))
- copy(s2s, s2)
- sort.Strings(s2s)
- for i, s := range s1s {
- if s != s2s[i] {
- return false
- }
- }
- return true
-}
-
-func CheckDuplicateBuildConstraints(pass *analysis.Pass) (interface{}, error) {
- for _, f := range pass.Files {
- constraints := buildTags(f)
- for i, constraint1 := range constraints {
- for j, constraint2 := range constraints {
- if i >= j {
- continue
- }
- if buildTagsIdentical(constraint1, constraint2) {
- msg := fmt.Sprintf("identical build constraints %q and %q",
- strings.Join(constraint1, " "),
- strings.Join(constraint2, " "))
- report.Report(pass, f, msg, report.FilterGenerated(), report.ShortRange())
- }
- }
- }
- }
- return nil, nil
-}
-
-func CheckSillyRegexp(pass *analysis.Pass) (interface{}, error) {
- // We could use the rule checking engine for this, but the
- // arguments aren't really invalid.
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, b := range fn.Blocks {
- for _, ins := range b.Instrs {
- call, ok := ins.(*ir.Call)
- if !ok {
- continue
- }
- if !code.IsCallToAny(call.Common(), "regexp.MustCompile", "regexp.Compile", "regexp.Match", "regexp.MatchReader", "regexp.MatchString") {
- continue
- }
- c, ok := call.Common().Args[0].(*ir.Const)
- if !ok {
- continue
- }
- s := constant.StringVal(c.Value)
- re, err := syntax.Parse(s, 0)
- if err != nil {
- continue
- }
- if re.Op != syntax.OpLiteral && re.Op != syntax.OpEmptyMatch {
- continue
- }
- report.Report(pass, call, "regular expression does not contain any meta characters")
- }
- }
- }
- return nil, nil
-}
-
-func CheckMissingEnumTypesInDeclaration(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- decl := node.(*ast.GenDecl)
- if !decl.Lparen.IsValid() {
- return
- }
- if decl.Tok != token.CONST {
- return
- }
-
- groups := code.GroupSpecs(pass.Fset, decl.Specs)
- groupLoop:
- for _, group := range groups {
- if len(group) < 2 {
- continue
- }
- if group[0].(*ast.ValueSpec).Type == nil {
- // first constant doesn't have a type
- continue groupLoop
- }
- for i, spec := range group {
- spec := spec.(*ast.ValueSpec)
- if len(spec.Names) != 1 || len(spec.Values) != 1 {
- continue groupLoop
- }
- switch v := spec.Values[0].(type) {
- case *ast.BasicLit:
- case *ast.UnaryExpr:
- if _, ok := v.X.(*ast.BasicLit); !ok {
- continue groupLoop
- }
- default:
- // if it's not a literal it might be typed, such as
- // time.Microsecond = 1000 * Nanosecond
- continue groupLoop
- }
- if i == 0 {
- continue
- }
- if spec.Type != nil {
- continue groupLoop
- }
- }
- var edits []analysis.TextEdit
- typ := group[0].(*ast.ValueSpec).Type
- for _, spec := range group[1:] {
- nspec := *spec.(*ast.ValueSpec)
- nspec.Type = typ
- edits = append(edits, edit.ReplaceWithNode(pass.Fset, spec, &nspec))
- }
- report.Report(pass, group[0], "only the first constant in this group has an explicit type", report.Fixes(edit.Fix("add type to all constants in group", edits...)))
- }
- }
- code.Preorder(pass, fn, (*ast.GenDecl)(nil))
- return nil, nil
-}
-
-func CheckTimerResetReturnValue(pass *analysis.Pass) (interface{}, error) {
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, block := range fn.Blocks {
- for _, ins := range block.Instrs {
- call, ok := ins.(*ir.Call)
- if !ok {
- continue
- }
- if !code.IsCallTo(call.Common(), "(*time.Timer).Reset") {
- continue
- }
- refs := call.Referrers()
- if refs == nil {
- continue
- }
- for _, ref := range code.FilterDebug(*refs) {
- ifstmt, ok := ref.(*ir.If)
- if !ok {
- continue
- }
-
- found := false
- for _, succ := range ifstmt.Block().Succs {
- if len(succ.Preds) != 1 {
- // Merge point, not a branch in the
- // syntactical sense.
-
- // FIXME(dh): this is broken for if
- // statements a la "if x || y"
- continue
- }
- irutil.Walk(succ, func(b *ir.BasicBlock) bool {
- if !succ.Dominates(b) {
- // We've reached the end of the branch
- return false
- }
- for _, ins := range b.Instrs {
- // TODO(dh): we should check that
- // we're receiving from the channel of
- // a time.Timer to further reduce
- // false positives. Not a key
- // priority, considering the rarity of
- // Reset and the tiny likeliness of a
- // false positive
- if ins, ok := ins.(*ir.Recv); ok && code.IsType(ins.Chan.Type(), "<-chan time.Time") {
- found = true
- return false
- }
- }
- return true
- })
- }
-
- if found {
- report.Report(pass, call, "it is not possible to use Reset's return value correctly, as there is a race condition between draining the channel and the new timer expiring")
- }
- }
- }
- }
- }
- return nil, nil
-}
-
-var (
- checkToLowerToUpperComparisonQ = pattern.MustParse(`
- (BinaryExpr
- (CallExpr fun@(Function (Or "strings.ToLower" "strings.ToUpper")) [a])
- tok@(Or "==" "!=")
- (CallExpr fun [b]))`)
- checkToLowerToUpperComparisonR = pattern.MustParse(`(CallExpr (SelectorExpr (Ident "strings") (Ident "EqualFold")) [a b])`)
-)
-
-func CheckToLowerToUpperComparison(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- m, ok := Match(pass, checkToLowerToUpperComparisonQ, node)
- if !ok {
- return
- }
- rn := pattern.NodeToAST(checkToLowerToUpperComparisonR.Root, m.State).(ast.Expr)
- if m.State["tok"].(token.Token) == token.NEQ {
- rn = &ast.UnaryExpr{
- Op: token.NOT,
- X: rn,
- }
- }
-
- report.Report(pass, node, "should use strings.EqualFold instead", report.Fixes(edit.Fix("replace with strings.EqualFold", edit.ReplaceWithNode(pass.Fset, node, rn))))
- }
-
- code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
- return nil, nil
-}
-
-func CheckUnreachableTypeCases(pass *analysis.Pass) (interface{}, error) {
- // Check if T subsumes V in a type switch. T subsumes V if T is an interface and T's method set is a subset of V's method set.
- subsumes := func(T, V types.Type) bool {
- tIface, ok := T.Underlying().(*types.Interface)
- if !ok {
- return false
- }
-
- return types.Implements(V, tIface)
- }
-
- subsumesAny := func(Ts, Vs []types.Type) (types.Type, types.Type, bool) {
- for _, T := range Ts {
- for _, V := range Vs {
- if subsumes(T, V) {
- return T, V, true
- }
- }
- }
-
- return nil, nil, false
- }
-
- fn := func(node ast.Node) {
- tsStmt := node.(*ast.TypeSwitchStmt)
-
- type ccAndTypes struct {
- cc *ast.CaseClause
- types []types.Type
- }
-
- // All asserted types in the order of case clauses.
- ccs := make([]ccAndTypes, 0, len(tsStmt.Body.List))
- for _, stmt := range tsStmt.Body.List {
- cc, _ := stmt.(*ast.CaseClause)
-
- // Exclude the 'default' case.
- if len(cc.List) == 0 {
- continue
- }
-
- Ts := make([]types.Type, len(cc.List))
- for i, expr := range cc.List {
- Ts[i] = pass.TypesInfo.TypeOf(expr)
- }
-
- ccs = append(ccs, ccAndTypes{cc: cc, types: Ts})
- }
-
- if len(ccs) <= 1 {
- // Zero or one case clauses, nothing to check.
- return
- }
-
- // Check if case clauses following cc have types that are subsumed by cc.
- for i, cc := range ccs[:len(ccs)-1] {
- for _, next := range ccs[i+1:] {
- if T, V, yes := subsumesAny(cc.types, next.types); yes {
- report.Report(pass, next.cc, fmt.Sprintf("unreachable case clause: %s will always match before %s", T.String(), V.String()),
- report.ShortRange())
- }
- }
- }
- }
-
- code.Preorder(pass, fn, (*ast.TypeSwitchStmt)(nil))
- return nil, nil
-}
-
-var checkSingleArgAppendQ = pattern.MustParse(`(CallExpr (Builtin "append") [_])`)
-
-func CheckSingleArgAppend(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- _, ok := Match(pass, checkSingleArgAppendQ, node)
- if !ok {
- return
- }
- report.Report(pass, node, "x = append(y) is equivalent to x = y", report.FilterGenerated())
- }
- code.Preorder(pass, fn, (*ast.CallExpr)(nil))
- return nil, nil
-}
-
-func CheckStructTags(pass *analysis.Pass) (interface{}, error) {
- importsGoFlags := false
-
- // we use the AST instead of (*types.Package).Imports to work
- // around vendored packages in GOPATH mode. A vendored package's
- // path will include the vendoring subtree as a prefix.
- for _, f := range pass.Files {
- for _, imp := range f.Imports {
- v := imp.Path.Value
- if v[1:len(v)-1] == "github.com/jessevdk/go-flags" {
- importsGoFlags = true
- break
- }
- }
- }
-
- fn := func(node ast.Node) {
- for _, field := range node.(*ast.StructType).Fields.List {
- if field.Tag == nil {
- continue
- }
- tags, err := parseStructTag(field.Tag.Value[1 : len(field.Tag.Value)-1])
- if err != nil {
- report.Report(pass, field.Tag, fmt.Sprintf("unparseable struct tag: %s", err))
- continue
- }
- for k, v := range tags {
- if len(v) > 1 {
- isGoFlagsTag := importsGoFlags &&
- (k == "choice" || k == "optional-value" || k == "default")
- if !isGoFlagsTag {
- report.Report(pass, field.Tag, fmt.Sprintf("duplicate struct tag %q", k))
- }
- }
-
- switch k {
- case "json":
- checkJSONTag(pass, field, v[0])
- case "xml":
- checkXMLTag(pass, field, v[0])
- }
- }
- }
- }
- code.Preorder(pass, fn, (*ast.StructType)(nil))
- return nil, nil
-}
-
-func checkJSONTag(pass *analysis.Pass, field *ast.Field, tag string) {
- if pass.Pkg.Path() == "encoding/json" || pass.Pkg.Path() == "encoding/json_test" {
- // don't flag malformed JSON tags in the encoding/json
- // package; it knows what it is doing, and it is testing
- // itself.
- return
- }
- //lint:ignore SA9003 TODO(dh): should we flag empty tags?
- if len(tag) == 0 {
- }
- fields := strings.Split(tag, ",")
- for _, r := range fields[0] {
- if !unicode.IsLetter(r) && !unicode.IsDigit(r) && !strings.ContainsRune("!#$%&()*+-./:<=>?@[]^_{|}~ ", r) {
- report.Report(pass, field.Tag, fmt.Sprintf("invalid JSON field name %q", fields[0]))
- }
- }
- var co, cs, ci int
- for _, s := range fields[1:] {
- switch s {
- case "omitempty":
- co++
- case "":
- // allow stuff like "-,"
- case "string":
- cs++
- // only for string, floating point, integer and bool
- T := code.Dereference(pass.TypesInfo.TypeOf(field.Type).Underlying()).Underlying()
- basic, ok := T.(*types.Basic)
- if !ok || (basic.Info()&(types.IsBoolean|types.IsInteger|types.IsFloat|types.IsString)) == 0 {
- report.Report(pass, field.Tag, "the JSON string option only applies to fields of type string, floating point, integer or bool, or pointers to those")
- }
- case "inline":
- ci++
- default:
- report.Report(pass, field.Tag, fmt.Sprintf("unknown JSON option %q", s))
- }
- }
- if co > 1 {
- report.Report(pass, field.Tag, `duplicate JSON option "omitempty"`)
- }
- if cs > 1 {
- report.Report(pass, field.Tag, `duplicate JSON option "string"`)
- }
- if ci > 1 {
- report.Report(pass, field.Tag, `duplicate JSON option "inline"`)
- }
-}
-
-func checkXMLTag(pass *analysis.Pass, field *ast.Field, tag string) {
- //lint:ignore SA9003 TODO(dh): should we flag empty tags?
- if len(tag) == 0 {
- }
- fields := strings.Split(tag, ",")
- counts := map[string]int{}
- var exclusives []string
- for _, s := range fields[1:] {
- switch s {
- case "attr", "chardata", "cdata", "innerxml", "comment":
- counts[s]++
- if counts[s] == 1 {
- exclusives = append(exclusives, s)
- }
- case "omitempty", "any":
- counts[s]++
- case "":
- default:
- report.Report(pass, field.Tag, fmt.Sprintf("unknown XML option %q", s))
- }
- }
- for k, v := range counts {
- if v > 1 {
- report.Report(pass, field.Tag, fmt.Sprintf("duplicate XML option %q", k))
- }
- }
- if len(exclusives) > 1 {
- report.Report(pass, field.Tag, fmt.Sprintf("XML options %s are mutually exclusive", strings.Join(exclusives, " and ")))
- }
-}
-
-func CheckImpossibleTypeAssertion(pass *analysis.Pass) (interface{}, error) {
- type entry struct {
- l, r *types.Func
- }
-
- msc := &pass.ResultOf[buildir.Analyzer].(*buildir.IR).Pkg.Prog.MethodSets
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- for _, b := range fn.Blocks {
- for _, instr := range b.Instrs {
- assert, ok := instr.(*ir.TypeAssert)
- if !ok {
- continue
- }
- var wrong []entry
- left := assert.X.Type()
- right := assert.AssertedType
- righti, ok := right.Underlying().(*types.Interface)
-
- if !ok {
- // We only care about interface->interface
- // assertions. The Go compiler already catches
- // impossible interface->concrete assertions.
- continue
- }
-
- ms := msc.MethodSet(left)
- for i := 0; i < righti.NumMethods(); i++ {
- mr := righti.Method(i)
- sel := ms.Lookup(mr.Pkg(), mr.Name())
- if sel == nil {
- continue
- }
- ml := sel.Obj().(*types.Func)
- if types.AssignableTo(ml.Type(), mr.Type()) {
- continue
- }
-
- wrong = append(wrong, entry{ml, mr})
- }
-
- if len(wrong) != 0 {
- s := fmt.Sprintf("impossible type assertion; %s and %s contradict each other:",
- types.TypeString(left, types.RelativeTo(pass.Pkg)),
- types.TypeString(right, types.RelativeTo(pass.Pkg)))
- for _, e := range wrong {
- s += fmt.Sprintf("\n\twrong type for %s method", e.l.Name())
- s += fmt.Sprintf("\n\t\thave %s", e.l.Type())
- s += fmt.Sprintf("\n\t\twant %s", e.r.Type())
- }
- report.Report(pass, assert, s)
- }
- }
- }
- }
- return nil, nil
-}
-
-func checkWithValueKey(call *Call) {
- arg := call.Args[1]
- T := arg.Value.Value.Type()
- if T, ok := T.(*types.Basic); ok {
- arg.Invalid(
- fmt.Sprintf("should not use built-in type %s as key for value; define your own type to avoid collisions", T))
- }
- if !types.Comparable(T) {
- arg.Invalid(fmt.Sprintf("keys used with context.WithValue must be comparable, but type %s is not comparable", T))
- }
-}
-
-func CheckMaybeNil(pass *analysis.Pass) (interface{}, error) {
- // This is an extremely trivial check that doesn't try to reason
- // about control flow. That is, phis and sigmas do not propagate
- // any information. As such, we can flag this:
- //
- // _ = *x
- // if x == nil { return }
- //
- // but we cannot flag this:
- //
- // if x == nil { println(x) }
- // _ = *x
- //
- // nor many other variations of conditional uses of or assignments to x.
- //
- // However, even this trivial implementation finds plenty of
- // real-world bugs, such as dereference before nil pointer check,
- // or using t.Error instead of t.Fatal when encountering nil
- // pointers.
- //
- // On the flip side, our naive implementation avoids false positives in branches, such as
- //
- // if x != nil { _ = *x }
- //
- // due to the same lack of propagating information through sigma
- // nodes. x inside the branch will be independent of the x in the
- // nil pointer check.
- //
- //
- // We could implement a more powerful check, but then we'd be
- // getting false positives instead of false negatives because
- // we're incapable of deducing relationships between variables.
- // For example, a function might return a pointer and an error,
- // and the error being nil guarantees that the pointer is not nil.
- // Depending on the surrounding code, the pointer may still end up
- // being checked against nil in one place, and guarded by a check
- // on the error in another, which would lead to us marking some
- // loads as unsafe.
- //
- // Unfortunately, simply hard-coding the relationship between
- // return values wouldn't eliminate all false positives, either.
- // Many other more subtle relationships exist. An abridged example
- // from real code:
- //
- // if a == nil && b == nil { return }
- // c := fn(a)
- // if c != "" { _ = *a }
- //
- // where `fn` is guaranteed to return a non-empty string if a
- // isn't nil.
- //
- // We choose to err on the side of false negatives.
-
- isNilConst := func(v ir.Value) bool {
- if code.IsPointerLike(v.Type()) {
- if k, ok := v.(*ir.Const); ok {
- return k.IsNil()
- }
- }
- return false
- }
-
- for _, fn := range pass.ResultOf[buildir.Analyzer].(*buildir.IR).SrcFuncs {
- maybeNil := map[ir.Value]ir.Instruction{}
- for _, b := range fn.Blocks {
- for _, instr := range b.Instrs {
- if instr, ok := instr.(*ir.BinOp); ok {
- var ptr ir.Value
- if isNilConst(instr.X) {
- ptr = instr.Y
- } else if isNilConst(instr.Y) {
- ptr = instr.X
- }
- maybeNil[ptr] = instr
- }
- }
- }
-
- for _, b := range fn.Blocks {
- for _, instr := range b.Instrs {
- var ptr ir.Value
- switch instr := instr.(type) {
- case *ir.Load:
- ptr = instr.X
- case *ir.Store:
- ptr = instr.Addr
- case *ir.IndexAddr:
- ptr = instr.X
- case *ir.FieldAddr:
- ptr = instr.X
- }
- if ptr != nil {
- switch ptr.(type) {
- case *ir.Alloc, *ir.FieldAddr, *ir.IndexAddr:
- // these cannot be nil
- continue
- }
- if r, ok := maybeNil[ptr]; ok {
- report.Report(pass, instr, "possible nil pointer dereference",
- report.Related(r, "this check suggests that the pointer can be nil"))
- }
- }
- }
- }
- }
-
- return nil, nil
-}
-
-var checkAddressIsNilQ = pattern.MustParse(
- `(BinaryExpr
- (UnaryExpr "&" _)
- (Or "==" "!=")
- (Builtin "nil"))`)
-
-func CheckAddressIsNil(pass *analysis.Pass) (interface{}, error) {
- fn := func(node ast.Node) {
- _, ok := Match(pass, checkAddressIsNilQ, node)
- if !ok {
- return
- }
- report.Report(pass, node, "the address of a variable cannot be nil")
- }
- code.Preorder(pass, fn, (*ast.BinaryExpr)(nil))
- return nil, nil
-}
projects / dotfiles / .git / blobdiff