.gitignore added

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.1.1-0.20210319172145-bda8f5cee399 / go / ssa / testdata / valueforexpr.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/go/ssa/testdata/valueforexpr.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/go/ssa/testdata/valueforexpr.go
new file mode 100644 (file)
index 0000000..da76f13
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/go/ssa/testdata/valueforexpr.go
@@ -0,0 +1,153 @@
+// +build ignore
+
+package main
+
+// This file is the input to TestValueForExpr in source_test.go, which
+// ensures that each expression e immediately following a /*@kind*/(x)
+// annotation, when passed to Function.ValueForExpr(e), returns a
+// non-nil Value of the same type as e and of kind 'kind'.
+
+func f(spilled, unspilled int) {
+       _ = /*@UnOp*/ (spilled)
+       _ = /*@Parameter*/ (unspilled)
+       _ = /*@nil*/ (1 + 2) // (constant)
+       i := 0
+
+       f := func() (int, int) { return 0, 0 }
+
+       /*@Call*/
+       (print( /*@BinOp*/ (i + 1)))
+       _, _ = /*@Call*/ (f())
+       ch := /*@MakeChan*/ (make(chan int))
+       /*@UnOp*/ (<-ch)
+       x := /*@UnOp*/ (<-ch)
+       _ = x
+       select {
+       case /*@Extract*/ (<-ch):
+       case x := /*@Extract*/ (<-ch):
+               _ = x
+       }
+       defer /*@Function*/ (func() {
+       })()
+       go /*@Function*/ (func() {
+       })()
+       y := 0
+       if true && /*@BinOp*/ (bool(y > 0)) {
+               y = 1
+       }
+       _ = /*@Phi*/ (y)
+       map1 := /*@MakeMap*/ (make(map[string]string))
+       _ = map1
+       _ = /*@Slice*/ (make([]int, 0))
+       _ = /*@MakeClosure*/ (func() { print(spilled) })
+
+       sl := []int{}
+       _ = /*@Slice*/ (sl[:0])
+
+       _ = /*@nil*/ (new(int)) // optimized away
+       tmp := /*@Alloc*/ (new(int))
+       _ = tmp
+       var iface interface{}
+       _ = /*@TypeAssert*/ (iface.(int))
+       _ = /*@UnOp*/ (sl[0])
+       _ = /*@IndexAddr*/ (&sl[0])
+       _ = /*@Index*/ ([2]int{}[0])
+       var p *int
+       _ = /*@UnOp*/ (*p)
+
+       _ = /*@UnOp*/ (global)
+       /*@UnOp*/ (global)[""] = ""
+       /*@Global*/ (global) = map[string]string{}
+
+       var local t
+       /*UnOp*/ (local.x) = 1
+
+       // Exercise corner-cases of lvalues vs rvalues.
+       type N *N
+       var n N
+       /*@UnOp*/ (n) = /*@UnOp*/ (n)
+       /*@ChangeType*/ (n) = /*@Alloc*/ (&n)
+       /*@UnOp*/ (n) = /*@UnOp*/ (*n)
+       /*@UnOp*/ (n) = /*@UnOp*/ (**n)
+}
+
+func complit() {
+       // Composite literals.
+       // We get different results for
+       // - composite literal as value (e.g. operand to print)
+       // - composite literal initializer for addressable value
+       // - composite literal value assigned to blank var
+
+       // 1. Slices
+       print( /*@Slice*/ ([]int{}))
+       print( /*@Alloc*/ (&[]int{}))
+       print(& /*@Slice*/ ([]int{}))
+
+       sl1 := /*@Slice*/ ([]int{})
+       sl2 := /*@Alloc*/ (&[]int{})
+       sl3 := & /*@Slice*/ ([]int{})
+       _, _, _ = sl1, sl2, sl3
+
+       _ = /*@Slice*/ ([]int{})
+       _ = /*@nil*/ (& /*@Slice*/ ([]int{})) // & optimized away
+       _ = & /*@Slice*/ ([]int{})
+
+       // 2. Arrays
+       print( /*@UnOp*/ ([1]int{}))
+       print( /*@Alloc*/ (&[1]int{}))
+       print(& /*@Alloc*/ ([1]int{}))
+
+       arr1 := /*@Alloc*/ ([1]int{})
+       arr2 := /*@Alloc*/ (&[1]int{})
+       arr3 := & /*@Alloc*/ ([1]int{})
+       _, _, _ = arr1, arr2, arr3
+
+       _ = /*@UnOp*/ ([1]int{})
+       _ = /*@Alloc*/ (& /*@Alloc*/ ([1]int{}))
+       _ = & /*@Alloc*/ ([1]int{})
+
+       // 3. Maps
+       type M map[int]int
+       print( /*@MakeMap*/ (M{}))
+       print( /*@Alloc*/ (&M{}))
+       print(& /*@MakeMap*/ (M{}))
+
+       m1 := /*@MakeMap*/ (M{})
+       m2 := /*@Alloc*/ (&M{})
+       m3 := & /*@MakeMap*/ (M{})
+       _, _, _ = m1, m2, m3
+
+       _ = /*@MakeMap*/ (M{})
+       _ = /*@nil*/ (& /*@MakeMap*/ (M{})) // & optimized away
+       _ = & /*@MakeMap*/ (M{})
+
+       // 4. Structs
+       print( /*@UnOp*/ (struct{}{}))
+       print( /*@Alloc*/ (&struct{}{}))
+       print(& /*@Alloc*/ (struct{}{}))
+
+       s1 := /*@Alloc*/ (struct{}{})
+       s2 := /*@Alloc*/ (&struct{}{})
+       s3 := & /*@Alloc*/ (struct{}{})
+       _, _, _ = s1, s2, s3
+
+       _ = /*@UnOp*/ (struct{}{})
+       _ = /*@Alloc*/ (& /*@Alloc*/ (struct{}{}))
+       _ = & /*@Alloc*/ (struct{}{})
+}
+
+type t struct{ x int }
+
+// Ensure we can locate methods of named types.
+func (t) f(param int) {
+       _ = /*@Parameter*/ (param)
+}
+
+// Ensure we can locate init functions.
+func init() {
+       m := /*@MakeMap*/ (make(map[string]string))
+       _ = m
+}
+
+// Ensure we can locate variables in initializer expressions.
+var global = /*@MakeMap*/ (make(map[string]string))