.gitignore added

[dotfiles/.git] / .config / coc / extensions / coc-go-data / tools / pkg / mod / golang.org / x / tools@v0.1.1-0.20210319172145-bda8f5cee399 / cmd / guru / testdata / src / describe / main.go

diff --git a/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/cmd/guru/testdata/src/describe/main.go b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/cmd/guru/testdata/src/describe/main.go
new file mode 100644 (file)
index 0000000..dad321d
--- /dev/null
+++ b/.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/tools@v0.1.1-0.20210319172145-bda8f5cee399/cmd/guru/testdata/src/describe/main.go
@@ -0,0 +1,116 @@
+package describe // @describe pkgdecl "describe"
+
+// Tests of 'describe' query.
+// See go.tools/guru/guru_test.go for explanation.
+// See describe.golden for expected query results.
+
+// TODO(adonovan): more coverage of the (extensive) logic.
+
+import (
+       "lib"
+       "nosuchpkg"            // @describe badimport1 "nosuchpkg"
+       nosuchpkg2 "nosuchpkg" // @describe badimport2 "nosuchpkg2"
+       _ "unsafe"             // @describe unsafe "unsafe"
+)
+
+var _ nosuchpkg.T
+var _ nosuchpkg2.T
+
+type cake float64 // @describe type-ref-builtin "float64"
+
+const c = iota // @describe const-ref-iota "iota"
+
+const pi = 3.141     // @describe const-def-pi "pi"
+const pie = cake(pi) // @describe const-def-pie "pie"
+const _ = pi         // @describe const-ref-pi "pi"
+
+var global = new(string) // NB: ssa.Global is indirect, i.e. **string
+
+func main() { // @describe func-def-main "main"
+       // func objects
+       _ = main      // @describe func-ref-main "main"
+       _ = (*C).f    // @describe func-ref-*C.f "..C..f"
+       _ = D.f       // @describe func-ref-D.f "D.f"
+       _ = I.f       // @describe func-ref-I.f "I.f"
+       var d D       // @describe type-D "D"
+       var i I       // @describe type-I "I"
+       _ = d.f       // @describe func-ref-d.f "d.f"
+       _ = i.f       // @describe func-ref-i.f "i.f"
+       var slice []D // @describe slice-of-D "slice"
+
+       var dptr *D // @describe ptr-with-nonptr-methods "dptr"
+       _ = dptr
+
+       // var objects
+       anon := func() {
+               _ = d // @describe ref-lexical-d "d"
+       }
+       _ = anon   // @describe ref-anon "anon"
+       _ = global // @describe ref-global "global"
+
+       // SSA affords some local flow sensitivity.
+       var a, b int
+       var x = &a // @describe var-def-x-1 "x"
+       _ = x      // @describe var-ref-x-1 "x"
+       x = &b     // @describe var-def-x-2 "x"
+       _ = x      // @describe var-ref-x-2 "x"
+
+       i = new(C) // @describe var-ref-i-C "i"
+       if i != nil {
+               i = D{} // @describe var-ref-i-D "i"
+       }
+       print(i) // @describe var-ref-i "\\bi\\b"
+
+       // const objects
+       const localpi = 3.141     // @describe const-local-pi "localpi"
+       const localpie = cake(pi) // @describe const-local-pie "localpie"
+       const _ = localpi         // @describe const-ref-localpi "localpi"
+
+       // type objects
+       type T int      // @describe type-def-T "T"
+       var three T = 3 // @describe type-ref-T "T"
+       _ = three
+
+       print(1 + 2*3)        // @describe const-expr " 2.3"
+       print(real(1+2i) - 3) // @describe const-expr2 "real.*3"
+
+       m := map[string]*int{"a": &a}
+       mapval, _ := m["a"] // @describe map-lookup,ok "m..a.."
+       _ = mapval          // @describe mapval "mapval"
+       _ = m               // @describe m "m"
+
+       defer main() // @describe defer-stmt "defer"
+       go main()    // @describe go-stmt "go"
+
+       panic(3) // @describe builtin-ref-panic "panic"
+
+       var a2 int // @describe var-decl-stmt "var a2 int"
+       _ = a2
+       var _ int // @describe var-decl-stmt2 "var _ int"
+       var _ int // @describe var-def-blank "_"
+
+       var _ lib.Outer // @describe lib-outer "Outer"
+
+       var mmm map[C]D // @describe var-map-of-C-D "mmm"
+
+       d := newD().ThirdField // @describe field-access "ThirdField"
+
+       astCopy := ast
+       unknown() // @describe call-unknown "\\("
+}
+
+type I interface { // @describe def-iface-I "I"
+       f() // @describe def-imethod-I.f "f"
+}
+
+type C int
+type D struct {
+       Field        int
+       AnotherField string
+       ThirdField   C
+}
+
+func (c *C) f() {}
+func (d D) f()  {}
+
+func newD() D { return D{} }