cmd/compile/internal/types: remove dead function

[gostls13.git] / src / cmd / compile / internal / types / pkg.go

diff --git a/src/cmd/compile/internal/types/pkg.go b/src/cmd/compile/internal/types/pkg.go
index 1fe49bd142568f9e6de695b2b223363330ed3735..c6ce7889afbb7bd7abc4d32a30e53278bda7b44f 100644 (file)
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -8,20 +8,21 @@ import (
        "cmd/internal/obj"
        "cmd/internal/objabi"
        "fmt"
-       "sort"
+       "strconv"
+       "sync"
 )
 
 // pkgMap maps a package path to a package.
 var pkgMap = make(map[string]*Pkg)
 
 type Pkg struct {
-       Path     string // string literal used in import statement, e.g. "runtime/internal/sys"
-       Name     string // package name, e.g. "sys"
-       Pathsym  *obj.LSym
-       Prefix   string // escaped path for use in symbol table
-       Imported bool   // export data of this package was parsed
-       Direct   bool   // imported directly
-       Syms     map[string]*Sym
+       Path    string // string literal used in import statement, e.g. "runtime/internal/sys"
+       Name    string // package name, e.g. "sys"
+       Prefix  string // escaped path for use in symbol table
+       Syms    map[string]*Sym
+       Pathsym *obj.LSym
+
+       Direct bool // imported directly
 }
 
 // NewPkg returns a new Pkg for the given package path and name.
@@ -38,32 +39,25 @@ func NewPkg(path, name string) *Pkg {
        p := new(Pkg)
        p.Path = path
        p.Name = name
-       p.Prefix = objabi.PathToPrefix(path)
+       if path == "go.shape" {
+               // Don't escape "go.shape", since it's not needed (it's a builtin
+               // package), and we don't want escape codes showing up in shape type
+               // names, which also appear in names of function/method
+               // instantiations.
+               p.Prefix = path
+       } else {
+               p.Prefix = objabi.PathToPrefix(path)
+       }
        p.Syms = make(map[string]*Sym)
        pkgMap[path] = p
 
        return p
 }
 
-// ImportedPkgList returns the list of directly imported packages.
-// The list is sorted by package path.
-func ImportedPkgList() []*Pkg {
-       var list []*Pkg
-       for _, p := range pkgMap {
-               if p.Direct {
-                       list = append(list, p)
-               }
-       }
-       sort.Sort(byPath(list))
-       return list
+func PkgMap() map[string]*Pkg {
+       return pkgMap
 }
 
-type byPath []*Pkg
-
-func (a byPath) Len() int           { return len(a) }
-func (a byPath) Less(i, j int) bool { return a[i].Path < a[j].Path }
-func (a byPath) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
-
 var nopkg = &Pkg{
        Syms: make(map[string]*Sym),
 }
@@ -73,8 +67,6 @@ func (pkg *Pkg) Lookup(name string) *Sym {
        return s
 }
 
-var InitSyms []*Sym
-
 // LookupOK looks up name in pkg and reports whether it previously existed.
 func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
        // TODO(gri) remove this check in favor of specialized lookup
@@ -89,9 +81,6 @@ func (pkg *Pkg) LookupOK(name string) (s *Sym, existed bool) {
                Name: name,
                Pkg:  pkg,
        }
-       if name == "init" {
-               InitSyms = append(InitSyms, s)
-       }
        pkg.Syms[name] = s
        return s, false
 }
@@ -108,22 +97,35 @@ func (pkg *Pkg) LookupBytes(name []byte) *Sym {
        return pkg.Lookup(str)
 }
 
-var internedStrings = map[string]string{}
+// LookupNum looks up the symbol starting with prefix and ending with
+// the decimal n. If prefix is too long, LookupNum panics.
+func (pkg *Pkg) LookupNum(prefix string, n int) *Sym {
+       var buf [20]byte // plenty long enough for all current users
+       copy(buf[:], prefix)
+       b := strconv.AppendInt(buf[:len(prefix)], int64(n), 10)
+       return pkg.LookupBytes(b)
+}
+
+// Selector looks up a selector identifier.
+func (pkg *Pkg) Selector(name string) *Sym {
+       if IsExported(name) {
+               pkg = LocalPkg
+       }
+       return pkg.Lookup(name)
+}
+
+var (
+       internedStringsmu sync.Mutex // protects internedStrings
+       internedStrings   = map[string]string{}
+)
 
 func InternString(b []byte) string {
+       internedStringsmu.Lock()
        s, ok := internedStrings[string(b)] // string(b) here doesn't allocate
        if !ok {
                s = string(b)
                internedStrings[s] = s
        }
+       internedStringsmu.Unlock()
        return s
 }
-
-// CleanroomDo invokes f in an environment with with no preexisting packages.
-// For testing of import/export only.
-func CleanroomDo(f func()) {
-       saved := pkgMap
-       pkgMap = make(map[string]*Pkg)
-       f()
-       pkgMap = saved
-}