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

   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}