.config/coc/extensions/coc-go-data/tools/pkg/mod/honnef.co/go/tools@v0.1.1/analysis/facts/typedness/testdata/src/Typedness/Typedness.go

   1 package pkg
   2
   3 import (
   4         "errors"
   5         "os/exec"
   6 )
   7
   8 type T struct{ x *int }
   9
  10 func notAStub() {}
  11
  12 func fn1() *int             { return nil }
  13 func fn2() (int, *int, int) { return 0, nil, 0 }
  14
  15 func fn3() (out1 int, out2 error) { notAStub(); return 0, nil }
  16 func fn4() error                  { notAStub(); return nil }
  17
  18 func gen2() (out1 interface{}) { // want gen2:`always typed: 00000001`
  19         return 1
  20 }
  21
  22 func gen3() (out1 interface{}) { // want gen3:`always typed: 00000001`
  23         // flag, always returns a typed value
  24         m := map[int]*int{}
  25         return m[0]
  26 }
  27
  28 func gen4() (out1 int, out2 interface{}, out3 *int) { // want gen4:`always typed: 00000010`
  29         // flag ret[1], always a typed value
  30         m := map[int]*int{}
  31         return 0, m[0], nil
  32 }
  33
  34 func gen5() (out1 interface{}) { // want gen5:`always typed: 00000001`
  35         // flag, propagate gen3
  36         return gen3()
  37 }
  38
  39 func gen6(b bool) interface{} {
  40         // don't flag, sometimes returns untyped nil
  41         if b {
  42                 m := map[int]*int{}
  43                 return m[0]
  44         } else {
  45                 return nil
  46         }
  47 }
  48
  49 func gen7() (out1 interface{}) { // want gen7:`always typed: 00000001`
  50         // flag, always returns a typed value
  51         return fn1()
  52 }
  53
  54 func gen8(x *int) (out1 interface{}) { // want gen8:`always typed: 00000001`
  55         // flag
  56         if x == nil {
  57                 return x
  58         }
  59         return x
  60 }
  61
  62 func gen9() (out1 interface{}) { // want gen9:`always typed: 00000001`
  63         // flag
  64         var x *int
  65         return x
  66 }
  67
  68 func gen10() (out1 interface{}) { // want gen10:`always typed: 00000001`
  69         // flag
  70         var x *int
  71         if x == nil {
  72                 return x
  73         }
  74         return errors.New("")
  75 }
  76
  77 func gen11() interface{} {
  78         // don't flag, we sometimes return untyped nil
  79         if true {
  80                 return nil
  81         } else {
  82                 return (*int)(nil)
  83         }
  84 }
  85
  86 func gen12(b bool) (out1 interface{}) { // want gen12:`always typed: 00000001`
  87         // flag, all branches return typed nils
  88         var x interface{}
  89         if b {
  90                 x = (*int)(nil)
  91         } else {
  92                 x = (*string)(nil)
  93         }
  94         return x
  95 }
  96
  97 func gen13() (out1 interface{}) { // want gen13:`always typed: 00000001`
  98         // flag, always returns a typed value
  99         _, x, _ := fn2()
 100         return x
 101 }
 102
 103 func gen14(ch chan *int) (out1 interface{}) { // want gen14:`always typed: 00000001`
 104         // flag
 105         return <-ch
 106 }
 107
 108 func gen15() (out1 interface{}) { // want gen15:`always typed: 00000001`
 109         // flag
 110         t := &T{}
 111         return t.x
 112 }
 113
 114 var g *int = new(int)
 115
 116 func gen16() (out1 interface{}) { // want gen16:`always typed: 00000001`
 117         return g
 118 }
 119
 120 func gen17(x interface{}) interface{} {
 121         // don't flag
 122         if x != nil {
 123                 return x
 124         }
 125         return x
 126 }
 127
 128 func gen18() (int, error) {
 129         // don't flag
 130         _, err := fn3()
 131         if err != nil {
 132                 return 0, errors.New("yo")
 133         }
 134         return 0, err
 135 }
 136
 137 func gen19() (out interface{}) {
 138         // don't flag
 139         if true {
 140                 return (*int)(nil)
 141         }
 142         return
 143 }
 144
 145 func gen20() (out interface{}) {
 146         // don't flag
 147         if true {
 148                 return (*int)(nil)
 149         }
 150         return
 151 }
 152
 153 func gen21() error {
 154         if false {
 155                 return (*exec.Error)(nil)
 156         }
 157         return fn4()
 158 }
 159
 160 func gen22() interface{} {
 161         // don't flag, propagate gen6
 162         return gen6(false)
 163 }
 164
 165 func gen23() interface{} {
 166         return gen24()
 167 }
 168
 169 func gen24() interface{} {
 170         return gen23()
 171 }
 172
 173 func gen25(x interface{}) (out1 interface{}) { // want gen25:`always typed: 00000001`
 174         return x.(interface{})
 175 }
 176
 177 func gen26(x interface{}) interface{} {
 178         v, _ := x.(interface{})
 179         return v
 180 }
 181
 182 func gen27(x interface{}) (out1 interface{}) {
 183         defer recover()
 184         out1 = x.(interface{})
 185         return out1
 186 }
 187
 188 type Error struct{}
 189
 190 func (*Error) Error() string { return "" }
 191
 192 func gen28() (out1 interface{}) { // want gen28:`always typed: 00000001`
 193         x := new(Error)
 194         var y error = x
 195         return y
 196 }
 197
 198 func gen29() (out1 interface{}) { // want gen29:`always typed: 00000001`
 199         var x *Error
 200         var y error = x
 201         return y
 202 }
 203
 204 func gen30() (out1, out2 interface{}) { // want gen30:`always typed: 00000011`
 205         return gen29(), gen28()
 206 }
 207
 208 func gen31() (out1 interface{}) { // want gen31:`always typed: 00000001`
 209         a, _ := gen30()
 210         return a
 211 }
 212
 213 func gen32() (out1 interface{}) { // want gen32:`always typed: 00000001`
 214         _, b := gen30()
 215         return b
 216 }
 217
 218 func gen33() (out1 interface{}) { // want gen33:`always typed: 00000001`
 219         a, b := gen30()
 220         _ = a
 221         return b
 222 }
 223
 224 func gen34() (out1, out2 interface{}) { // want gen34:`always typed: 00000010`
 225         return nil, 1
 226 }
 227
 228 func gen35() (out1 interface{}) {
 229         a, _ := gen34()
 230         return a
 231 }
 232
 233 func gen36() (out1 interface{}) { // want gen36:`always typed: 00000001`
 234         _, b := gen34()
 235         return b
 236 }