This test exercises miscellaneous definition and hover requests.
Its size expectations assume a 64-bit machine.
-- go.mod --
module mod.com
go 1.16
-- flags --
-skip_goarch=386,arm
-- a.go --
package a //@loc(aPackage, re"package (a)"),hover(aPackage, aPackage, aPackage)
var (
// x is a variable.
x string //@loc(x, "x"),hover(x, x, hoverx)
)
// Constant block. When I hover on h, I should see this comment.
const (
// When I hover on g, I should see this comment.
g = 1 //@hover("g", "g", hoverg)
h = 2 //@hover("h", "h", hoverh)
)
// z is a variable too.
var z string //@loc(z, "z"),hover(z, z, hoverz)
func AStuff() { //@loc(AStuff, "AStuff")
x := 5
Random2(x) //@def("dom2", Random2)
Random() //@def("()", Random)
}
type H interface { //@loc(H, "H")
Goodbye()
}
type I interface { //@loc(I, "I")
B()
J
}
type J interface { //@loc(J, "J")
Hello()
}
func _() {
// 1st type declaration block
type (
a struct { //@hover("a", "a", hoverDeclBlocka)
x string
}
)
// 2nd type declaration block
type (
// b has a comment
b struct{} //@hover("b", "b", hoverDeclBlockb)
)
// 3rd type declaration block
type (
// c is a struct
c struct { //@hover("c", "c", hoverDeclBlockc)
f string
}
d string //@hover("d", "d", hoverDeclBlockd)
)
type (
e struct { //@hover("e", "e", hoverDeclBlocke)
f float64
} // e has a comment
)
}
var (
hh H //@hover("H", "H", hoverH)
ii I //@hover("I", "I", hoverI)
jj J //@hover("J", "J", hoverJ)
)
-- a_test.go --
package a
import (
"testing"
)
func TestA(t *testing.T) { //@hover("TestA", "TestA", hoverTestA)
}
-- random.go --
package a
func Random() int { //@loc(Random, "Random")
y := 6 + 7
return y
}
func Random2(y int) int { //@loc(Random2, "Random2"),loc(RandomParamY, "y")
return y //@def("y", RandomParamY),hover("y", "y", hovery)
}
type Pos struct {
x, y int //@loc(PosX, "x"),loc(PosY, "y")
}
// Typ has a comment. Its fields do not.
type Typ struct{ field string } //@loc(TypField, "field")
func _() {
x := &Typ{}
_ = x.field //@def("field", TypField),hover("field", "field", hoverfield)
}
func (p *Pos) Sum() int { //@loc(PosSum, "Sum")
return p.x + p.y //@hover("x", "x", hoverpx)
}
func _() {
var p Pos
_ = p.Sum() //@def("()", PosSum),hover("()", `Sum`, hoverSum)
}
-- @aPackage --
-- @hoverDeclBlocka --
```go
type a struct { // size=16 (0x10)
x string
}
```
1st type declaration block
-- @hoverDeclBlockb --
```go
type b struct{} // size=0
```
b has a comment
-- @hoverDeclBlockc --
```go
type c struct { // size=16 (0x10)
f string
}
```
c is a struct
-- @hoverDeclBlockd --
```go
type d string // size=16 (0x10)
```
3rd type declaration block
-- @hoverDeclBlocke --
```go
type e struct { // size=8
f float64
}
```
e has a comment
-- @hoverH --
```go
type H interface {
Goodbye()
}
```
[`a.H` on pkg.go.dev](https://pkg.go.dev/mod.com#H)
-- @hoverI --
```go
type I interface {
B()
J
}
```
```go
func (J) Hello()
```
[`a.I` on pkg.go.dev](https://pkg.go.dev/mod.com#I)
-- @hoverJ --
```go
type J interface {
Hello()
}
```
[`a.J` on pkg.go.dev](https://pkg.go.dev/mod.com#J)
-- @hoverSum --
```go
func (p *Pos) Sum() int
```
[`(a.Pos).Sum` on pkg.go.dev](https://pkg.go.dev/mod.com#Pos.Sum)
-- @hoverTestA --
```go
func TestA(t *testing.T)
```
-- @hoverfield --
```go
field field string
```
-- @hoverg --
```go
const g untyped int = 1
```
When I hover on g, I should see this comment.
-- @hoverh --
```go
const h untyped int = 2
```
Constant block. When I hover on h, I should see this comment.
-- @hoverpx --
```go
field x int
```
@loc(PosX, "x"),loc(PosY, "y")
-- @hoverx --
```go
var x string
```
x is a variable.
-- @hovery --
```go
var y int
```
-- @hoverz --
```go
var z string
```
z is a variable too.