| package snippets |
| |
| import ( |
| "bytes" |
| "context" |
| "go/ast" |
| "net/http" |
| "sort" |
| |
| "golang.org/lsptests/foo" |
| ) |
| |
| func _() { |
| []int{} //@item(litIntSlice, "[]int{}", "", "var") |
| &[]int{} //@item(litIntSliceAddr, "&[]int{}", "", "var") |
| make([]int, 0) //@item(makeIntSlice, "make([]int, 0)", "", "func") |
| |
| var _ *[]int = in //@snippet(" //", litIntSliceAddr, "&[]int{$0\\}", "&[]int{$0\\}") |
| var _ **[]int = in //@complete(" //") |
| |
| var slice []int |
| slice = i //@snippet(" //", litIntSlice, "[]int{$0\\}", "[]int{$0\\}") |
| slice = m //@snippet(" //", makeIntSlice, "make([]int, ${1:})", "make([]int, ${1:0})") |
| } |
| |
| func _() { |
| type namedInt []int |
| |
| namedInt{} //@item(litNamedSlice, "namedInt{}", "", "var") |
| make(namedInt, 0) //@item(makeNamedSlice, "make(namedInt, 0)", "", "func") |
| |
| var namedSlice namedInt |
| namedSlice = n //@snippet(" //", litNamedSlice, "namedInt{$0\\}", "namedInt{$0\\}") |
| namedSlice = m //@snippet(" //", makeNamedSlice, "make(namedInt, ${1:})", "make(namedInt, ${1:0})") |
| } |
| |
| func _() { |
| make(chan int) //@item(makeChan, "make(chan int)", "", "func") |
| |
| var ch chan int |
| ch = m //@snippet(" //", makeChan, "make(chan int)", "make(chan int)") |
| } |
| |
| func _() { |
| map[string]struct{}{} //@item(litMap, "map[string]struct{}{}", "", "var") |
| make(map[string]struct{}) //@item(makeMap, "make(map[string]struct{})", "", "func") |
| |
| var m map[string]struct{} |
| m = m //@snippet(" //", litMap, "map[string]struct{\\}{$0\\}", "map[string]struct{\\}{$0\\}") |
| m = m //@snippet(" //", makeMap, "make(map[string]struct{\\})", "make(map[string]struct{\\})") |
| |
| struct{}{} //@item(litEmptyStruct, "struct{}{}", "", "var") |
| |
| m["hi"] = s //@snippet(" //", litEmptyStruct, "struct{\\}{\\}", "struct{\\}{\\}") |
| } |
| |
| func _() { |
| type myStruct struct{ i int } //@item(myStructType, "myStruct", "struct{...}", "struct") |
| |
| myStruct{} //@item(litStruct, "myStruct{}", "", "var") |
| &myStruct{} //@item(litStructPtr, "&myStruct{}", "", "var") |
| |
| var ms myStruct |
| ms = m //@snippet(" //", litStruct, "myStruct{$0\\}", "myStruct{$0\\}") |
| |
| var msPtr *myStruct |
| msPtr = m //@snippet(" //", litStructPtr, "&myStruct{$0\\}", "&myStruct{$0\\}") |
| |
| msPtr = &m //@snippet(" //", litStruct, "myStruct{$0\\}", "myStruct{$0\\}") |
| |
| type myStructCopy struct { i int } //@item(myStructCopyType, "myStructCopy", "struct{...}", "struct") |
| |
| // Don't offer literal completion for convertible structs. |
| ms = myStruct //@complete(" //", litStruct, myStructType, myStructCopyType) |
| } |
| |
| type myImpl struct{} |
| |
| func (myImpl) foo() {} |
| |
| func (*myImpl) bar() {} |
| |
| type myBasicImpl string |
| |
| func (myBasicImpl) foo() {} |
| |
| func _() { |
| type myIntf interface { |
| foo() |
| } |
| |
| myImpl{} //@item(litImpl, "myImpl{}", "", "var") |
| |
| var mi myIntf |
| mi = m //@snippet(" //", litImpl, "myImpl{\\}", "myImpl{\\}") |
| |
| myBasicImpl() //@item(litBasicImpl, "myBasicImpl()", "string", "var") |
| |
| mi = m //@snippet(" //", litBasicImpl, "myBasicImpl($0)", "myBasicImpl($0)") |
| |
| // only satisfied by pointer to myImpl |
| type myPtrIntf interface { |
| bar() |
| } |
| |
| &myImpl{} //@item(litImplPtr, "&myImpl{}", "", "var") |
| |
| var mpi myPtrIntf |
| mpi = m //@snippet(" //", litImplPtr, "&myImpl{\\}", "&myImpl{\\}") |
| } |
| |
| func _() { |
| var s struct{ i []int } //@item(litSliceField, "i", "[]int", "field") |
| var foo []int |
| // no literal completions after selector |
| foo = s.i //@complete(" //", litSliceField) |
| } |
| |
| func _() { |
| type myStruct struct{ i int } //@item(litMyStructType, "myStruct", "struct{...}", "struct") |
| myStruct{} //@item(litMyStruct, "myStruct{}", "", "var") |
| |
| foo := func(s string, args ...myStruct) {} |
| // Don't give literal slice candidate for variadic arg. |
| // Do give literal candidates for variadic element. |
| foo("", myStruct) //@complete(")", litMyStruct, litMyStructType) |
| } |
| |
| func _() { |
| Buffer{} //@item(litBuffer, "Buffer{}", "", "var") |
| |
| var b *bytes.Buffer |
| b = bytes.Bu //@snippet(" //", litBuffer, "Buffer{\\}", "Buffer{\\}") |
| } |
| |
| func _() { |
| _ = "func(...) {}" //@item(litFunc, "func(...) {}", "", "var") |
| |
| sort.Slice(nil, fun) //@complete(")", litFunc),snippet(")", litFunc, "func(i, j int) bool {$0\\}", "func(i, j int) bool {$0\\}") |
| |
| http.HandleFunc("", f) //@snippet(")", litFunc, "func(w http.ResponseWriter, r *http.Request) {$0\\}", "func(${1:w} http.ResponseWriter, ${2:r} *http.Request) {$0\\}") |
| |
| // no literal "func" completions |
| http.Handle("", fun) //@complete(")") |
| |
| http.HandlerFunc() //@item(handlerFunc, "http.HandlerFunc()", "", "var") |
| http.Handle("", h) //@snippet(")", handlerFunc, "http.HandlerFunc($0)", "http.HandlerFunc($0)") |
| http.Handle("", http.HandlerFunc()) //@snippet("))", litFunc, "func(w http.ResponseWriter, r *http.Request) {$0\\}", "func(${1:w} http.ResponseWriter, ${2:r} *http.Request) {$0\\}") |
| |
| var namedReturn func(s string) (b bool) |
| namedReturn = f //@snippet(" //", litFunc, "func(s string) (b bool) {$0\\}", "func(s string) (b bool) {$0\\}") |
| |
| var multiReturn func() (bool, int) |
| multiReturn = f //@snippet(" //", litFunc, "func() (bool, int) {$0\\}", "func() (bool, int) {$0\\}") |
| |
| var multiNamedReturn func() (b bool, i int) |
| multiNamedReturn = f //@snippet(" //", litFunc, "func() (b bool, i int) {$0\\}", "func() (b bool, i int) {$0\\}") |
| |
| var duplicateParams func(myImpl, int, myImpl) |
| duplicateParams = f //@snippet(" //", litFunc, "func(mi1 myImpl, i int, mi2 myImpl) {$0\\}", "func(${1:mi1} myImpl, ${2:i} int, ${3:mi2} myImpl) {$0\\}") |
| |
| type aliasImpl = myImpl |
| var aliasParams func(aliasImpl) aliasImpl |
| aliasParams = f //@snippet(" //", litFunc, "func(ai aliasImpl) aliasImpl {$0\\}", "func(${1:ai} aliasImpl) aliasImpl {$0\\}") |
| |
| const two = 2 |
| var builtinTypes func([]int, [two]bool, map[string]string, struct{ i int }, interface{ foo() }, <-chan int) |
| builtinTypes = f //@snippet(" //", litFunc, "func(i1 []int, b [two]bool, m map[string]string, s struct{ i int \\}, i2 interface{ foo() \\}, c <-chan int) {$0\\}", "func(${1:i1} []int, ${2:b} [two]bool, ${3:m} map[string]string, ${4:s} struct{ i int \\}, ${5:i2} interface{ foo() \\}, ${6:c} <-chan int) {$0\\}") |
| |
| var _ func(ast.Node) = f //@snippet(" //", litFunc, "func(n ast.Node) {$0\\}", "func(${1:n} ast.Node) {$0\\}") |
| var _ func(error) = f //@snippet(" //", litFunc, "func(err error) {$0\\}", "func(${1:err} error) {$0\\}") |
| var _ func(context.Context) = f //@snippet(" //", litFunc, "func(ctx context.Context) {$0\\}", "func(${1:ctx} context.Context) {$0\\}") |
| |
| type context struct {} |
| var _ func(context) = f //@snippet(" //", litFunc, "func(ctx context) {$0\\}", "func(${1:ctx} context) {$0\\}") |
| } |
| |
| func _() { |
| StructFoo{} //@item(litStructFoo, "StructFoo{}", "struct{...}", "struct") |
| |
| var sfp *foo.StructFoo |
| // Don't insert the "&" before "StructFoo{}". |
| sfp = foo.Str //@snippet(" //", litStructFoo, "StructFoo{$0\\}", "StructFoo{$0\\}") |
| |
| var sf foo.StructFoo |
| sf = foo.Str //@snippet(" //", litStructFoo, "StructFoo{$0\\}", "StructFoo{$0\\}") |
| sf = foo. //@snippet(" //", litStructFoo, "StructFoo{$0\\}", "StructFoo{$0\\}") |
| } |
| |
| func _() { |
| float64() //@item(litFloat64, "float64()", "float64", "var") |
| |
| // don't complete to "&float64()" |
| var _ *float64 = float64 //@complete(" //") |
| |
| var f float64 |
| f = fl //@complete(" //", litFloat64),snippet(" //", litFloat64, "float64($0)", "float64($0)") |
| |
| type myInt int |
| myInt() //@item(litMyInt, "myInt()", "", "var") |
| |
| var mi myInt |
| mi = my //@snippet(" //", litMyInt, "myInt($0)", "myInt($0)") |
| } |
| |
| func _() { |
| type ptrStruct struct { |
| p *ptrStruct |
| } |
| |
| ptrStruct{} //@item(litPtrStruct, "ptrStruct{}", "", "var") |
| |
| ptrStruct{ |
| p: &ptrSt, //@rank(",", litPtrStruct) |
| } |
| |
| &ptrStruct{} //@item(litPtrStructPtr, "&ptrStruct{}", "", "var") |
| |
| &ptrStruct{ |
| p: ptrSt, //@rank(",", litPtrStructPtr) |
| } |
| } |
| |
| func _() { |
| f := func(...[]int) {} |
| f() //@snippet(")", litIntSlice, "[]int{$0\\}", "[]int{$0\\}") |
| } |
| |
| |
| func _() { |
| // don't complete to "untyped int()" |
| []int{}[untyped] //@complete("] //") |
| } |