mirror of
https://github.com/golang/go
synced 2024-11-18 20:24:41 -07:00
5a76f03bc7
In cases like: var foo []io.Writer var buf *bytes.Buffer foo = append(foo, <>) we weren't giving "buf" a good score. When comparing the candidate type *bytes.Buffer to the (variadic) expected type []io.Writer we were turning the candidate type into []*bytes.Buffer. However, of course, []*bytes.Buffer is not assignable to []io.Writer, so the types didn't match. Now we instead turn the expected type []io.Writer into io.Writer and compare to *bytes.Buffer. I fixed the @rank test note to check that the candidates' scores are strictly decreasing. Previously it would allow candidates with the same score if they happened to be in the right order. This made it easier to right a test for this issue, but also uncovered an issue with untyped completion logic. I fixed it to do the untyped constant check if _either_ the expected or candidate type is untyped (previously it required the candidate type to be untyped). Fixes golang/go#35625. Change-Id: I9a837d6a781669cb7a2f1d6d3d7f360c85be49eb Reviewed-on: https://go-review.googlesource.com/c/tools/+/207518 Reviewed-by: Rebecca Stambler <rstambler@golang.org> Run-TryBot: Rebecca Stambler <rstambler@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org>
126 lines
2.9 KiB
Go
126 lines
2.9 KiB
Go
// Copyright 2019 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package deep
|
|
|
|
import "context"
|
|
|
|
type deepA struct {
|
|
b deepB //@item(deepBField, "b", "deepB", "field")
|
|
}
|
|
|
|
type deepB struct {
|
|
}
|
|
|
|
func wantsDeepB(deepB) {}
|
|
|
|
func _() {
|
|
var a deepA //@item(deepAVar, "a", "deepA", "var")
|
|
a.b //@item(deepABField, "a.b", "deepB", "field")
|
|
wantsDeepB(a) //@deep(")", deepABField, deepAVar)
|
|
|
|
deepA{a} //@snippet("}", deepABField, "a.b", "a.b")
|
|
}
|
|
|
|
func wantsContext(context.Context) {}
|
|
|
|
func _() {
|
|
context.Background() //@item(ctxBackground, "context.Background", "func() context.Context", "func", "Background returns a non-nil, empty Context.")
|
|
context.TODO() //@item(ctxTODO, "context.TODO", "func() context.Context", "func", "TODO returns a non-nil, empty Context.")
|
|
|
|
wantsContext(c) //@rank(")", ctxBackground),rank(")", ctxTODO)
|
|
}
|
|
|
|
func _() {
|
|
// deepCircle is circular.
|
|
type deepCircle struct {
|
|
*deepCircle
|
|
}
|
|
var circle deepCircle //@item(deepCircle, "circle", "deepCircle", "var")
|
|
circle.deepCircle //@item(deepCircleField, "circle.deepCircle", "*deepCircle", "field", "deepCircle is circular.")
|
|
var _ deepCircle = circ //@deep(" //", deepCircle, deepCircleField)
|
|
}
|
|
|
|
func _() {
|
|
type deepEmbedC struct {
|
|
}
|
|
type deepEmbedB struct {
|
|
deepEmbedC
|
|
}
|
|
type deepEmbedA struct {
|
|
deepEmbedB
|
|
}
|
|
|
|
wantsC := func(deepEmbedC) {}
|
|
|
|
var a deepEmbedA //@item(deepEmbedA, "a", "deepEmbedA", "var")
|
|
a.deepEmbedB //@item(deepEmbedB, "a.deepEmbedB", "deepEmbedB", "field")
|
|
a.deepEmbedC //@item(deepEmbedC, "a.deepEmbedC", "deepEmbedC", "field")
|
|
wantsC(a) //@deep(")", deepEmbedC, deepEmbedA, deepEmbedB)
|
|
}
|
|
|
|
func _() {
|
|
type nested struct {
|
|
a int
|
|
n *nested //@item(deepNestedField, "n", "*nested", "field")
|
|
}
|
|
|
|
nested{
|
|
a: 123, //@deep(" //", deepNestedField)
|
|
}
|
|
}
|
|
|
|
func _() {
|
|
var a struct {
|
|
b struct {
|
|
c int
|
|
}
|
|
d int
|
|
}
|
|
|
|
a.d //@item(deepAD, "a.d", "int", "field")
|
|
a.b.c //@item(deepABC, "a.b.c", "int", "field")
|
|
a.b //@item(deepAB, "a.b", "struct{...}", "field")
|
|
a //@item(deepA, "a", "struct{...}", "var")
|
|
|
|
// "a.d" should be ranked above the deeper "a.b.c"
|
|
var i int
|
|
i = a //@deep(" //", deepAD, deepABC, deepA, deepAB)
|
|
}
|
|
|
|
type foo struct {
|
|
b bar
|
|
}
|
|
|
|
func (f foo) bar() bar {
|
|
return f.b
|
|
}
|
|
|
|
func (f foo) barPtr() *bar {
|
|
return &f.b
|
|
}
|
|
|
|
type bar struct{}
|
|
|
|
func (b bar) valueReceiver() int {
|
|
return 0
|
|
}
|
|
|
|
func (b *bar) ptrReceiver() int {
|
|
return 0
|
|
}
|
|
|
|
func _() {
|
|
var (
|
|
i int
|
|
f foo
|
|
)
|
|
|
|
f.bar().valueReceiver //@item(deepBarValue, "f.bar().valueReceiver", "func() int", "method")
|
|
f.barPtr().valueReceiver //@item(deepBarPtrValue, "f.barPtr().valueReceiver", "func() int", "method")
|
|
f.barPtr().ptrReceiver //@item(deepBarPtrPtr, "f.barPtr().ptrReceiver", "func() int", "method")
|
|
|
|
i = fb //@fuzzy(" //", deepBarValue, deepBarPtrPtr, deepBarPtrValue)
|
|
}
|