internal/pkgbits: add Index type

Element indices are very common in the pkgbits API, so introduce a new
defined type to help make that clearer.

Change-Id: I8f9493e2335601c740eb403d1fdcd11183122907
Reviewed-on: https://go-review.googlesource.com/c/go/+/407435
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>

4 files changed, 46 insertions, 46 deletions

diff --git a/src/cmd/compile/internal/noder/linker.go b/src/cmd/compile/internal/noder/linker.go
index 4ad05dcbe0..a58b9b930c 100644
--- a/src/cmd/compile/internal/noder/linker.go
+++ b/src/cmd/compile/internal/noder/linker.go
@@ -37,8 +37,8 @@ import (
 type linker struct {
 	pw pkgbits.PkgEncoder
 
-	pkgs  map[string]int
-	decls map[*types.Sym]int
+	pkgs  map[string]pkgbits.Index
+	decls map[*types.Sym]pkgbits.Index
 }
 
 func (l *linker) relocAll(pr *pkgReader, relocs []pkgbits.RelocEnt) []pkgbits.RelocEnt {
@@ -50,7 +50,7 @@ func (l *linker) relocAll(pr *pkgReader, relocs []pkgbits.RelocEnt) []pkgbits.Re
 	return res
 }
 
-func (l *linker) relocIdx(pr *pkgReader, k pkgbits.RelocKind, idx int) int {
+func (l *linker) relocIdx(pr *pkgReader, k pkgbits.RelocKind, idx pkgbits.Index) pkgbits.Index {
 	assert(pr != nil)
 
 	absIdx := pr.AbsIdx(k, idx)
@@ -59,7 +59,7 @@ func (l *linker) relocIdx(pr *pkgReader, k pkgbits.RelocKind, idx int) int {
 		return ^newidx
 	}
 
-	var newidx int
+	var newidx pkgbits.Index
 	switch k {
 	case pkgbits.RelocString:
 		newidx = l.relocString(pr, idx)
@@ -85,11 +85,11 @@ func (l *linker) relocIdx(pr *pkgReader, k pkgbits.RelocKind, idx int) int {
 	return newidx
 }
 
-func (l *linker) relocString(pr *pkgReader, idx int) int {
+func (l *linker) relocString(pr *pkgReader, idx pkgbits.Index) pkgbits.Index {
 	return l.pw.StringIdx(pr.StringIdx(idx))
 }
 
-func (l *linker) relocPkg(pr *pkgReader, idx int) int {
+func (l *linker) relocPkg(pr *pkgReader, idx pkgbits.Index) pkgbits.Index {
 	path := pr.PeekPkgPath(idx)
 
 	if newidx, ok := l.pkgs[path]; ok {
@@ -114,7 +114,7 @@ func (l *linker) relocPkg(pr *pkgReader, idx int) int {
 	return w.Flush()
 }
 
-func (l *linker) relocObj(pr *pkgReader, idx int) int {
+func (l *linker) relocObj(pr *pkgReader, idx pkgbits.Index) pkgbits.Index {
 	path, name, tag := pr.PeekObj(idx)
 	sym := types.NewPkg(path, "").Lookup(name)
 
@@ -184,7 +184,7 @@ func (l *linker) relocObj(pr *pkgReader, idx int) int {
 	return w.Idx
 }
 
-func (l *linker) relocCommon(pr *pkgReader, w *pkgbits.Encoder, k pkgbits.RelocKind, idx int) {
+func (l *linker) relocCommon(pr *pkgReader, w *pkgbits.Encoder, k pkgbits.RelocKind, idx pkgbits.Index) {
 	r := pr.NewDecoderRaw(k, idx)
 	w.Relocs = l.relocAll(pr, r.Relocs)
 	io.Copy(&w.Data, &r.Data)
diff --git a/src/cmd/compile/internal/noder/reader.go b/src/cmd/compile/internal/noder/reader.go
index 60aba3e560..296cdd7d54 100644
--- a/src/cmd/compile/internal/noder/reader.go
+++ b/src/cmd/compile/internal/noder/reader.go
@@ -35,7 +35,7 @@ type pkgReader struct {
 
 	// offset for rewriting the given index into the output,
 	// but bitwise inverted so we can detect if we're missing the entry or not.
-	newindex []int
+	newindex []pkgbits.Index
 }
 
 func newPkgReader(pr pkgbits.PkgDecoder) *pkgReader {
@@ -46,13 +46,13 @@ func newPkgReader(pr pkgbits.PkgDecoder) *pkgReader {
 		pkgs:     make([]*types.Pkg, pr.NumElems(pkgbits.RelocPkg)),
 		typs:     make([]*types.Type, pr.NumElems(pkgbits.RelocType)),
 
-		newindex: make([]int, pr.TotalElems()),
+		newindex: make([]pkgbits.Index, pr.TotalElems()),
 	}
 }
 
 type pkgReaderIndex struct {
 	pr   *pkgReader
-	idx  int
+	idx  pkgbits.Index
 	dict *readerDict
 }
 
@@ -62,7 +62,7 @@ func (pri pkgReaderIndex) asReader(k pkgbits.RelocKind, marker pkgbits.SyncMarke
 	return r
 }
 
-func (pr *pkgReader) newReader(k pkgbits.RelocKind, idx int, marker pkgbits.SyncMarker) *reader {
+func (pr *pkgReader) newReader(k pkgbits.RelocKind, idx pkgbits.Index, marker pkgbits.SyncMarker) *reader {
 	return &reader{
 		Decoder: pr.NewDecoder(k, idx, marker),
 		p:       pr,
@@ -182,7 +182,7 @@ func (r *reader) posBase() *src.PosBase {
 	return r.inlPosBase(r.p.posBaseIdx(r.Reloc(pkgbits.RelocPosBase)))
 }
 
-func (pr *pkgReader) posBaseIdx(idx int) *src.PosBase {
+func (pr *pkgReader) posBaseIdx(idx pkgbits.Index) *src.PosBase {
 	if b := pr.posBases[idx]; b != nil {
 		return b
 	}
@@ -266,7 +266,7 @@ func (r *reader) pkg() *types.Pkg {
 	return r.p.pkgIdx(r.Reloc(pkgbits.RelocPkg))
 }
 
-func (pr *pkgReader) pkgIdx(idx int) *types.Pkg {
+func (pr *pkgReader) pkgIdx(idx pkgbits.Index) *types.Pkg {
 	if pkg := pr.pkgs[idx]; pkg != nil {
 		return pkg
 	}
@@ -322,7 +322,7 @@ func (r *reader) typWrapped(wrapped bool) *types.Type {
 func (r *reader) typInfo() typeInfo {
 	r.Sync(pkgbits.SyncType)
 	if r.Bool() {
-		return typeInfo{idx: r.Len(), derived: true}
+		return typeInfo{idx: pkgbits.Index(r.Len()), derived: true}
 	}
 	return typeInfo{idx: r.Reloc(pkgbits.RelocType), derived: false}
 }
@@ -573,7 +573,7 @@ func (r *reader) obj() ir.Node {
 	return r.p.objIdx(idx, implicits, explicits)
 }
 
-func (pr *pkgReader) objIdx(idx int, implicits, explicits []*types.Type) ir.Node {
+func (pr *pkgReader) objIdx(idx pkgbits.Index, implicits, explicits []*types.Type) ir.Node {
 	rname := pr.newReader(pkgbits.RelocName, idx, pkgbits.SyncObject1)
 	_, sym := rname.qualifiedIdent()
 	tag := pkgbits.CodeObj(rname.Code(pkgbits.SyncCodeObj))
@@ -712,7 +712,7 @@ func (r *reader) mangle(sym *types.Sym) *types.Sym {
 	return sym.Pkg.Lookup(buf.String())
 }
 
-func (pr *pkgReader) objDictIdx(sym *types.Sym, idx int, implicits, explicits []*types.Type) *readerDict {
+func (pr *pkgReader) objDictIdx(sym *types.Sym, idx pkgbits.Index, implicits, explicits []*types.Type) *readerDict {
 	r := pr.newReader(pkgbits.RelocObjDict, idx, pkgbits.SyncObject1)
 
 	var dict readerDict
@@ -757,7 +757,7 @@ func (pr *pkgReader) objDictIdx(sym *types.Sym, idx int, implicits, explicits []
 
 	dict.itabs = make([]itabInfo2, r.Len())
 	for i := range dict.itabs {
-		typ := pr.typIdx(typeInfo{idx: r.Len(), derived: true}, &dict, true)
+		typ := pr.typIdx(typeInfo{idx: pkgbits.Index(r.Len()), derived: true}, &dict, true)
 		ifaceInfo := r.typInfo()
 
 		var lsym *obj.LSym
diff --git a/src/cmd/compile/internal/noder/unified.go b/src/cmd/compile/internal/noder/unified.go
index 6e63ff4123..46acdab79e 100644
--- a/src/cmd/compile/internal/noder/unified.go
+++ b/src/cmd/compile/internal/noder/unified.go
@@ -257,14 +257,14 @@ func writeUnifiedExport(out io.Writer) {
 	l := linker{
 		pw: pkgbits.NewPkgEncoder(base.Debug.SyncFrames),
 
-		pkgs:  make(map[string]int),
-		decls: make(map[*types.Sym]int),
+		pkgs:  make(map[string]pkgbits.Index),
+		decls: make(map[*types.Sym]pkgbits.Index),
 	}
 
 	publicRootWriter := l.pw.NewEncoder(pkgbits.RelocMeta, pkgbits.SyncPublic)
 	assert(publicRootWriter.Idx == pkgbits.PublicRootIdx)
 
-	var selfPkgIdx int
+	var selfPkgIdx pkgbits.Index
 
 	{
 		pr := localPkgReader
@@ -294,11 +294,11 @@ func writeUnifiedExport(out io.Writer) {
 	}
 
 	{
-		var idxs []int
+		var idxs []pkgbits.Index
 		for _, idx := range l.decls {
 			idxs = append(idxs, idx)
 		}
-		sort.Ints(idxs)
+		sort.Slice(idxs, func(i, j int) bool { return idxs[i] < idxs[j] })
 
 		w := publicRootWriter
 
diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go
index 298ed493f7..b440ad3a1e 100644
--- a/src/cmd/compile/internal/noder/writer.go
+++ b/src/cmd/compile/internal/noder/writer.go
@@ -23,10 +23,10 @@ type pkgWriter struct {
 	curpkg *types2.Package
 	info   *types2.Info
 
-	posBasesIdx map[*syntax.PosBase]int
-	pkgsIdx     map[*types2.Package]int
-	typsIdx     map[types2.Type]int
-	globalsIdx  map[types2.Object]int
+	posBasesIdx map[*syntax.PosBase]pkgbits.Index
+	pkgsIdx     map[*types2.Package]pkgbits.Index
+	typsIdx     map[types2.Type]pkgbits.Index
+	globalsIdx  map[types2.Object]pkgbits.Index
 
 	funDecls map[*types2.Func]*syntax.FuncDecl
 	typDecls map[*types2.TypeName]typeDeclGen
@@ -43,11 +43,11 @@ func newPkgWriter(m posMap, pkg *types2.Package, info *types2.Info) *pkgWriter {
 		curpkg: pkg,
 		info:   info,
 
-		pkgsIdx:    make(map[*types2.Package]int),
-		globalsIdx: make(map[types2.Object]int),
-		typsIdx:    make(map[types2.Type]int),
+		pkgsIdx:    make(map[*types2.Package]pkgbits.Index),
+		globalsIdx: make(map[types2.Object]pkgbits.Index),
+		typsIdx:    make(map[types2.Type]pkgbits.Index),
 
-		posBasesIdx: make(map[*syntax.PosBase]int),
+		posBasesIdx: make(map[*syntax.PosBase]pkgbits.Index),
 
 		funDecls: make(map[*types2.Func]*syntax.FuncDecl),
 		typDecls: make(map[*types2.TypeName]typeDeclGen),
@@ -97,7 +97,7 @@ type writerDict struct {
 
 	// derivedIdx maps a Type to its corresponding index within the
 	// derived slice, if present.
-	derivedIdx map[types2.Type]int
+	derivedIdx map[types2.Type]pkgbits.Index
 
 	// funcs lists references to generic functions that were
 	// instantiated with derived types (i.e., that require
@@ -111,7 +111,7 @@ type writerDict struct {
 
 // A derivedInfo represents a reference to an encoded generic Go type.
 type derivedInfo struct {
-	idx    int
+	idx    pkgbits.Index
 	needed bool
 }
 
@@ -124,18 +124,18 @@ type derivedInfo struct {
 // Otherwise, the typeInfo represents a non-generic Go type, and idx
 // is an index into the reader.typs array instead.
 type typeInfo struct {
-	idx     int
+	idx     pkgbits.Index
 	derived bool
 }
 
 type objInfo struct {
-	idx       int        // index for the generic function declaration
-	explicits []typeInfo // info for the type arguments
+	idx       pkgbits.Index // index for the generic function declaration
+	explicits []typeInfo    // info for the type arguments
 }
 
 type itabInfo struct {
-	typIdx int      // always a derived type index
-	iface  typeInfo // always a non-empty interface type
+	typIdx pkgbits.Index // always a derived type index
+	iface  typeInfo      // always a non-empty interface type
 }
 
 func (info objInfo) anyDerived() bool {
@@ -189,7 +189,7 @@ func (w *writer) posBase(b *syntax.PosBase) {
 	w.Reloc(pkgbits.RelocPosBase, w.p.posBaseIdx(b))
 }
 
-func (pw *pkgWriter) posBaseIdx(b *syntax.PosBase) int {
+func (pw *pkgWriter) posBaseIdx(b *syntax.PosBase) pkgbits.Index {
 	if idx, ok := pw.posBasesIdx[b]; ok {
 		return idx
 	}
@@ -215,7 +215,7 @@ func (w *writer) pkg(pkg *types2.Package) {
 	w.Reloc(pkgbits.RelocPkg, w.p.pkgIdx(pkg))
 }
 
-func (pw *pkgWriter) pkgIdx(pkg *types2.Package) int {
+func (pw *pkgWriter) pkgIdx(pkg *types2.Package) pkgbits.Index {
 	if idx, ok := pw.pkgsIdx[pkg]; ok {
 		return idx
 	}
@@ -263,7 +263,7 @@ func (w *writer) typ(typ types2.Type) {
 func (w *writer) typInfo(info typeInfo) {
 	w.Sync(pkgbits.SyncType)
 	if w.Bool(info.derived) {
-		w.Len(info.idx)
+		w.Len(int(info.idx))
 		w.derived = true
 	} else {
 		w.Reloc(pkgbits.RelocType, info.idx)
@@ -385,7 +385,7 @@ func (pw *pkgWriter) typIdx(typ types2.Type, dict *writerDict) typeInfo {
 	}
 
 	if w.derived {
-		idx := len(dict.derived)
+		idx := pkgbits.Index(len(dict.derived))
 		dict.derived = append(dict.derived, derivedInfo{idx: w.Flush()})
 		dict.derivedIdx[typ] = idx
 		return typeInfo{idx: idx, derived: true}
@@ -515,13 +515,13 @@ func (w *writer) obj(obj types2.Object, explicits *types2.TypeList) {
 	}
 }
 
-func (pw *pkgWriter) objIdx(obj types2.Object) int {
+func (pw *pkgWriter) objIdx(obj types2.Object) pkgbits.Index {
 	if idx, ok := pw.globalsIdx[obj]; ok {
 		return idx
 	}
 
 	dict := &writerDict{
-		derivedIdx: make(map[types2.Type]int),
+		derivedIdx: make(map[types2.Type]pkgbits.Index),
 	}
 
 	if isDefinedType(obj) && obj.Pkg() == pw.curpkg {
@@ -663,7 +663,7 @@ func (w *writer) objDict(obj types2.Object, dict *writerDict) {
 	nitabs := len(dict.itabs)
 	w.Len(nitabs)
 	for _, itab := range dict.itabs {
-		w.Len(itab.typIdx)
+		w.Len(int(itab.typIdx))
 		w.typInfo(itab.iface)
 	}
 
@@ -829,7 +829,7 @@ func (w *writer) pragmaFlag(p ir.PragmaFlag) {
 
 // @@@ Function bodies
 
-func (pw *pkgWriter) bodyIdx(pkg *types2.Package, sig *types2.Signature, block *syntax.BlockStmt, dict *writerDict) (idx int, closureVars []posObj) {
+func (pw *pkgWriter) bodyIdx(pkg *types2.Package, sig *types2.Signature, block *syntax.BlockStmt, dict *writerDict) (idx pkgbits.Index, closureVars []posObj) {
 	w := pw.newWriter(pkgbits.RelocBody, pkgbits.SyncFuncBody)
 	w.dict = dict