gopls/internal/lsp/source/completion: unimport check gop overload

gopls/internal/goxls/testdata/bar/bar.go.in

@@ -0,0 +1,47 @@
+// +build go1.11
+
+package bar
+
+import (
+	"golang.org/lsptests/foo" //@item(foo, "foo", "\"golang.org/lsptests/foo\"", "package")
+)
+
+func helper(i foo.IntFoo) {} //@item(helper, "helper", "func(i foo.IntFoo)", "func")
+
+func _() {
+	help //@complete("l", helper)
+	_ = foo.StructFoo{} //@complete("S", IntFoo, StructFoo)
+}
+
+// Bar is a function.
+func Bar() { //@item(Bar, "Bar", "func()", "func", "Bar is a function.")
+	foo.Foo()        //@complete("F", Foo, IntFoo, StructFoo)
+	var _ foo.IntFoo //@complete("I", IntFoo, StructFoo)
+	foo.()           //@complete("(", Foo, IntFoo, StructFoo)
+}
+
+func _() {
+	var Valentine int //@item(Valentine, "Valentine", "int", "var")
+
+	_ = foo.StructFoo{
+		Valu //@complete(" //", Value)
+	}
+  	_ = foo.StructFoo{
+		Va        //@complete("a", Value, Valentine)
+	}
+	_ = foo.StructFoo{
+		Value: 5, //@complete("a", Value)
+	}
+	_ = foo.StructFoo{
+		//@complete("", Value, Valentine, foo, helper, Bar)
+	}
+	_ = foo.StructFoo{
+		Value: Valen //@complete("le", Valentine)
+	}
+	_ = foo.StructFoo{
+		Value:       //@complete(" //", Valentine, foo, helper, Bar)
+	}
+	_ = foo.StructFoo{
+		Value:       //@complete(" ", Valentine, foo, helper, Bar)
+	}
+}

gopls/internal/goxls/testdata/baz/baz.go.in

@@ -0,0 +1,33 @@
+// +build go1.11
+
+package baz
+
+import (
+	"golang.org/lsptests/bar"
+
+	f "golang.org/lsptests/foo"
+)
+
+var FooStruct f.StructFoo
+
+func Baz() {
+	defer bar.Bar() //@complete("B", Bar)
+	// TODO(rstambler): Test completion here.
+	defer bar.B
+	var x f.IntFoo  //@complete("n", IntFoo),typdef("x", IntFoo)
+	bar.Bar()       //@complete("B", Bar)
+}
+
+func _() {
+	bob := f.StructFoo{Value: 5}
+	if x := bob. //@complete(" //", Value)
+	switch true == false {
+		case true:
+			if x := bob. //@complete(" //", Value)
+		case false:
+	}
+	if x := bob.Va //@complete("a", Value)
+	switch true == true {
+		default:
+	}
+}

gopls/internal/goxls/testdata/foo/foo.gop → gopls/internal/goxls/testdata/foo/foo.go

@@ -23,9 +23,8 @@ func _() {
 	shadowed := 123
 	{
 		shadowed := "hi" //@item(shadowed, "shadowed", "string", "var")
-		_ = shadowed  //@complete("a", shadowed)
+		sha              //@complete("a", shadowed)
 	}
-	_ = shadowed
 }
 
 type IntFoo int //@item(IntFoo, "IntFoo", "int", "type")

gopls/internal/goxls/testdata/overload/c/add.gop

@@ -0,0 +1,10 @@
+package c
+
+func Add = (
+	func(a, b int) int {
+		return a + b
+	}
+	func(a, b string) string {
+		return a + b
+	}
+)

gopls/internal/goxls/testdata/overload/c/method.gop

@@ -0,0 +1,19 @@
+package c
+
+type Foo struct {
+}
+
+func (a *Foo) MulInt(b int) *Foo { //@mark(c_foo_mulInt,"MulInt")
+	println "mulInt"
+	return a
+}
+
+func (a *Foo) MulFoo(b *Foo) *Foo { //@mark(c_foo_mulFoo,"MulFoo")
+	println "mulFoo"
+	return a
+}
+
+func (Foo).Mul = (
+	(Foo).MulInt
+	(Foo).MulFoo
+)

gopls/internal/goxls/testdata/overload/c/mul.gop

@@ -0,0 +1,14 @@
+package c
+
+func MulInt(a, b int) int { //@mark(c_mulInt,"MulInt")
+	return a * b
+}
+
+func MulFloat(a, b float64) float64 { //@mark(c_mulFloat,"MulFloat")
+	return a * b
+}
+
+func Mul = (
+	MulInt
+	MulFloat
+)

gopls/internal/goxls/testdata/overload/d/utils.go

