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 f63a357f0d092921835d7b31896777780a0eabcd..c6ce7889afbb7bd7abc4d32a30e53278bda7b44f 100644 (file)
--- a/src/cmd/compile/internal/types/pkg.go
+++ b/src/cmd/compile/internal/types/pkg.go
@@ -8,16 +8,13 @@ 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)
 
-// MaxPkgHeight is a height greater than any likely package height.
-const MaxPkgHeight = 1e9
-
 type Pkg struct {
        Path    string // string literal used in import statement, e.g. "runtime/internal/sys"
        Name    string // package name, e.g. "sys"
@@ -25,12 +22,6 @@ type Pkg struct {
        Syms    map[string]*Sym
        Pathsym *obj.LSym
 
-       // Height is the package's height in the import graph. Leaf
-       // packages (i.e., packages with no imports) have height 0,
-       // and all other packages have height 1 plus the maximum
-       // height of their imported packages.
-       Height int
-
        Direct bool // imported directly
 }
 
@@ -48,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),
 }
@@ -113,6 +97,23 @@ func (pkg *Pkg) LookupBytes(name []byte) *Sym {
        return pkg.Lookup(str)
 }
 
+// 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{}
@@ -128,12 +129,3 @@ func InternString(b []byte) string {
        internedStringsmu.Unlock()
        return s
 }
-
-// CleanroomDo invokes f in an environment with no preexisting packages.
-// For testing of import/export only.
-func CleanroomDo(f func()) {
-       saved := pkgMap
-       pkgMap = make(map[string]*Pkg)
-       f()
-       pkgMap = saved
-}