gopls/internal/test/marker/testdata/inlayhints/inlayhints.txt

-- flags --
-ignore_extra_diags

-- settings.json --
{
	"hints": {
		"assignVariableTypes": true,
		"compositeLiteralFields": true,
		"compositeLiteralTypes": true,
		"constantValues": true,
		"functionTypeParameters": true,
		"parameterNames": true,
		"rangeVariabletypes": true
	}
}

-- composite_literals.go --
package inlayHint //@inlayhints(complit)

import "fmt"

func fieldNames() {
	for _, c := range []struct {
		in, want string
	}{
		struct{ in, want string }{"Hello, world", "dlrow ,olleH"},
		{"Hello, 世界", "界世 ,olleH"},
		{"", ""},
	} {
		fmt.Println(c.in == c.want)
	}
}

func fieldNamesPointers() {
	for _, c := range []*struct {
		in, want string
	}{
		&struct{ in, want string }{"Hello, world", "dlrow ,olleH"},
		{"Hello, 世界", "界世 ,olleH"},
		{"", ""},
	} {
		fmt.Println(c.in == c.want)
	}
}

-- @complit --
package inlayHint //@inlayhints(complit)

import "fmt"

func fieldNames() {
	for _, c := range []struct {
		in, want string
	}{
		struct{ in, want string }{<in: >"Hello, world", <want: >"dlrow ,olleH"},
		<struct{in string; want string}>{<in: >"Hello, 世界", <want: >"界世 ,olleH"},
		<struct{in string; want string}>{<in: >"", <want: >""},
	} {
		fmt.Println(<a...: >c.in == c.want)
	}
}

func fieldNamesPointers() {
	for _, c := range []*struct {
		in, want string
	}{
		&struct{ in, want string }{<in: >"Hello, world", <want: >"dlrow ,olleH"},
		<&struct{in string; want string}>{<in: >"Hello, 世界", <want: >"界世 ,olleH"},
		<&struct{in string; want string}>{<in: >"", <want: >""},
	} {
		fmt.Println(<a...: >c.in == c.want)
	}
}

-- constant_values.go --
package inlayHint //@inlayhints(values)

const True = true

type Kind int

const (
	KindNone Kind = iota
	KindPrint
	KindPrintf
	KindErrorf
)

const (
	u         = iota * 4
	v float64 = iota * 42
	w         = iota * 42
)

const (
	a, b = 1, 2
	c, d
	e, f = 5 * 5, "hello" + "world"
	g, h
	i, j = true, f
)

// No hint
const (
	Int     = 3
	Float   = 3.14
	Bool    = true
	Rune    = '3'
	Complex = 2.7i
	String  = "Hello, world!"
)

var (
	varInt     = 3
	varFloat   = 3.14
	varBool    = true
	varRune    = '3' + '4'
	varComplex = 2.7i
	varString  = "Hello, world!"
)

-- @values --
package inlayHint //@inlayhints(values)

const True = true

type Kind int

const (
	KindNone Kind = iota< = 0>
	KindPrint< = 1>
	KindPrintf< = 2>
	KindErrorf< = 3>
)

const (
	u         = iota * 4< = 0>
	v float64 = iota * 42< = 42>
	w         = iota * 42< = 84>
)

const (
	a, b = 1, 2
	c, d< = 1, 2>
	e, f = 5 * 5, "hello" + "world"< = 25, "helloworld">
	g, h< = 25, "helloworld">
	i, j = true, f< = true, "helloworld">
)

// No hint
const (
	Int     = 3
	Float   = 3.14
	Bool    = true
	Rune    = '3'
	Complex = 2.7i
	String  = "Hello, world!"
)

var (
	varInt     = 3
	varFloat   = 3.14
	varBool    = true
	varRune    = '3' + '4'
	varComplex = 2.7i
	varString  = "Hello, world!"
)

-- parameter_names.go --
package inlayHint //@inlayhints(parameters)

import "fmt"

func hello(name string) string {
	return "Hello " + name
}

func helloWorld() string {
	return hello("World")
}

type foo struct{}

func (*foo) bar(baz string, qux int) int {
	if baz != "" {
		return qux + 1
	}
	return qux
}

func kase(foo int, bar bool, baz ...string) {
	fmt.Println(foo, bar, baz)
}

func kipp(foo string, bar, baz string) {
	fmt.Println(foo, bar, baz)
}