@@ -0,0 +1,33 @@
+package d
+
+const GopPackage = true
+
+type Foo struct {
+}
+
+const Gopo_Foo_Mul = ".MulInt,.MulFoo"
+const Gopo_Mul = "MulInt,MulFloat"
+
+func Add__0(a int, b int) int { //@mark(d_add__0,"Add__0")
+	return a + b
+}
+
+func Add__1(a string, b string) string { //@mark(d_add__1,"Add__1")
+	return a + b
+}
+
+func (a *Foo) MulInt(b int) *Foo { //@mark(d_foo_mulInt,"MulInt")
+	return a
+}
+
+func (a *Foo) MulFoo(b *Foo) *Foo { //@mark(d_foo_mulFoo,"MulFoo")
+	return a
+}
+
+func MulInt(a int, b int) int { //@mark(d_mulInt,"MulInt")
+	return a * b
+}
+
+func MulFloat(a float64, b float64) float64 { //@mark(d_mulFloat,"MulFloat")
+	return a * b
+}

gopls/internal/goxls/testdata/overload/overload.gop

@@ -1,6 +1,8 @@
 import (
 	"golang.org/lsptests/overload/a"
 	"golang.org/lsptests/overload/b"
+	"golang.org/lsptests/overload/c"
+	"golang.org/lsptests/overload/d"
 )
 
 Demo          //@godef("Demo",Demo__0)
@@ -30,3 +32,23 @@ b.demo "hello"  //@godef("demo",b_demo__3)
 var n2 b.N
 n2.add 100     //@godef("add",b_add__0)
 n2.add "hello" //@godef("add",b_add__1)
+
+c.mul 100, 200   //@godef("mul",c_mulInt)
+c.mul 100.1, 200 //@godef("mul",c_mulFloat)
+
+c.add 100, 200
+c.add "hello", "world"
+
+var foo c.Foo
+foo.mul 100        //@godef("mul",c_foo_mulInt)
+foo.mul new(c.Foo) //@godef("mul",c_foo_mulFoo)
+
+d.mul 100, 200   //@godef("mul",d_mulInt)
+d.mul 100.1, 200 //@godef("mul",d_mulFloat)
+
+d.add 100, 200         //@godef("add",d_add__0)
+d.add "hello", "world" //@godef("add",d_add__1)
+
+var foo2 d.Foo
+foo2.mul 100        //@godef("mul",d_foo_mulInt)
+foo2.mul new(d.Foo) //@godef("mul",d_foo_mulFoo)

gopls/internal/goxls/testdata/overload/overload.gop.golden

