.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201028153306-37f0764111ff/go/analysis/passes/nilness/testdata/src/a/a.go

   1 package a
   2
   3 type X struct{ f, g int }
   4
   5 func f(x, y *X) {
   6         if x == nil {
   7                 print(x.f) // want "nil dereference in field selection"
   8         } else {
   9                 print(x.f)
  10         }
  11
  12         if x == nil {
  13                 if nil != y {
  14                         print(1)
  15                         panic(0)
  16                 }
  17                 x.f = 1 // want "nil dereference in field selection"
  18                 y.f = 1 // want "nil dereference in field selection"
  19         }
  20
  21         var f func()
  22         if f == nil { // want "tautological condition: nil == nil"
  23                 go f() // want "nil dereference in dynamic function call"
  24         } else {
  25                 // This block is unreachable,
  26                 // so we don't report an error for the
  27                 // nil dereference in the call.
  28                 defer f()
  29         }
  30 }
  31
  32 func f2(ptr *[3]int, i interface{}) {
  33         if ptr != nil {
  34                 print(ptr[:])
  35                 *ptr = [3]int{}
  36                 print(*ptr)
  37         } else {
  38                 print(ptr[:])   // want "nil dereference in slice operation"
  39                 *ptr = [3]int{} // want "nil dereference in store"
  40                 print(*ptr)     // want "nil dereference in load"
  41
  42                 if ptr != nil { // want "impossible condition: nil != nil"
  43                         // Dominated by ptr==nil and ptr!=nil,
  44                         // this block is unreachable.
  45                         // We do not report errors within it.
  46                         print(*ptr)
  47                 }
  48         }
  49
  50         if i != nil {
  51                 print(i.(interface{ f() }))
  52         } else {
  53                 print(i.(interface{ f() })) // want "nil dereference in type assertion"
  54         }
  55 }
  56
  57 func g() error
  58
  59 func f3() error {
  60         err := g()
  61         if err != nil {
  62                 return err
  63         }
  64         if err != nil && err.Error() == "foo" { // want "impossible condition: nil != nil"
  65                 print(0)
  66         }
  67         ch := make(chan int)
  68         if ch == nil { // want "impossible condition: non-nil == nil"
  69                 print(0)
  70         }
  71         if ch != nil { // want "tautological condition: non-nil != nil"
  72                 print(0)
  73         }
  74         return nil
  75 }
  76
  77 func h(err error, b bool) {
  78         if err != nil && b {
  79                 return
  80         } else if err != nil {
  81                 panic(err)
  82         }
  83 }
  84
  85 func i(*int) error {
  86         for {
  87                 if err := g(); err != nil {
  88                         return err
  89                 }
  90         }
  91 }
  92
  93 func f4(x *X) {
  94         if x == nil {
  95                 panic(x)
  96         }
  97 }
  98
  99 func f5(x *X) {
 100         panic(nil) // want "panic with nil value"
 101 }
 102
 103 func f6(x *X) {
 104         var err error
 105         panic(err) // want "panic with nil value"
 106 }
 107
 108 func f7() {
 109         x, err := bad()
 110         if err != nil {
 111                 panic(0)
 112         }
 113         if x == nil {
 114                 panic(err) // want "panic with nil value"
 115         }
 116 }
 117
 118 func bad() (*X, error) {
 119         return nil, nil
 120 }
 121
 122 func f8() {
 123         var e error
 124         v, _ := e.(interface{})
 125         print(v)
 126 }
 127
 128 func f9(x interface {
 129         a()
 130         b()
 131         c()
 132 }) {
 133
 134         x.b() // we don't catch this panic because we don't have any facts yet
 135         xx := interface {
 136                 a()
 137                 b()
 138         }(x)
 139         if xx != nil {
 140                 return
 141         }
 142         x.c()  // want "nil dereference in dynamic method call"
 143         xx.b() // want "nil dereference in dynamic method call"
 144         xxx := interface{ a() }(xx)
 145         xxx.a() // want "nil dereference in dynamic method call"
 146
 147         if unknown() {
 148                 panic(x) // want "panic with nil value"
 149         }
 150         if unknown() {
 151                 panic(xx) // want "panic with nil value"
 152         }
 153         if unknown() {
 154                 panic(xxx) // want "panic with nil value"
 155         }
 156 }
 157
 158 func unknown() bool {
 159         return false
 160 }