.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.0.0-20201105173854-bc9fc8d8c4bc/go/analysis/passes/shadow/testdata/src/a/a.go

   1 // Copyright 2013 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // This file contains tests for the shadowed variable checker.
   6 // Some of these errors are caught by the compiler (shadowed return parameters for example)
   7 // but are nonetheless useful tests.
   8
   9 package a
  10
  11 import "os"
  12
  13 func ShadowRead(f *os.File, buf []byte) (err error) {
  14         var x int
  15         if f != nil {
  16                 err := 3 // OK - different type.
  17                 _ = err
  18         }
  19         if f != nil {
  20                 _, err := f.Read(buf) // want "declaration of .err. shadows declaration at line 13"
  21                 if err != nil {
  22                         return err
  23                 }
  24                 i := 3 // OK
  25                 _ = i
  26         }
  27         if f != nil {
  28                 x := one()               // want "declaration of .x. shadows declaration at line 14"
  29                 var _, err = f.Read(buf) // want "declaration of .err. shadows declaration at line 13"
  30                 if x == 1 && err != nil {
  31                         return err
  32                 }
  33         }
  34         for i := 0; i < 10; i++ {
  35                 i := i // OK: obviously intentional idiomatic redeclaration
  36                 go func() {
  37                         println(i)
  38                 }()
  39         }
  40         var shadowTemp interface{}
  41         switch shadowTemp := shadowTemp.(type) { // OK: obviously intentional idiomatic redeclaration
  42         case int:
  43                 println("OK")
  44                 _ = shadowTemp
  45         }
  46         if shadowTemp := shadowTemp; true { // OK: obviously intentional idiomatic redeclaration
  47                 var f *os.File // OK because f is not mentioned later in the function.
  48                 // The declaration of x is a shadow because x is mentioned below.
  49                 var x int // want "declaration of .x. shadows declaration at line 14"
  50                 _, _, _ = x, f, shadowTemp
  51         }
  52         // Use a couple of variables to trigger shadowing errors.
  53         _, _ = err, x
  54         return
  55 }
  56
  57 func one() int {
  58         return 1
  59 }
  60
  61 // Must not complain with an internal error for the
  62 // implicitly declared type switch variable v.
  63 func issue26725(x interface{}) int {
  64         switch v := x.(type) {
  65         case int, int32:
  66                 if v, ok := x.(int); ok {
  67                         return v
  68                 }
  69         case int64:
  70                 return int(v)
  71         }
  72         return 0
  73 }
  74
  75 // Verify that implicitly declared variables from
  76 // type switches are considered in shadowing analysis.
  77 func shadowTypeSwitch(a interface{}) {
  78         switch t := a.(type) {
  79         case int:
  80                 {
  81                         t := 0 // want "declaration of .t. shadows declaration at line 78"
  82                         _ = t
  83                 }
  84                 _ = t
  85         case uint:
  86                 {
  87                         t := uint(0) // OK because t is not mentioned later in this function
  88                         _ = t
  89                 }
  90         }
  91 }
  92
  93 func shadowBlock() {
  94         var a int
  95         {
  96                 var a = 3 // want "declaration of .a. shadows declaration at line 94"
  97                 _ = a
  98         }
  99         _ = a
 100 }