@@ -108,6 +108,102 @@ func b.GopDemo()
 ```
 
 [`b.GopDemo` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/b#GopDemo)
+-- c_add-hoverdef --
+```go
+func c.Add__1(a string, b string) string
+```
+
+[`c.Add__1` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Add__1)
+-- c_add__0-hoverdef --
+```go
+func c.Add__0(a int, b int) int
+```
+
+[`c.Add__0` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Add__0)
+-- c_foo_mulFoo-hoverdef --
+```go
+func (*c.Foo).MulFoo(b *c.Foo) *c.Foo
+```
+
+[`(c.Foo).MulFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Foo.MulFoo)
+-- c_foo_mulInt-hoverdef --
+```go
+func (*c.Foo).MulInt(b int) *c.Foo
+```
+
+[`(c.Foo).MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Foo.MulInt)
+-- c_foo_mul__0-hoverdef --
+```go
+func (*c.Foo).MulInt(b int) *c.Foo
+```
+
+[`(c.Foo).MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Foo.MulInt)
+-- c_foo_mul__1-hoverdef --
+```go
+func (*c.Foo).MulFoo(b *c.Foo) *c.Foo
+```
+
+[`(c.Foo).MulFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#Foo.MulFoo)
+-- c_mulFloat-hoverdef --
+```go
+func c.MulFloat(a float64, b float64) float64
+```
+
+[`c.MulFloat` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#MulFloat)
+-- c_mulInt-hoverdef --
+```go
+func c.MulInt(a int, b int) int
+```
+
+[`c.MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#MulInt)
+-- c_mul__0-hoverdef --
+```go
+func c.MulInt(a int, b int) int
+```
+
+[`c.MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#MulInt)
+-- c_mul__1-hoverdef --
+```go
+func c.MulFloat(a float64, b float64) float64
+```
+
+[`c.MulFloat` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/c#MulFloat)
+-- d_add__0-hoverdef --
+```go
+func d.Add__0(a int, b int) int
+```
+
+[`d.Add__0` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#Add__0)
+-- d_add__1-hoverdef --
+```go
+func d.Add__1(a string, b string) string
+```
+
+[`d.Add__1` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#Add__1)
+-- d_foo_mulFoo-hoverdef --
+```go
+func (*d.Foo).MulFoo(b *d.Foo) *d.Foo
+```
+
+[`(d.Foo).MulFoo` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#Foo.MulFoo)
+-- d_foo_mulInt-hoverdef --
+```go
+func (*d.Foo).MulInt(b int) *d.Foo
+```
+
+[`(d.Foo).MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#Foo.MulInt)
+-- d_mulFloat-hoverdef --
+```go
+func d.MulFloat(a float64, b float64) float64
+```
+
+[`d.MulFloat` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#MulFloat)
+-- d_mulInt-hoverdef --
+```go
+func d.MulInt(a int, b int) int
+```
+
+[`d.MulInt` on pkg.go.dev](https://pkg.go.dev/golang.org/lsptests/overload/d#MulInt)
 -- pkg_add__0-hoverdef --
 ```go
 func (*pkg.N).Add__0(a int)

gopls/internal/goxls/testdata/overload/overload_rank.gop.in

@@ -3,15 +3,15 @@ import (
 )
 
 func _() {
-	demo //@item(apkgDemo1, "demo", "Go+ overload funcs\n\n- func()\n- func(n int) int\n- func(n1 int, n2 int)\n- func(s ...string)", "func")
-	Demo //@item(apkgDemo2, "Demo", "Go+ overload funcs\n\n- func()\n- func(n int) int\n- func(n1 int, n2 int)\n- func(s ...string)", "func")
+	demo //@item(apkgDemo1, "demo", "Go+ overload func\n\n- func()\n- func(n int) int\n- func(n1 int, n2 int)\n- func(s ...string)", "func")
+	Demo //@item(apkgDemo2, "Demo", "Go+ overload func\n\n- func()\n- func(n int) int\n- func(n1 int, n2 int)\n- func(s ...string)", "func")
 
 	a.demo //@rank(" //", apkgDemo1, apkgDemo2)
 }
 
 func _() {
-	add //@item(apkgAdd1, "add", "Go+ overload funcs\n\n- func(a int)\n- func(a ...string)", "method")
-	Add //@item(apkgAdd2, "Add", "Go+ overload funcs\n\n- func(a int)\n- func(a ...string)", "method")
+	add //@item(apkgAdd1, "add", "Go+ overload func\n\n- func(a int)\n- func(a ...string)", "method")
+	Add //@item(apkgAdd2, "Add", "Go+ overload func\n\n- func(a int)\n- func(a ...string)", "method")
 
 	var n N
 	n.add //@rank(" //", apkgAdd1, apkgAdd2)

gopls/internal/goxls/testdata/overload/overload_unimport.gop.in

@@ -0,0 +1,24 @@
+func _() {
+	c.add //@unimported("add", c_add_unimported)
+	c.mul //@unimported("mul", c_mul_unimported)
+	c.mulInt //@unimported("mulInt", c_mulInt_unimported)
+	c.MulInt //@unimported("MulInt", c_MulInt_unimported)
+}
+
+func _() {
+	d.add //@unimported("add", d_add_unimported)
+	d.mul //@unimported("mul", d_mul_unimported)
+	d.mulInt //@unimported("mulInt", d_mulInt_unimported)
+	d.MulInt //@unimported("MulInt", d_MulInt_unimported)
+}
+
+
+/* c.add */ //@item(c_add_unimported, "add", "Go+ overload func\n\nfunc (from \"golang.org/lsptests/overload/c\")", "func")
+/* c.mul */ //@item(c_mul_unimported, "mul", "Go+ overload func\n\nfunc (from \"golang.org/lsptests/overload/c\")", "func")
+/* c.mulInt */ //@item(c_mulInt_unimported, "mulInt", "Go+ alias func\n\nfunc (from \"golang.org/lsptests/overload/c\")", "func")
+/* c.MulInt */ //@item(c_MulInt_unimported, "MulInt", "func (from \"golang.org/lsptests/overload/c\")", "func")
+
+/* d.add */ //@item(d_add_unimported, "add", "Go+ overload func\n\nfunc (from \"golang.org/lsptests/overload/d\")", "func")
+/* d.mul */ //@item(d_mul_unimported, "mul", "Go+ overload func\n\nfunc (from \"golang.org/lsptests/overload/d\")", "func")
+/* d.mulInt */ //@item(d_mulInt_unimported, "mulInt", "Go+ alias func\n\nfunc (from \"golang.org/lsptests/overload/d\")", "func")
+/* d.MulInt */ //@item(d_MulInt_unimported, "MulInt", "func (from \"golang.org/lsptests/overload/d\")", "func")

gopls/internal/goxls/testdata/summary.txt.golden

@@ -1,9 +1,9 @@
 -- summary --
 CallHierarchyCount = 0
 CodeLensCount = 4
-CompletionsCount = 18
+CompletionsCount = 36
 CompletionSnippetCount = 12
-UnimportedCompletionsCount = 0
+UnimportedCompletionsCount = 8
 DeepCompletionsCount = 0
 FuzzyCompletionsCount = 1
 RankedCompletionsCount = 15
@@ -13,8 +13,8 @@ FoldingRangesCount = 0
 SemanticTokenCount = 0
 SuggestedFixCount = 0
 MethodExtractionCount = 0
-DefinitionsCount = 23
-TypeDefinitionsCount = 1
+DefinitionsCount = 33
+TypeDefinitionsCount = 2
 HighlightsCount = 0
 InlayHintsCount = 0
 RenamesCount = 0