qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-18 07:54:55 -07:00
Code Releases Activity

go/types: remove MethodSetCache - not needed

Browse Source 
In x/tools, MethodSetCache was moved from x/tools/go/types to
x/tools/go/types/typeutil. Mirror that change.

Change-Id: Ib838a9518371473c83fa4abc2778d42f33947c98
Reviewed-on: https://go-review.googlesource.com/10771
Reviewed-by: Alan Donovan <adonovan@google.com>
This commit is contained in:
Robert Griesemer 2015-06-05 10:35:29 -07:00
parent 7529314ed3
commit a9c14d1ab5
1 changed files with 0 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
src/go/types/methodsetcache.go
View File

@ -1,69 +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 types
import "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[*Named]struct{ value, pointer *MethodSet } // method sets for named N and *N
others map[Type]*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 NewMethodSet(T).
// Utility functions can thus expose an optional *MethodSetCache
// parameter to clients that care about performance.
//
func (cache *MethodSetCache) MethodSet(T Type) *MethodSet {
if cache == nil {
return NewMethodSet(T)
}
cache.mu.Lock()
defer cache.mu.Unlock()
switch T := T.(type) {
case *Named:
return cache.lookupNamed(T).value
case *Pointer:
if N, ok := T.Elem().(*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 = NewMethodSet(T)
if cache.others == nil {
cache.others = make(map[Type]*MethodSet)
}
cache.others[T] = mset
}
return mset
}
func (cache *MethodSetCache) lookupNamed(named *Named) struct{ value, pointer *MethodSet } {
if cache.named == nil {
cache.named = make(map[*Named]struct{ value, pointer *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 = NewMethodSet(named)
msets.pointer = NewMethodSet(NewPointer(named))
cache.named[named] = msets
}
return msets
}