github.com/powerman/golang-tools@v0.1.11-0.20220410185822-5ad214d8d803/go/analysis/passes/composite/testdata/src/a/a.go (about)

     1  // Copyright 2012 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 the test for untagged struct literals.
     6  
     7  package a
     8  
     9  import (
    10  	"flag"
    11  	"go/scanner"
    12  	"go/token"
    13  	"image"
    14  	"unicode"
    15  )
    16  
    17  var Okay1 = []string{
    18  	"Name",
    19  	"Usage",
    20  	"DefValue",
    21  }
    22  
    23  var Okay2 = map[string]bool{
    24  	"Name":     true,
    25  	"Usage":    true,
    26  	"DefValue": true,
    27  }
    28  
    29  var Okay3 = struct {
    30  	X string
    31  	Y string
    32  	Z string
    33  }{
    34  	"Name",
    35  	"Usage",
    36  	"DefValue",
    37  }
    38  
    39  var Okay4 = []struct {
    40  	A int
    41  	B int
    42  }{
    43  	{1, 2},
    44  	{3, 4},
    45  }
    46  
    47  type MyStruct struct {
    48  	X string
    49  	Y string
    50  	Z string
    51  }
    52  
    53  var Okay5 = &MyStruct{
    54  	"Name",
    55  	"Usage",
    56  	"DefValue",
    57  }
    58  
    59  var Okay6 = []MyStruct{
    60  	{"foo", "bar", "baz"},
    61  	{"aa", "bb", "cc"},
    62  }
    63  
    64  var Okay7 = []*MyStruct{
    65  	{"foo", "bar", "baz"},
    66  	{"aa", "bb", "cc"},
    67  }
    68  
    69  // Testing is awkward because we need to reference things from a separate package
    70  // to trigger the warnings.
    71  
    72  var goodStructLiteral = flag.Flag{
    73  	Name:  "Name",
    74  	Usage: "Usage",
    75  }
    76  var badStructLiteral = flag.Flag{ // want "unkeyed fields"
    77  	"Name",
    78  	"Usage",
    79  	nil, // Value
    80  	"DefValue",
    81  }
    82  
    83  var delta [3]rune
    84  
    85  // SpecialCase is a named slice of CaseRange to test issue 9171.
    86  var goodNamedSliceLiteral = unicode.SpecialCase{
    87  	{Lo: 1, Hi: 2, Delta: delta},
    88  	unicode.CaseRange{Lo: 1, Hi: 2, Delta: delta},
    89  }
    90  var badNamedSliceLiteral = unicode.SpecialCase{
    91  	{1, 2, delta},                  // want "unkeyed fields"
    92  	unicode.CaseRange{1, 2, delta}, // want "unkeyed fields"
    93  }
    94  
    95  // ErrorList is a named slice, so no warnings should be emitted.
    96  var goodScannerErrorList = scanner.ErrorList{
    97  	&scanner.Error{Msg: "foobar"},
    98  }
    99  var badScannerErrorList = scanner.ErrorList{
   100  	&scanner.Error{token.Position{}, "foobar"}, // want "unkeyed fields"
   101  }
   102  
   103  // Check whitelisted structs: if vet is run with --compositewhitelist=false,
   104  // this line triggers an error.
   105  var whitelistedPoint = image.Point{1, 2}
   106  
   107  // Do not check type from unknown package.
   108  // See issue 15408.
   109  var unknownPkgVar = unicode.NoSuchType{"foo", "bar"}
   110  
   111  // A named pointer slice of CaseRange to test issue 23539. In
   112  // particular, we're interested in how some slice elements omit their
   113  // type.
   114  var goodNamedPointerSliceLiteral = []*unicode.CaseRange{
   115  	{Lo: 1, Hi: 2},
   116  	&unicode.CaseRange{Lo: 1, Hi: 2},
   117  }
   118  var badNamedPointerSliceLiteral = []*unicode.CaseRange{
   119  	{1, 2, delta},                   // want "unkeyed fields"
   120  	&unicode.CaseRange{1, 2, delta}, // want "unkeyed fields"
   121  }
   122  
   123  // unicode.Range16 is whitelisted, so there'll be no vet error
   124  var range16 = unicode.Range16{0xfdd0, 0xfdef, 1}
   125  
   126  // unicode.Range32 is whitelisted, so there'll be no vet error
   127  var range32 = unicode.Range32{0x1fffe, 0x1ffff, 1}