.config/coc/extensions/coc-go-data/tools/pkg/mod/honnef.co/go/tools@v0.1.1/staticcheck/testdata/src/CheckTypedNilInterface/CheckTypedNilInterface.go

   1 package pkg
   2
   3 import (
   4         "errors"
   5         "os/exec"
   6 )
   7
   8 type T struct{ x *int }
   9
  10 func fn1() *int             { return nil }
  11 func fn2() (int, *int, int) { return 0, nil, 0 }
  12
  13 func fn3() (int, error) { return 0, nil }
  14 func fn4() error        { return nil }
  15
  16 func gen1() interface{} {
  17         // don't flag, returning a concrete value
  18         return 0
  19 }
  20
  21 func gen2() interface{} {
  22         // don't flag, returning a concrete value
  23         return &T{}
  24 }
  25
  26 func gen3() interface{} {
  27         // flag, always returns a typed value
  28         m := map[int]*int{}
  29         return m[0]
  30 }
  31
  32 func gen4() (int, interface{}, *int) {
  33         // flag ret[1], always a typed value
  34         m := map[int]*int{}
  35         return 0, m[0], nil
  36 }
  37
  38 func gen5() interface{} {
  39         // flag, propagate gen3
  40         return gen3()
  41 }
  42
  43 func gen6(b bool) interface{} {
  44         // don't flag, sometimes returns untyped nil
  45         if b {
  46                 m := map[int]*int{}
  47                 return m[0]
  48         } else {
  49                 return nil
  50         }
  51 }
  52
  53 func gen7() interface{} {
  54         // flag, always returns a typed value
  55         return fn1()
  56 }
  57
  58 func gen8(x *int) interface{} {
  59         // flag
  60         if x == nil {
  61                 return x
  62         }
  63         return x
  64 }
  65
  66 func gen9() interface{} {
  67         // flag
  68         var x *int
  69         return x
  70 }
  71
  72 func gen10() interface{} {
  73         // flag
  74         var x *int
  75         if x == nil {
  76                 return x
  77         }
  78         return errors.New("")
  79
  80         // This is a tricky one. we should flag this, because it never
  81         // returns a nil error, but if errors.New could return untyped
  82         // nils, then we shouldn't flag it. we need to consider the
  83         // implementation of the called function.
  84 }
  85
  86 func gen11() interface{} {
  87         // don't flag, we sometimes return untyped nil
  88         if true {
  89                 return nil
  90         } else {
  91                 return (*int)(nil)
  92         }
  93 }
  94
  95 func gen12(b bool) interface{} {
  96         // flag, all branches return typed nils
  97         var x interface{}
  98         if b {
  99                 x = (*int)(nil)
 100         } else {
 101                 x = (*string)(nil)
 102         }
 103         return x
 104 }
 105
 106 func gen13() interface{} {
 107         // flag, always returns a typed value
 108         _, x, _ := fn2()
 109         return x
 110 }
 111
 112 func gen14(ch chan *int) interface{} {
 113         // flag
 114         return <-ch
 115 }
 116
 117 func gen15() interface{} {
 118         // flag
 119         t := &T{}
 120         return t.x
 121 }
 122
 123 var g *int = new(int)
 124
 125 func gen16() interface{} {
 126         // don't flag. returning a global is akin to returning &T{}.
 127         return g
 128 }
 129
 130 func gen17(x interface{}) interface{} {
 131         // don't flag
 132         if x != nil {
 133                 return x
 134         }
 135         return x
 136 }
 137
 138 func gen18() (int, error) {
 139         // don't flag
 140         _, err := fn3()
 141         if err != nil {
 142                 return 0, errors.New("yo")
 143         }
 144         return 0, err
 145 }
 146
 147 func gen19() (out interface{}) {
 148         // don't flag
 149         if true {
 150                 return (*int)(nil)
 151         }
 152         return
 153 }
 154
 155 func gen20() (out interface{}) {
 156         // don't flag
 157         if true {
 158                 return (*int)(nil)
 159         }
 160         return
 161 }
 162
 163 func gen21() error {
 164         if false {
 165                 return (*exec.Error)(nil)
 166         }
 167         return fn4()
 168 }
 169
 170 func gen22() interface{} {
 171         if true {
 172                 return g
 173         }
 174         return (*int)(nil)
 175 }
 176
 177 func test() {
 178         _ = gen1() == nil
 179         _ = gen2() == nil
 180         _ = gen3() == nil // want `never true`
 181         {
 182                 _, r2, r3 := gen4()
 183                 _ = r2 == nil // want `never true`
 184                 _ = r3 == nil
 185         }
 186         _ = gen5() == nil // want `never true`
 187         _ = gen6(false) == nil
 188         _ = gen7() == nil    // want `never true`
 189         _ = gen8(nil) == nil // want `never true`
 190         _ = gen9() == nil    // want `never true`
 191         _ = gen10() == nil   // want `never true`
 192         _ = gen11() == nil
 193         _ = gen12(true) == nil // want `never true`
 194         _ = gen13() == nil     // want `never true`
 195         _ = gen14(nil) == nil  // want `never true`
 196         _ = gen15() == nil     // want `never true`
 197         _ = gen16() == nil
 198         _ = gen17(nil) == nil
 199         {
 200                 _, r2 := gen18()
 201                 _ = r2 == nil
 202         }
 203         _ = gen19() == nil
 204         _ = gen20() == nil
 205         _ = gen21() == nil
 206         _ = gen22() == nil // want `never true`
 207 }