go/ssa: rename some API features (incompatible change)
Rename the following exported names:
(*Program).BuildAll → Build
(*Program).Method → MethodValue
Package.Object → Pkg
Also:
(*Function).pkgobj → pkg
Change-Id: Iff7e6c240ebe6786ba759278ac0daa3d66698013
Reviewed-on: https://go-review.googlesource.com/14134
Reviewed-by: Robert Griesemer <gri@golang.org>
diff --git a/go/callgraph/cha/cha_test.go b/go/callgraph/cha/cha_test.go
index 38348c0..e8aa6e1 100644
--- a/go/callgraph/cha/cha_test.go
+++ b/go/callgraph/cha/cha_test.go
@@ -78,11 +78,11 @@
prog := ssautil.CreateProgram(iprog, 0)
mainPkg := prog.Package(iprog.Created[0].Pkg)
- prog.BuildAll()
+ prog.Build()
cg := cha.CallGraph(prog)
- if got := printGraph(cg, mainPkg.Object); got != want {
+ if got := printGraph(cg, mainPkg.Pkg); got != want {
t.Errorf("%s: got:\n%s\nwant:\n%s",
prog.Fset.Position(pos), got, want)
}
diff --git a/go/callgraph/rta/rta.go b/go/callgraph/rta/rta.go
index 8d22da6..81d9d3c 100644
--- a/go/callgraph/rta/rta.go
+++ b/go/callgraph/rta/rta.go
@@ -197,7 +197,7 @@
func (r *rta) addInvokeEdge(site ssa.CallInstruction, C types.Type) {
// Ascertain the concrete method of C to be called.
imethod := site.Common().Method
- cmethod := r.prog.Method(r.prog.MethodSets.MethodSet(C).Lookup(imethod.Pkg(), imethod.Name()))
+ cmethod := r.prog.MethodValue(r.prog.MethodSets.MethodSet(C).Lookup(imethod.Pkg(), imethod.Name()))
r.addEdge(site, cmethod, true)
}
@@ -361,7 +361,7 @@
if m.Exported() {
// Exported methods are always potentially callable via reflection.
- r.addReachable(r.prog.Method(sel), true)
+ r.addReachable(r.prog.MethodValue(sel), true)
}
}
diff --git a/go/callgraph/rta/rta_test.go b/go/callgraph/rta/rta_test.go
index e5aa846..976bb30 100644
--- a/go/callgraph/rta/rta_test.go
+++ b/go/callgraph/rta/rta_test.go
@@ -83,14 +83,14 @@
prog := ssautil.CreateProgram(iprog, 0)
mainPkg := prog.Package(iprog.Created[0].Pkg)
- prog.BuildAll()
+ prog.Build()
res := rta.Analyze([]*ssa.Function{
mainPkg.Func("main"),
mainPkg.Func("init"),
}, true)
- if got := printResult(res, mainPkg.Object); got != want {
+ if got := printResult(res, mainPkg.Pkg); got != want {
t.Errorf("%s: got:\n%s\nwant:\n%s",
prog.Fset.Position(pos), got, want)
}
diff --git a/go/callgraph/static/static_test.go b/go/callgraph/static/static_test.go
index 62297f7..e1bfcd7 100644
--- a/go/callgraph/static/static_test.go
+++ b/go/callgraph/static/static_test.go
@@ -63,7 +63,7 @@
P := iprog.Created[0].Pkg
prog := ssautil.CreateProgram(iprog, 0)
- prog.BuildAll()
+ prog.Build()
cg := static.CallGraph(prog)
diff --git a/go/pointer/analysis.go b/go/pointer/analysis.go
index d02e536..9946581 100644
--- a/go/pointer/analysis.go
+++ b/go/pointer/analysis.go
@@ -254,17 +254,17 @@
for _, pkg := range a.prog.AllPackages() {
// (This only checks that the package scope is complete,
// not that func bodies exist, but it's a good signal.)
- if !pkg.Object.Complete() {
- return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete`, pkg.Object.Path())
+ if !pkg.Pkg.Complete() {
+ return nil, fmt.Errorf(`pointer analysis requires a complete program yet package %q was incomplete`, pkg.Pkg.Path())
}
}
if reflect := a.prog.ImportedPackage("reflect"); reflect != nil {
- rV := reflect.Object.Scope().Lookup("Value")
+ rV := reflect.Pkg.Scope().Lookup("Value")
a.reflectValueObj = rV
a.reflectValueCall = a.prog.LookupMethod(rV.Type(), nil, "Call")
- a.reflectType = reflect.Object.Scope().Lookup("Type").Type().(*types.Named)
- a.reflectRtypeObj = reflect.Object.Scope().Lookup("rtype")
+ a.reflectType = reflect.Pkg.Scope().Lookup("Type").Type().(*types.Named)
+ a.reflectRtypeObj = reflect.Pkg.Scope().Lookup("rtype")
a.reflectRtypePtr = types.NewPointer(a.reflectRtypeObj.Type())
// Override flattening of reflect.Value, treating it like a basic type.
diff --git a/go/pointer/example_test.go b/go/pointer/example_test.go
index ba70557..673de7a 100644
--- a/go/pointer/example_test.go
+++ b/go/pointer/example_test.go
@@ -66,7 +66,7 @@
mainPkg := prog.Package(iprog.Created[0].Pkg)
// Build SSA code for bodies of all functions in the whole program.
- prog.BuildAll()
+ prog.Build()
// Configure the pointer analysis to build a call-graph.
config := &pointer.Config{
@@ -76,7 +76,7 @@
// Query points-to set of (C).f's parameter m, a map.
C := mainPkg.Type("C").Type()
- Cfm := prog.LookupMethod(C, mainPkg.Object, "f").Params[1]
+ Cfm := prog.LookupMethod(C, mainPkg.Pkg, "f").Params[1]
config.AddQuery(Cfm)
// Run the pointer analysis.
diff --git a/go/pointer/gen.go b/go/pointer/gen.go
index 6c256ac..43849a2 100644
--- a/go/pointer/gen.go
+++ b/go/pointer/gen.go
@@ -1223,7 +1223,7 @@
// I think so, but the answer may depend on reflection.
mset := a.prog.MethodSets.MethodSet(T)
for i, n := 0, mset.Len(); i < n; i++ {
- m := a.prog.Method(mset.At(i))
+ m := a.prog.MethodValue(mset.At(i))
a.valueNode(m)
if !itf {
diff --git a/go/pointer/intrinsics.go b/go/pointer/intrinsics.go
index 251c0e2..144df1e 100644
--- a/go/pointer/intrinsics.go
+++ b/go/pointer/intrinsics.go
@@ -211,7 +211,7 @@
return false // "reflect" package not loaded
}
reflectPackage := a.reflectValueObj.Pkg()
- if fn.Pkg != nil && fn.Pkg.Object == reflectPackage {
+ if fn.Pkg != nil && fn.Pkg.Pkg == reflectPackage {
return true
}
// Synthetic wrappers have a nil Pkg, so they slip through the
diff --git a/go/pointer/pointer_test.go b/go/pointer/pointer_test.go
index 2744d4f..d687fa1 100644
--- a/go/pointer/pointer_test.go
+++ b/go/pointer/pointer_test.go
@@ -176,7 +176,7 @@
// SSA creation + building.
prog := ssautil.CreateProgram(iprog, ssa.SanityCheckFunctions)
- prog.BuildAll()
+ prog.Build()
mainpkg := prog.Package(mainPkgInfo)
ptrmain := mainpkg // main package for the pointer analysis
@@ -243,7 +243,7 @@
for _, typstr := range split(rest, "|") {
var t types.Type = types.Typ[types.Invalid] // means "..."
if typstr != "..." {
- tv, err := types.Eval(prog.Fset, mainpkg.Object, f.Pos(), typstr)
+ tv, err := types.Eval(prog.Fset, mainpkg.Pkg, f.Pos(), typstr)
if err != nil {
ok = false
// Don't print err since its location is bad.
diff --git a/go/pointer/reflect.go b/go/pointer/reflect.go
index 466995c..d10e86d 100644
--- a/go/pointer/reflect.go
+++ b/go/pointer/reflect.go
@@ -1879,7 +1879,7 @@
if isIface {
sig = sel.Type().(*types.Signature)
} else {
- fn = a.prog.Method(sel)
+ fn = a.prog.MethodValue(sel)
// move receiver to params[0]
sig = changeRecv(fn.Signature)
}
diff --git a/go/pointer/stdlib_test.go b/go/pointer/stdlib_test.go
index ef7c652..d3d14ea 100644
--- a/go/pointer/stdlib_test.go
+++ b/go/pointer/stdlib_test.go
@@ -52,7 +52,7 @@
// Create SSA packages.
prog := ssautil.CreateProgram(iprog, 0)
- prog.BuildAll()
+ prog.Build()
numPkgs := len(prog.AllPackages())
if want := 240; numPkgs < want {
diff --git a/go/ssa/builder.go b/go/ssa/builder.go
index 5b8ce0e..c2a4a89 100644
--- a/go/ssa/builder.go
+++ b/go/ssa/builder.go
@@ -2217,9 +2217,7 @@
//
// BuildAll is idempotent and thread-safe.
//
-// TODO(adonovan): rename to Build.
-//
-func (prog *Program) BuildAll() {
+func (prog *Program) Build() {
var wg sync.WaitGroup
for _, p := range prog.packages {
if prog.mode&BuildSerially != 0 {
@@ -2281,10 +2279,10 @@
emitStore(init, initguard, vTrue, token.NoPos)
// Call the init() function of each package we import.
- for _, pkg := range p.Object.Imports() {
+ for _, pkg := range p.Pkg.Imports() {
prereq := p.Prog.packages[pkg]
if prereq == nil {
- panic(fmt.Sprintf("Package(%q).Build(): unsatisfied import: Program.CreatePackage(%q) was not called", p.Object.Path(), pkg.Path()))
+ panic(fmt.Sprintf("Package(%q).Build(): unsatisfied import: Program.CreatePackage(%q) was not called", p.Pkg.Path(), pkg.Path()))
}
var v Call
v.Call.Value = prereq.init
diff --git a/go/ssa/builder_test.go b/go/ssa/builder_test.go
index e7ac838..10411e5 100644
--- a/go/ssa/builder_test.go
+++ b/go/ssa/builder_test.go
@@ -112,7 +112,7 @@
}
mset := prog.MethodSets.MethodSet(types.NewPointer(mem.Type()))
for i, n := 0, mset.Len(); i < n; i++ {
- m := prog.Method(mset.At(i))
+ m := prog.MethodValue(mset.At(i))
// For external types, only synthetic wrappers have code.
expExt := !strings.Contains(m.Synthetic, "wrapper")
if expExt && !isEmpty(m) {
@@ -303,7 +303,7 @@
}
prog := ssautil.CreateProgram(lprog, test.mode)
mainPkg := prog.Package(lprog.Created[0].Pkg)
- prog.BuildAll()
+ prog.Build()
initFunc := mainPkg.Func("init")
if initFunc == nil {
t.Errorf("test 'package %s': no init function", f.Name.Name)
@@ -374,7 +374,7 @@
// Create and build SSA
prog := ssautil.CreateProgram(lprog, 0)
- prog.BuildAll()
+ prog.Build()
// Enumerate reachable synthetic functions
want := map[string]string{
diff --git a/go/ssa/create.go b/go/ssa/create.go
index 88226ae..84a17fc 100644
--- a/go/ssa/create.go
+++ b/go/ssa/create.go
@@ -162,7 +162,7 @@
Prog: prog,
Members: make(map[string]Member),
values: make(map[types.Object]Value),
- Object: pkg,
+ Pkg: pkg,
info: info, // transient (CREATE and BUILD phases)
files: files, // transient (CREATE and BUILD phases)
}
@@ -190,7 +190,7 @@
// GC-compiled binary package.
// No code.
// No position information.
- scope := p.Object.Scope()
+ scope := p.Pkg.Scope()
for _, name := range scope.Names() {
obj := scope.Lookup(name)
memberFromObject(p, obj, nil)
@@ -224,9 +224,9 @@
}
if importable {
- prog.imported[p.Object.Path()] = p
+ prog.imported[p.Pkg.Path()] = p
}
- prog.packages[p.Object] = p
+ prog.packages[p.Pkg] = p
return p
}
diff --git a/go/ssa/example_test.go b/go/ssa/example_test.go
index 8f86a35..71d4fe1 100644
--- a/go/ssa/example_test.go
+++ b/go/ssa/example_test.go
@@ -132,7 +132,7 @@
prog := ssautil.CreateProgram(lprog, ssa.SanityCheckFunctions)
// Build SSA code for the entire cmd/cover program.
- prog.BuildAll()
+ prog.Build()
// Output:
}
diff --git a/go/ssa/func.go b/go/ssa/func.go
index a9c0f75..f1e545c 100644
--- a/go/ssa/func.go
+++ b/go/ssa/func.go
@@ -501,7 +501,7 @@
// Package-level function?
// Prefix with package name for cross-package references only.
- if p := f.pkgobj(); p != nil && p != from {
+ if p := f.pkg(); p != nil && p != from {
return fmt.Sprintf("%s.%s", p.Path(), f.name)
}
@@ -529,9 +529,9 @@
types.WriteSignature(buf, sig, types.RelativeTo(from))
}
-func (f *Function) pkgobj() *types.Package {
+func (f *Function) pkg() *types.Package {
if f.Pkg != nil {
- return f.Pkg.Object
+ return f.Pkg.Pkg
}
return nil
}
@@ -549,7 +549,7 @@
func WriteFunction(buf *bytes.Buffer, f *Function) {
fmt.Fprintf(buf, "# Name: %s\n", f.String())
if f.Pkg != nil {
- fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Object.Path())
+ fmt.Fprintf(buf, "# Package: %s\n", f.Pkg.Pkg.Path())
}
if syn := f.Synthetic; syn != "" {
fmt.Fprintln(buf, "# Synthetic:", syn)
@@ -566,7 +566,7 @@
fmt.Fprintf(buf, "# Recover: %s\n", f.Recover)
}
- from := f.pkgobj()
+ from := f.pkg()
if f.FreeVars != nil {
buf.WriteString("# Free variables:\n")
diff --git a/go/ssa/interp/interp.go b/go/ssa/interp/interp.go
index afe4939..6c65ec9 100644
--- a/go/ssa/interp/interp.go
+++ b/go/ssa/interp/interp.go
@@ -619,7 +619,7 @@
*g = v
return
}
- panic("no global variable: " + pkg.Object.Path() + "." + name)
+ panic("no global variable: " + pkg.Pkg.Path() + "." + name)
}
var environ []value
@@ -687,7 +687,7 @@
}
// Ad-hoc initialization for magic system variables.
- switch pkg.Object.Path() {
+ switch pkg.Pkg.Path() {
case "syscall":
setGlobal(i, pkg, "envs", environ)
@@ -695,7 +695,7 @@
deleteBodies(pkg, "DeepEqual", "deepValueEqual")
case "runtime":
- sz := sizes.Sizeof(pkg.Object.Scope().Lookup("MemStats").Type())
+ sz := sizes.Sizeof(pkg.Pkg.Scope().Lookup("MemStats").Type())
setGlobal(i, pkg, "sizeof_C_MStats", uintptr(sz))
deleteBodies(pkg, "GOROOT", "gogetenv")
}
diff --git a/go/ssa/interp/interp_test.go b/go/ssa/interp/interp_test.go
index f36c23e..45509d5 100644
--- a/go/ssa/interp/interp_test.go
+++ b/go/ssa/interp/interp_test.go
@@ -219,7 +219,7 @@
}
prog := ssautil.CreateProgram(iprog, ssa.SanityCheckFunctions)
- prog.BuildAll()
+ prog.Build()
var mainPkg *ssa.Package
var initialPkgs []*ssa.Package
diff --git a/go/ssa/interp/reflect.go b/go/ssa/interp/reflect.go
index 468771b..d2d7a69 100644
--- a/go/ssa/interp/reflect.go
+++ b/go/ssa/interp/reflect.go
@@ -520,7 +520,7 @@
func initReflect(i *interpreter) {
i.reflectPackage = &ssa.Package{
Prog: i.prog,
- Object: reflectTypesPackage,
+ Pkg: reflectTypesPackage,
Members: make(map[string]ssa.Member),
}
@@ -539,18 +539,18 @@
// provide fake source files. This would guarantee that no bad
// information leaks into other packages.
if r := i.prog.ImportedPackage("reflect"); r != nil {
- rV := r.Object.Scope().Lookup("Value").Type().(*types.Named)
+ rV := r.Pkg.Scope().Lookup("Value").Type().(*types.Named)
// delete bodies of the old methods
mset := i.prog.MethodSets.MethodSet(rV)
for j := 0; j < mset.Len(); j++ {
- i.prog.Method(mset.At(j)).Blocks = nil
+ i.prog.MethodValue(mset.At(j)).Blocks = nil
}
tEface := types.NewInterface(nil, nil).Complete()
rV.SetUnderlying(types.NewStruct([]*types.Var{
- types.NewField(token.NoPos, r.Object, "t", tEface, false), // a lie
- types.NewField(token.NoPos, r.Object, "v", tEface, false),
+ types.NewField(token.NoPos, r.Pkg, "t", tEface, false), // a lie
+ types.NewField(token.NoPos, r.Pkg, "v", tEface, false),
}, nil))
}
diff --git a/go/ssa/methods.go b/go/ssa/methods.go
index 12534de..bb35639 100644
--- a/go/ssa/methods.go
+++ b/go/ssa/methods.go
@@ -12,20 +12,17 @@
"golang.org/x/tools/go/types"
)
-// Method returns the Function implementing method sel, building
+// MethodValue returns the Function implementing method sel, building
// wrapper methods on demand. It returns nil if sel denotes an
// abstract (interface) method.
//
// Precondition: sel.Kind() == MethodVal.
//
-// TODO(adonovan): rename this to MethodValue because of the
-// precondition, and for consistency with functions in source.go.
-//
// Thread-safe.
//
// EXCLUSIVE_LOCKS_ACQUIRED(prog.methodsMu)
//
-func (prog *Program) Method(sel *types.Selection) *Function {
+func (prog *Program) MethodValue(sel *types.Selection) *Function {
if sel.Kind() != types.MethodVal {
panic(fmt.Sprintf("Method(%s) kind != MethodVal", sel))
}
@@ -52,7 +49,7 @@
if sel == nil {
panic(fmt.Sprintf("%s has no method %s", T, types.Id(pkg, name)))
}
- return prog.Method(sel)
+ return prog.MethodValue(sel)
}
// methodSet contains the (concrete) methods of a non-interface type.
diff --git a/go/ssa/print.go b/go/ssa/print.go
index 88c31f6..679fa8d 100644
--- a/go/ssa/print.go
+++ b/go/ssa/print.go
@@ -27,7 +27,7 @@
func relName(v Value, i Instruction) string {
var from *types.Package
if i != nil {
- from = i.Parent().pkgobj()
+ from = i.Parent().pkg()
}
switch v := v.(type) {
case Member: // *Function or *Global
@@ -45,8 +45,8 @@
func relString(m Member, from *types.Package) string {
// NB: not all globals have an Object (e.g. init$guard),
// so use Package().Object not Object.Package().
- if obj := m.Package().Object; obj != nil && obj != from {
- return fmt.Sprintf("%s.%s", obj.Path(), m.Name())
+ if pkg := m.Package().Pkg; pkg != nil && pkg != from {
+ return fmt.Sprintf("%s.%s", pkg.Path(), m.Name())
}
return m.Name()
}
@@ -57,12 +57,12 @@
// It never appears in disassembly, which uses Value.Name().
func (v *Parameter) String() string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("parameter %s : %s", v.Name(), relType(v.Type(), from))
}
func (v *FreeVar) String() string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("freevar %s : %s", v.Name(), relType(v.Type(), from))
}
@@ -77,7 +77,7 @@
if v.Heap {
op = "new"
}
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("%s %s (%s)", op, relType(deref(v.Type()), from), v.Comment)
}
@@ -147,7 +147,7 @@
}
func printConv(prefix string, v, x Value) string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("%s %s <- %s (%s)",
prefix,
relType(v.Type(), from),
@@ -177,7 +177,7 @@
}
func (v *MakeSlice) String() string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("make %s %s %s",
relType(v.Type(), from),
relName(v.Len, v),
@@ -209,12 +209,12 @@
if v.Reserve != nil {
res = relName(v.Reserve, v)
}
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("make %s %s", relType(v.Type(), from), res)
}
func (v *MakeChan) String() string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("make %s %s", relType(v.Type(), from), relName(v.Size, v))
}
@@ -259,7 +259,7 @@
}
func (v *TypeAssert) String() string {
- from := v.Parent().pkgobj()
+ from := v.Parent().pkg()
return fmt.Sprintf("typeassert%s %s.(%s)", commaOk(v.CommaOk), relName(v.X, v), relType(v.AssertedType, from))
}
@@ -366,7 +366,7 @@
}
func (p *Package) String() string {
- return "package " + p.Object.Path()
+ return "package " + p.Pkg.Path()
}
var _ io.WriterTo = (*Package)(nil) // *Package implements io.Writer
@@ -391,7 +391,7 @@
names = append(names, name)
}
- from := p.Object
+ from := p.Pkg
sort.Strings(names)
for _, name := range names {
switch mem := p.Members[name].(type) {
diff --git a/go/ssa/sanity.go b/go/ssa/sanity.go
index b0593d0..262ed46 100644
--- a/go/ssa/sanity.go
+++ b/go/ssa/sanity.go
@@ -407,8 +407,8 @@
s.errorf("nil Prog")
}
- fn.String() // must not crash
- fn.RelString(fn.pkgobj()) // must not crash
+ fn.String() // must not crash
+ fn.RelString(fn.pkg()) // must not crash
// All functions have a package, except delegates (which are
// shared across packages, or duplicated as weak symbols in a
@@ -484,7 +484,7 @@
// It does not require that the package is built.
// Unlike sanityCheck (for functions), it just panics at the first error.
func sanityCheckPackage(pkg *Package) {
- if pkg.Object == nil {
+ if pkg.Pkg == nil {
panic(fmt.Sprintf("Package %s has no Object", pkg))
}
pkg.String() // must not crash
@@ -492,7 +492,7 @@
for name, mem := range pkg.Members {
if name != mem.Name() {
panic(fmt.Sprintf("%s: %T.Name() = %s, want %s",
- pkg.Object.Path(), mem, mem.Name(), name))
+ pkg.Pkg.Path(), mem, mem.Name(), name))
}
obj := mem.Object()
if obj == nil {
@@ -510,7 +510,7 @@
// its types.Func ("init") and its ssa.Function ("init#%d").
} else {
panic(fmt.Sprintf("%s: %T.Object().Name() = %s, want %s",
- pkg.Object.Path(), mem, obj.Name(), name))
+ pkg.Pkg.Path(), mem, obj.Name(), name))
}
}
if obj.Pos() != mem.Pos() {
diff --git a/go/ssa/ssa.go b/go/ssa/ssa.go
index f4c64bb..b24c195 100644
--- a/go/ssa/ssa.go
+++ b/go/ssa/ssa.go
@@ -45,7 +45,7 @@
//
type Package struct {
Prog *Program // the owning program
- Object *types.Package // the type checker's package object for this package
+ Pkg *types.Package // the corresponding go/types.Package
Members map[string]Member // all package members keyed by name (incl. init and init#%d)
values map[types.Object]Value // package members (incl. types and methods), keyed by object
init *Function // Func("init"); the package's init function
diff --git a/go/ssa/ssautil/visit.go b/go/ssa/ssautil/visit.go
index 30843c3..6c51f93 100644
--- a/go/ssa/ssautil/visit.go
+++ b/go/ssa/ssautil/visit.go
@@ -44,7 +44,7 @@
for _, T := range visit.prog.RuntimeTypes() {
mset := visit.prog.MethodSets.MethodSet(T)
for i, n := 0, mset.Len(); i < n; i++ {
- visit.function(visit.prog.Method(mset.At(i)))
+ visit.function(visit.prog.MethodValue(mset.At(i)))
}
}
}
diff --git a/go/ssa/stdlib_test.go b/go/ssa/stdlib_test.go
index 5726016..1392b40 100644
--- a/go/ssa/stdlib_test.go
+++ b/go/ssa/stdlib_test.go
@@ -80,7 +80,7 @@
t2 := time.Now()
// Build SSA.
- prog.BuildAll()
+ prog.Build()
t3 := time.Now()
alloc3 := bytesAllocated()
diff --git a/go/ssa/testmain.go b/go/ssa/testmain.go
index a7b1242..3cb23bc 100644
--- a/go/ssa/testmain.go
+++ b/go/ssa/testmain.go
@@ -102,7 +102,7 @@
Prog: prog,
Members: make(map[string]Member),
values: make(map[types.Object]Value),
- Object: types.NewPackage("test$main", "main"),
+ Pkg: types.NewPackage("test$main", "main"),
}
// Build package's init function.
@@ -127,23 +127,23 @@
v.setType(types.NewTuple())
init.emit(&v)
- pkgpaths = append(pkgpaths, pkg.Object.Path())
+ pkgpaths = append(pkgpaths, pkg.Pkg.Path())
}
sort.Strings(pkgpaths)
init.emit(new(Return))
init.finishBody()
testmain.init = init
- testmain.Object.MarkComplete()
+ testmain.Pkg.MarkComplete()
testmain.Members[init.name] = init
// For debugging convenience, define an unexported const
// that enumerates the packages.
- packagesConst := types.NewConst(token.NoPos, testmain.Object, "packages", tString,
+ packagesConst := types.NewConst(token.NoPos, testmain.Pkg, "packages", tString,
exact.MakeString(strings.Join(pkgpaths, " ")))
memberFromObject(testmain, packagesConst, nil)
// Create main *types.Func and *ssa.Function
- mainFunc := types.NewFunc(token.NoPos, testmain.Object, "main", new(types.Signature))
+ mainFunc := types.NewFunc(token.NoPos, testmain.Pkg, "main", new(types.Signature))
memberFromObject(testmain, mainFunc, nil)
main := testmain.Func("main")
main.Synthetic = "test main function"
@@ -222,7 +222,7 @@
sanityCheckPackage(testmain)
}
- prog.packages[testmain.Object] = testmain
+ prog.packages[testmain.Pkg] = testmain
return testmain
}