func plex(foo, bar string, baz string) {
	fmt.Println(foo, bar, baz)
}

func tars(foo string, bar, baz string) {
	fmt.Println(foo, bar, baz)
}

func foobar() {
	var x foo
	x.bar("", 1)
	kase(0, true, "c", "d", "e")
	kipp("a", "b", "c")
	plex("a", "b", "c")
	tars("a", "b", "c")
	foo, bar, baz := "a", "b", "c"
	kipp(foo, bar, baz)
	plex("a", bar, baz)
	tars(foo+foo, (bar), "c")

}

-- @parameters --
package inlayHint //@inlayhints(parameters)

import "fmt"

func hello(name string) string {
	return "Hello " + name
}

func helloWorld() string {
	return hello(<name: >"World")
}

type foo struct{}

func (*foo) bar(baz string, qux int) int {
	if baz != "" {
		return qux + 1
	}
	return qux
}

func kase(foo int, bar bool, baz ...string) {
	fmt.Println(<a...: >foo, bar, baz)
}

func kipp(foo string, bar, baz string) {
	fmt.Println(<a...: >foo, bar, baz)
}

func plex(foo, bar string, baz string) {
	fmt.Println(<a...: >foo, bar, baz)
}

func tars(foo string, bar, baz string) {
	fmt.Println(<a...: >foo, bar, baz)
}

func foobar() {
	var x foo
	x.bar(<baz: >"", <qux: >1)
	kase(<foo: >0, <bar: >true, <baz...: >"c", "d", "e")
	kipp(<foo: >"a", <bar: >"b", <baz: >"c")
	plex(<foo: >"a", <bar: >"b", <baz: >"c")
	tars(<foo: >"a", <bar: >"b", <baz: >"c")
	foo< string>, bar< string>, baz< string> := "a", "b", "c"
	kipp(foo, bar, baz)
	plex(<foo: >"a", bar, baz)
	tars(<foo: >foo+foo, <bar: >(bar), <baz: >"c")

}

-- type_params.go --
package inlayHint //@inlayhints(typeparams)

func main() {
	ints := map[string]int64{
		"first":  34,
		"second": 12,
	}

	floats := map[string]float64{
		"first":  35.98,
		"second": 26.99,
	}

	SumIntsOrFloats[string, int64](ints)
	SumIntsOrFloats[string, float64](floats)

	SumIntsOrFloats(ints)
	SumIntsOrFloats(floats)

	SumNumbers(ints)
	SumNumbers(floats)
}

type Number interface {
	int64 | float64
}

func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

func SumNumbers[K comparable, V Number](m map[K]V) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

-- @typeparams --
package inlayHint //@inlayhints(typeparams)

func main() {
	ints< map[string]int64> := map[string]int64{
		"first":  34,
		"second": 12,
	}

	floats< map[string]float64> := map[string]float64{
		"first":  35.98,
		"second": 26.99,
	}

	SumIntsOrFloats[string, int64](<m: >ints)
	SumIntsOrFloats[string, float64](<m: >floats)

	SumIntsOrFloats<[string, int64]>(<m: >ints)
	SumIntsOrFloats<[string, float64]>(<m: >floats)

	SumNumbers<[string, int64]>(<m: >ints)
	SumNumbers<[string, float64]>(<m: >floats)
}

type Number interface {
	int64 | float64
}

func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

func SumNumbers[K comparable, V Number](m map[K]V) V {
	var s V
	for _, v := range m {
		s += v
	}
	return s
}

-- variable_types.go --
package inlayHint //@inlayhints(vartypes)

func assignTypes() {
	i, j := 0, len([]string{})-1
	println(i, j)
}

func rangeTypes() {
	for k, v := range []string{} {
		println(k, v)
	}
}

func funcLitType() {
	myFunc := func(a string) string { return "" }
}

func compositeLitType() {
	foo := map[string]interface{}{"": ""}
}

-- @vartypes --
package inlayHint //@inlayhints(vartypes)

func assignTypes() {
	i< int>, j< int> := 0, len([]string{})-1
	println(i, j)
}

func rangeTypes() {
	for k, v := range []string{} {
		println(k, v)
	}
}

func funcLitType() {
	myFunc< func(a string) string> := func(a string) string { return "" }
}

func compositeLitType() {
	foo< map[string]interface{}> := map[string]interface{}{"": ""}
}