methodset_test.go

Documentation: go/types

		 1  // Copyright 2021 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package types_test
		 6  
		 7  import (
		 8  	"testing"
		 9  
		10  	"go/internal/typeparams"
		11  	. "go/types"
		12  )
		13  
		14  func TestNewMethodSet(t *testing.T) {
		15  	type method struct {
		16  		name		 string
		17  		index		[]int
		18  		indirect bool
		19  	}
		20  
		21  	// Tests are expressed src -> methods, for simplifying the composite literal.
		22  	// Should be kept in sync with TestLookupFieldOrMethod.
		23  	tests := map[string][]method{
		24  		// Named types
		25  		"var a T; type T struct{}; func (T) f() {}":	 {{"f", []int{0}, false}},
		26  		"var a *T; type T struct{}; func (T) f() {}":	{{"f", []int{0}, true}},
		27  		"var a T; type T struct{}; func (*T) f() {}":	{},
		28  		"var a *T; type T struct{}; func (*T) f() {}": {{"f", []int{0}, true}},
		29  
		30  		// Interfaces
		31  		"var a T; type T interface{ f() }":													 {{"f", []int{0}, true}},
		32  		"var a T1; type ( T1 T2; T2 interface{ f() } )":							{{"f", []int{0}, true}},
		33  		"var a T1; type ( T1 interface{ T2 }; T2 interface{ f() } )": {{"f", []int{0}, true}},
		34  
		35  		// Embedding
		36  		"var a struct{ E }; type E interface{ f() }":						{{"f", []int{0, 0}, true}},
		37  		"var a *struct{ E }; type E interface{ f() }":					 {{"f", []int{0, 0}, true}},
		38  		"var a struct{ E }; type E struct{}; func (E) f() {}":	 {{"f", []int{0, 0}, false}},
		39  		"var a struct{ *E }; type E struct{}; func (E) f() {}":	{{"f", []int{0, 0}, true}},
		40  		"var a struct{ E }; type E struct{}; func (*E) f() {}":	{},
		41  		"var a struct{ *E }; type E struct{}; func (*E) f() {}": {{"f", []int{0, 0}, true}},
		42  
		43  		// collisions
		44  		"var a struct{ E1; *E2 }; type ( E1 interface{ f() }; E2 struct{ f int })":						{},
		45  		"var a struct{ E1; *E2 }; type ( E1 struct{ f int }; E2 struct{} ); func (E2) f() {}": {},
		46  	}
		47  
		48  	genericTests := map[string][]method{
		49  		// By convention, look up a in the scope of "g"
		50  		"type C interface{ f() }; func g[T C](a T){}":											 {{"f", []int{0}, true}},
		51  		"type C interface{ f() }; func g[T C]() { var a T; _ = a }":				 {{"f", []int{0}, true}},
		52  		"type C interface{ f() }; func g[T C]() { var a struct{T}; _ = a }": {{"f", []int{0, 0}, true}},
		53  
		54  		// Issue #45639.
		55  		"type C interface{ f() }; func g[T C]() { type Y T; var a Y; _ = a }": {},
		56  	}
		57  
		58  	check := func(src string, methods []method, generic bool) {
		59  		pkgName := "p"
		60  		if generic {
		61  			// The generic_ prefix causes pkgFor to allow generic code.
		62  			pkgName = "generic_p"
		63  		}
		64  		pkg, err := pkgFor("test", "package "+pkgName+";"+src, nil)
		65  		if err != nil {
		66  			t.Errorf("%s: incorrect test case: %s", src, err)
		67  			return
		68  		}
		69  
		70  		scope := pkg.Scope()
		71  		if generic {
		72  			fn := pkg.Scope().Lookup("g").(*Func)
		73  			scope = fn.Scope()
		74  		}
		75  		obj := scope.Lookup("a")
		76  		if obj == nil {
		77  			t.Errorf("%s: incorrect test case - no object a", src)
		78  			return
		79  		}
		80  
		81  		ms := NewMethodSet(obj.Type())
		82  		if got, want := ms.Len(), len(methods); got != want {
		83  			t.Errorf("%s: got %d methods, want %d", src, got, want)
		84  			return
		85  		}
		86  		for i, m := range methods {
		87  			sel := ms.At(i)
		88  			if got, want := sel.Obj().Name(), m.name; got != want {
		89  				t.Errorf("%s [method %d]: got name = %q at, want %q", src, i, got, want)
		90  			}
		91  			if got, want := sel.Index(), m.index; !sameSlice(got, want) {
		92  				t.Errorf("%s [method %d]: got index = %v, want %v", src, i, got, want)
		93  			}
		94  			if got, want := sel.Indirect(), m.indirect; got != want {
		95  				t.Errorf("%s [method %d]: got indirect = %v, want %v", src, i, got, want)
		96  			}
		97  		}
		98  	}
		99  
	 100  	for src, methods := range tests {
	 101  		check(src, methods, false)
	 102  	}
	 103  
	 104  	if typeparams.Enabled {
	 105  		for src, methods := range genericTests {
	 106  			check(src, methods, true)
	 107  		}
	 108  	}
	 109  }
	 110
View as plain text