diff options
Diffstat (limited to 'vendor/golang.org/x/tools/go/types')
8 files changed, 0 insertions, 850 deletions
diff --git a/vendor/golang.org/x/tools/go/types/typeutil/example_test.go b/vendor/golang.org/x/tools/go/types/typeutil/example_test.go deleted file mode 100644 index 86c4d44..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/example_test.go +++ /dev/null @@ -1,67 +0,0 @@ -// Copyright 2014 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 typeutil_test - -import ( - "fmt" - "go/ast" - "go/parser" - "go/token" - "go/types" - "sort" - - "golang.org/x/tools/go/types/typeutil" -) - -func ExampleMap() { - const source = `package P - -var X []string -var Y []string - -const p, q = 1.0, 2.0 - -func f(offset int32) (value byte, ok bool) -func g(rune) (uint8, bool) -` - - // Parse and type-check the package. - fset := token.NewFileSet() - f, err := parser.ParseFile(fset, "P.go", source, 0) - if err != nil { - panic(err) - } - pkg, err := new(types.Config).Check("P", fset, []*ast.File{f}, nil) - if err != nil { - panic(err) - } - - scope := pkg.Scope() - - // Group names of package-level objects by their type. - var namesByType typeutil.Map // value is []string - for _, name := range scope.Names() { - T := scope.Lookup(name).Type() - - names, _ := namesByType.At(T).([]string) - names = append(names, name) - namesByType.Set(T, names) - } - - // Format, sort, and print the map entries. - var lines []string - namesByType.Iterate(func(T types.Type, names interface{}) { - lines = append(lines, fmt.Sprintf("%s %s", names, T)) - }) - sort.Strings(lines) - for _, line := range lines { - fmt.Println(line) - } - - // Output: - // [X Y] []string - // [f g] func(offset int32) (value byte, ok bool) - // [p q] untyped float -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports.go b/vendor/golang.org/x/tools/go/types/typeutil/imports.go deleted file mode 100644 index 9c441db..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/imports.go +++ /dev/null @@ -1,31 +0,0 @@ -// Copyright 2014 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 typeutil - -import "go/types" - -// Dependencies returns all dependencies of the specified packages. -// -// Dependent packages appear in topological order: if package P imports -// package Q, Q appears earlier than P in the result. -// The algorithm follows import statements in the order they -// appear in the source code, so the result is a total order. -// -func Dependencies(pkgs ...*types.Package) []*types.Package { - var result []*types.Package - seen := make(map[*types.Package]bool) - var visit func(pkgs []*types.Package) - visit = func(pkgs []*types.Package) { - for _, p := range pkgs { - if !seen[p] { - seen[p] = true - visit(p.Imports()) - result = append(result, p) - } - } - } - visit(pkgs) - return result -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go b/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go deleted file mode 100644 index c8ef6d6..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/imports_test.go +++ /dev/null @@ -1,80 +0,0 @@ -// Copyright 2014 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 typeutil_test - -import ( - "fmt" - "go/ast" - "go/parser" - "go/token" - "go/types" - "testing" - - "golang.org/x/tools/go/types/typeutil" -) - -type closure map[string]*types.Package - -func (c closure) Import(path string) (*types.Package, error) { return c[path], nil } - -func TestDependencies(t *testing.T) { - packages := make(map[string]*types.Package) - conf := types.Config{ - Importer: closure(packages), - } - fset := token.NewFileSet() - - // All edges go to the right. - // /--D--B--A - // F \_C_/ - // \__E_/ - for i, content := range []string{ - `package a`, - `package c; import (_ "a")`, - `package b; import (_ "a")`, - `package e; import (_ "c")`, - `package d; import (_ "b"; _ "c")`, - `package f; import (_ "d"; _ "e")`, - } { - f, err := parser.ParseFile(fset, fmt.Sprintf("%d.go", i), content, 0) - if err != nil { - t.Fatal(err) - } - pkg, err := conf.Check(f.Name.Name, fset, []*ast.File{f}, nil) - if err != nil { - t.Fatal(err) - } - packages[pkg.Path()] = pkg - } - - for _, test := range []struct { - roots, want string - }{ - {"a", "a"}, - {"b", "ab"}, - {"c", "ac"}, - {"d", "abcd"}, - {"e", "ace"}, - {"f", "abcdef"}, - - {"be", "abce"}, - {"eb", "aceb"}, - {"de", "abcde"}, - {"ed", "acebd"}, - {"ef", "acebdf"}, - } { - var pkgs []*types.Package - for _, r := range test.roots { - pkgs = append(pkgs, packages[string(r)]) - } - var got string - for _, p := range typeutil.Dependencies(pkgs...) { - got += p.Path() - } - if got != test.want { - t.Errorf("Dependencies(%q) = %q, want %q", test.roots, got, test.want) - } - } -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map.go b/vendor/golang.org/x/tools/go/types/typeutil/map.go deleted file mode 100644 index c7f7545..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/map.go +++ /dev/null @@ -1,313 +0,0 @@ -// Copyright 2014 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 typeutil defines various utilities for types, such as Map, -// a mapping from types.Type to interface{} values. -package typeutil // import "golang.org/x/tools/go/types/typeutil" - -import ( - "bytes" - "fmt" - "go/types" - "reflect" -) - -// Map is a hash-table-based mapping from types (types.Type) to -// arbitrary interface{} values. The concrete types that implement -// the Type interface are pointers. Since they are not canonicalized, -// == cannot be used to check for equivalence, and thus we cannot -// simply use a Go map. -// -// Just as with map[K]V, a nil *Map is a valid empty map. -// -// Not thread-safe. -// -type Map struct { - hasher Hasher // shared by many Maps - table map[uint32][]entry // maps hash to bucket; entry.key==nil means unused - length int // number of map entries -} - -// entry is an entry (key/value association) in a hash bucket. -type entry struct { - key types.Type - value interface{} -} - -// SetHasher sets the hasher used by Map. -// -// All Hashers are functionally equivalent but contain internal state -// used to cache the results of hashing previously seen types. -// -// A single Hasher created by MakeHasher() may be shared among many -// Maps. This is recommended if the instances have many keys in -// common, as it will amortize the cost of hash computation. -// -// A Hasher may grow without bound as new types are seen. Even when a -// type is deleted from the map, the Hasher never shrinks, since other -// types in the map may reference the deleted type indirectly. -// -// Hashers are not thread-safe, and read-only operations such as -// Map.Lookup require updates to the hasher, so a full Mutex lock (not a -// read-lock) is require around all Map operations if a shared -// hasher is accessed from multiple threads. -// -// If SetHasher is not called, the Map will create a private hasher at -// the first call to Insert. -// -func (m *Map) SetHasher(hasher Hasher) { - m.hasher = hasher -} - -// Delete removes the entry with the given key, if any. -// It returns true if the entry was found. -// -func (m *Map) Delete(key types.Type) bool { - if m != nil && m.table != nil { - hash := m.hasher.Hash(key) - bucket := m.table[hash] - for i, e := range bucket { - if e.key != nil && types.Identical(key, e.key) { - // We can't compact the bucket as it - // would disturb iterators. - bucket[i] = entry{} - m.length-- - return true - } - } - } - return false -} - -// At returns the map entry for the given key. -// The result is nil if the entry is not present. -// -func (m *Map) At(key types.Type) interface{} { - if m != nil && m.table != nil { - for _, e := range m.table[m.hasher.Hash(key)] { - if e.key != nil && types.Identical(key, e.key) { - return e.value - } - } - } - return nil -} - -// Set sets the map entry for key to val, -// and returns the previous entry, if any. -func (m *Map) Set(key types.Type, value interface{}) (prev interface{}) { - if m.table != nil { - hash := m.hasher.Hash(key) - bucket := m.table[hash] - var hole *entry - for i, e := range bucket { - if e.key == nil { - hole = &bucket[i] - } else if types.Identical(key, e.key) { - prev = e.value - bucket[i].value = value - return - } - } - - if hole != nil { - *hole = entry{key, value} // overwrite deleted entry - } else { - m.table[hash] = append(bucket, entry{key, value}) - } - } else { - if m.hasher.memo == nil { - m.hasher = MakeHasher() - } - hash := m.hasher.Hash(key) - m.table = map[uint32][]entry{hash: {entry{key, value}}} - } - - m.length++ - return -} - -// Len returns the number of map entries. -func (m *Map) Len() int { - if m != nil { - return m.length - } - return 0 -} - -// Iterate calls function f on each entry in the map in unspecified order. -// -// If f should mutate the map, Iterate provides the same guarantees as -// Go maps: if f deletes a map entry that Iterate has not yet reached, -// f will not be invoked for it, but if f inserts a map entry that -// Iterate has not yet reached, whether or not f will be invoked for -// it is unspecified. -// -func (m *Map) Iterate(f func(key types.Type, value interface{})) { - if m != nil { - for _, bucket := range m.table { - for _, e := range bucket { - if e.key != nil { - f(e.key, e.value) - } - } - } - } -} - -// Keys returns a new slice containing the set of map keys. -// The order is unspecified. -func (m *Map) Keys() []types.Type { - keys := make([]types.Type, 0, m.Len()) - m.Iterate(func(key types.Type, _ interface{}) { - keys = append(keys, key) - }) - return keys -} - -func (m *Map) toString(values bool) string { - if m == nil { - return "{}" - } - var buf bytes.Buffer - fmt.Fprint(&buf, "{") - sep := "" - m.Iterate(func(key types.Type, value interface{}) { - fmt.Fprint(&buf, sep) - sep = ", " - fmt.Fprint(&buf, key) - if values { - fmt.Fprintf(&buf, ": %q", value) - } - }) - fmt.Fprint(&buf, "}") - return buf.String() -} - -// String returns a string representation of the map's entries. -// Values are printed using fmt.Sprintf("%v", v). -// Order is unspecified. -// -func (m *Map) String() string { - return m.toString(true) -} - -// KeysString returns a string representation of the map's key set. -// Order is unspecified. -// -func (m *Map) KeysString() string { - return m.toString(false) -} - -//////////////////////////////////////////////////////////////////////// -// Hasher - -// A Hasher maps each type to its hash value. -// For efficiency, a hasher uses memoization; thus its memory -// footprint grows monotonically over time. -// Hashers are not thread-safe. -// Hashers have reference semantics. -// Call MakeHasher to create a Hasher. -type Hasher struct { - memo map[types.Type]uint32 -} - -// MakeHasher returns a new Hasher instance. -func MakeHasher() Hasher { - return Hasher{make(map[types.Type]uint32)} -} - -// Hash computes a hash value for the given type t such that -// Identical(t, t') => Hash(t) == Hash(t'). -func (h Hasher) Hash(t types.Type) uint32 { - hash, ok := h.memo[t] - if !ok { - hash = h.hashFor(t) - h.memo[t] = hash - } - return hash -} - -// hashString computes the Fowler–Noll–Vo hash of s. -func hashString(s string) uint32 { - var h uint32 - for i := 0; i < len(s); i++ { - h ^= uint32(s[i]) - h *= 16777619 - } - return h -} - -// hashFor computes the hash of t. -func (h Hasher) hashFor(t types.Type) uint32 { - // See Identical for rationale. - switch t := t.(type) { - case *types.Basic: - return uint32(t.Kind()) - - case *types.Array: - return 9043 + 2*uint32(t.Len()) + 3*h.Hash(t.Elem()) - - case *types.Slice: - return 9049 + 2*h.Hash(t.Elem()) - - case *types.Struct: - var hash uint32 = 9059 - for i, n := 0, t.NumFields(); i < n; i++ { - f := t.Field(i) - if f.Anonymous() { - hash += 8861 - } - hash += hashString(t.Tag(i)) - hash += hashString(f.Name()) // (ignore f.Pkg) - hash += h.Hash(f.Type()) - } - return hash - - case *types.Pointer: - return 9067 + 2*h.Hash(t.Elem()) - - case *types.Signature: - var hash uint32 = 9091 - if t.Variadic() { - hash *= 8863 - } - return hash + 3*h.hashTuple(t.Params()) + 5*h.hashTuple(t.Results()) - - case *types.Interface: - var hash uint32 = 9103 - for i, n := 0, t.NumMethods(); i < n; i++ { - // See go/types.identicalMethods for rationale. - // Method order is not significant. - // Ignore m.Pkg(). - m := t.Method(i) - hash += 3*hashString(m.Name()) + 5*h.Hash(m.Type()) - } - return hash - - case *types.Map: - return 9109 + 2*h.Hash(t.Key()) + 3*h.Hash(t.Elem()) - - case *types.Chan: - return 9127 + 2*uint32(t.Dir()) + 3*h.Hash(t.Elem()) - - case *types.Named: - // Not safe with a copying GC; objects may move. - return uint32(reflect.ValueOf(t.Obj()).Pointer()) - - case *types.Tuple: - return h.hashTuple(t) - } - panic(t) -} - -func (h Hasher) hashTuple(tuple *types.Tuple) uint32 { - // See go/types.identicalTypes for rationale. - n := tuple.Len() - var hash uint32 = 9137 + 2*uint32(n) - for i := 0; i < n; i++ { - hash += 3 * h.Hash(tuple.At(i).Type()) - } - return hash -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/map_test.go b/vendor/golang.org/x/tools/go/types/typeutil/map_test.go deleted file mode 100644 index 34facbe..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/map_test.go +++ /dev/null @@ -1,174 +0,0 @@ -// Copyright 2014 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 typeutil_test - -// TODO(adonovan): -// - test use of explicit hasher across two maps. -// - test hashcodes are consistent with equals for a range of types -// (e.g. all types generated by type-checking some body of real code). - -import ( - "go/types" - "testing" - - "golang.org/x/tools/go/types/typeutil" -) - -var ( - tStr = types.Typ[types.String] // string - tPStr1 = types.NewPointer(tStr) // *string - tPStr2 = types.NewPointer(tStr) // *string, again - tInt = types.Typ[types.Int] // int - tChanInt1 = types.NewChan(types.RecvOnly, tInt) // <-chan int - tChanInt2 = types.NewChan(types.RecvOnly, tInt) // <-chan int, again -) - -func checkEqualButNotIdentical(t *testing.T, x, y types.Type, comment string) { - if !types.Identical(x, y) { - t.Errorf("%s: not equal: %s, %s", comment, x, y) - } - if x == y { - t.Errorf("%s: identical: %v, %v", comment, x, y) - } -} - -func TestAxioms(t *testing.T) { - checkEqualButNotIdentical(t, tPStr1, tPStr2, "tPstr{1,2}") - checkEqualButNotIdentical(t, tChanInt1, tChanInt2, "tChanInt{1,2}") -} - -func TestMap(t *testing.T) { - var tmap *typeutil.Map - - // All methods but Set are safe on on (*T)(nil). - tmap.Len() - tmap.At(tPStr1) - tmap.Delete(tPStr1) - tmap.KeysString() - tmap.String() - - tmap = new(typeutil.Map) - - // Length of empty map. - if l := tmap.Len(); l != 0 { - t.Errorf("Len() on empty Map: got %d, want 0", l) - } - // At of missing key. - if v := tmap.At(tPStr1); v != nil { - t.Errorf("At() on empty Map: got %v, want nil", v) - } - // Deletion of missing key. - if tmap.Delete(tPStr1) { - t.Errorf("Delete() on empty Map: got true, want false") - } - // Set of new key. - if prev := tmap.Set(tPStr1, "*string"); prev != nil { - t.Errorf("Set() on empty Map returned non-nil previous value %s", prev) - } - - // Now: {*string: "*string"} - - // Length of non-empty map. - if l := tmap.Len(); l != 1 { - t.Errorf("Len(): got %d, want 1", l) - } - // At via insertion key. - if v := tmap.At(tPStr1); v != "*string" { - t.Errorf("At(): got %q, want \"*string\"", v) - } - // At via equal key. - if v := tmap.At(tPStr2); v != "*string" { - t.Errorf("At(): got %q, want \"*string\"", v) - } - // Iteration over sole entry. - tmap.Iterate(func(key types.Type, value interface{}) { - if key != tPStr1 { - t.Errorf("Iterate: key: got %s, want %s", key, tPStr1) - } - if want := "*string"; value != want { - t.Errorf("Iterate: value: got %s, want %s", value, want) - } - }) - - // Setion with key equal to present one. - if prev := tmap.Set(tPStr2, "*string again"); prev != "*string" { - t.Errorf("Set() previous value: got %s, want \"*string\"", prev) - } - - // Setion of another association. - if prev := tmap.Set(tChanInt1, "<-chan int"); prev != nil { - t.Errorf("Set() previous value: got %s, want nil", prev) - } - - // Now: {*string: "*string again", <-chan int: "<-chan int"} - - want1 := "{*string: \"*string again\", <-chan int: \"<-chan int\"}" - want2 := "{<-chan int: \"<-chan int\", *string: \"*string again\"}" - if s := tmap.String(); s != want1 && s != want2 { - t.Errorf("String(): got %s, want %s", s, want1) - } - - want1 = "{*string, <-chan int}" - want2 = "{<-chan int, *string}" - if s := tmap.KeysString(); s != want1 && s != want2 { - t.Errorf("KeysString(): got %s, want %s", s, want1) - } - - // Keys(). - I := types.Identical - switch k := tmap.Keys(); { - case I(k[0], tChanInt1) && I(k[1], tPStr1): // ok - case I(k[1], tChanInt1) && I(k[0], tPStr1): // ok - default: - t.Errorf("Keys(): got %v, want %s", k, want2) - } - - if l := tmap.Len(); l != 2 { - t.Errorf("Len(): got %d, want 1", l) - } - // At via original key. - if v := tmap.At(tPStr1); v != "*string again" { - t.Errorf("At(): got %q, want \"*string again\"", v) - } - hamming := 1 - tmap.Iterate(func(key types.Type, value interface{}) { - switch { - case I(key, tChanInt1): - hamming *= 2 // ok - case I(key, tPStr1): - hamming *= 3 // ok - } - }) - if hamming != 6 { - t.Errorf("Iterate: hamming: got %d, want %d", hamming, 6) - } - - if v := tmap.At(tChanInt2); v != "<-chan int" { - t.Errorf("At(): got %q, want \"<-chan int\"", v) - } - // Deletion with key equal to present one. - if !tmap.Delete(tChanInt2) { - t.Errorf("Delete() of existing key: got false, want true") - } - - // Now: {*string: "*string again"} - - if l := tmap.Len(); l != 1 { - t.Errorf("Len(): got %d, want 1", l) - } - // Deletion again. - if !tmap.Delete(tPStr2) { - t.Errorf("Delete() of existing key: got false, want true") - } - - // Now: {} - - if l := tmap.Len(); l != 0 { - t.Errorf("Len(): got %d, want %d", l, 0) - } - if s := tmap.String(); s != "{}" { - t.Errorf("Len(): got %q, want %q", s, "") - } -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go b/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go deleted file mode 100644 index 3208461..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/methodsetcache.go +++ /dev/null @@ -1,72 +0,0 @@ -// Copyright 2014 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. - -// This file implements a cache of method sets. - -package typeutil - -import ( - "go/types" - "sync" -) - -// A MethodSetCache records the method set of each type T for which -// MethodSet(T) is called so that repeat queries are fast. -// The zero value is a ready-to-use cache instance. -type MethodSetCache struct { - mu sync.Mutex - named map[*types.Named]struct{ value, pointer *types.MethodSet } // method sets for named N and *N - others map[types.Type]*types.MethodSet // all other types -} - -// MethodSet returns the method set of type T. It is thread-safe. -// -// If cache is nil, this function is equivalent to types.NewMethodSet(T). -// Utility functions can thus expose an optional *MethodSetCache -// parameter to clients that care about performance. -// -func (cache *MethodSetCache) MethodSet(T types.Type) *types.MethodSet { - if cache == nil { - return types.NewMethodSet(T) - } - cache.mu.Lock() - defer cache.mu.Unlock() - - switch T := T.(type) { - case *types.Named: - return cache.lookupNamed(T).value - - case *types.Pointer: - if N, ok := T.Elem().(*types.Named); ok { - return cache.lookupNamed(N).pointer - } - } - - // all other types - // (The map uses pointer equivalence, not type identity.) - mset := cache.others[T] - if mset == nil { - mset = types.NewMethodSet(T) - if cache.others == nil { - cache.others = make(map[types.Type]*types.MethodSet) - } - cache.others[T] = mset - } - return mset -} - -func (cache *MethodSetCache) lookupNamed(named *types.Named) struct{ value, pointer *types.MethodSet } { - if cache.named == nil { - cache.named = make(map[*types.Named]struct{ value, pointer *types.MethodSet }) - } - // Avoid recomputing mset(*T) for each distinct Pointer - // instance whose underlying type is a named type. - msets, ok := cache.named[named] - if !ok { - msets.value = types.NewMethodSet(named) - msets.pointer = types.NewMethodSet(types.NewPointer(named)) - cache.named[named] = msets - } - return msets -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui.go b/vendor/golang.org/x/tools/go/types/typeutil/ui.go deleted file mode 100644 index 9849c24..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/ui.go +++ /dev/null @@ -1,52 +0,0 @@ -// Copyright 2014 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 typeutil - -// This file defines utilities for user interfaces that display types. - -import "go/types" - -// IntuitiveMethodSet returns the intuitive method set of a type T, -// which is the set of methods you can call on an addressable value of -// that type. -// -// The result always contains MethodSet(T), and is exactly MethodSet(T) -// for interface types and for pointer-to-concrete types. -// For all other concrete types T, the result additionally -// contains each method belonging to *T if there is no identically -// named method on T itself. -// -// This corresponds to user intuition about method sets; -// this function is intended only for user interfaces. -// -// The order of the result is as for types.MethodSet(T). -// -func IntuitiveMethodSet(T types.Type, msets *MethodSetCache) []*types.Selection { - isPointerToConcrete := func(T types.Type) bool { - ptr, ok := T.(*types.Pointer) - return ok && !types.IsInterface(ptr.Elem()) - } - - var result []*types.Selection - mset := msets.MethodSet(T) - if types.IsInterface(T) || isPointerToConcrete(T) { - for i, n := 0, mset.Len(); i < n; i++ { - result = append(result, mset.At(i)) - } - } else { - // T is some other concrete type. - // Report methods of T and *T, preferring those of T. - pmset := msets.MethodSet(types.NewPointer(T)) - for i, n := 0, pmset.Len(); i < n; i++ { - meth := pmset.At(i) - if m := mset.Lookup(meth.Obj().Pkg(), meth.Obj().Name()); m != nil { - meth = m - } - result = append(result, meth) - } - - } - return result -} diff --git a/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go b/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go deleted file mode 100644 index b5064ac..0000000 --- a/vendor/golang.org/x/tools/go/types/typeutil/ui_test.go +++ /dev/null @@ -1,61 +0,0 @@ -package typeutil_test - -import ( - "fmt" - "go/ast" - "go/parser" - "go/token" - "go/types" - "strings" - "testing" - - "golang.org/x/tools/go/types/typeutil" -) - -func TestIntuitiveMethodSet(t *testing.T) { - const source = ` -package P -type A int -func (A) f() -func (*A) g() -` - - fset := token.NewFileSet() - f, err := parser.ParseFile(fset, "hello.go", source, 0) - if err != nil { - t.Fatal(err) - } - - var conf types.Config - pkg, err := conf.Check("P", fset, []*ast.File{f}, nil) - if err != nil { - t.Fatal(err) - } - qual := types.RelativeTo(pkg) - - for _, test := range []struct { - expr string // type expression - want string // intuitive method set - }{ - {"A", "(A).f (*A).g"}, - {"*A", "(*A).f (*A).g"}, - {"error", "(error).Error"}, - {"*error", ""}, - {"struct{A}", "(struct{A}).f (*struct{A}).g"}, - {"*struct{A}", "(*struct{A}).f (*struct{A}).g"}, - } { - tv, err := types.Eval(fset, pkg, 0, test.expr) - if err != nil { - t.Errorf("Eval(%s) failed: %v", test.expr, err) - } - var names []string - for _, m := range typeutil.IntuitiveMethodSet(tv.Type, nil) { - name := fmt.Sprintf("(%s).%s", types.TypeString(m.Recv(), qual), m.Obj().Name()) - names = append(names, name) - } - got := strings.Join(names, " ") - if got != test.want { - t.Errorf("IntuitiveMethodSet(%s) = %q, want %q", test.expr, got, test.want) - } - } -} |