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