code review 7199052: exp/ssa: (#2 of 5): core utilities

src/pkg/exp/ssa/print.go

 package ssa
 
 // This file implements the String() methods for all Value and
 // Instruction types.
 
 import (
         "bytes"
         "fmt"
         "go/ast"
         "go/types"
-        "reflect"
 )
 
 func (id Id) String() string {
         if id.Pkg == nil {
                 return id.Name
         }
         return fmt.Sprintf("%s/%s", id.Pkg.Path, id.Name)
 }
 
 // relName returns the name of v relative to i.
 // In most cases, this is identical to v.Name(), but for cross-package
 // references to Functions (including methods) and Globals, the

[iant, 2013/01/25 05:33:02]

You can have cross-package references to types and consts, too.

[adonovan, 2013/01/25 15:04:44]

Yes, but types are not SSA values and constants (Literal) do are not belong to
any particular package.  (A Package has a map[string]*Literal for each 'const'
decl but the Literal itself doesn't know about this.)

So only Function and Global concern us here.

 // package-qualified FullName is used instead.
 //
 func relName(v Value, i Instruction) string {
         switch v := v.(type) {
         case *Global:
                 if v.Pkg == i.Block().Func.Pkg {
                         return v.Name()
                 }
                 return v.FullName()
         case *Function:
                 if v.Pkg == nil || v.Pkg == i.Block().Func.Pkg {
                         return v.Name()
                 }
                 return v.FullName()
         }
         return v.Name()
 }
 
 // Value.String()
 //
 // This method is provided only for debugging.
 // It never appears in disassembly, which uses Value.Name().
 
 func (v *Literal) String() string {
-        return fmt.Sprintf("literal %s rep=%s", v.Name(), reflect.TypeOf(v.Value))

[iant, 2013/01/25 05:33:02]

suggest rep=%T and just passing v.Value rather than calling reflect.Typeof
yourself.

[adonovan, 2013/01/25 15:04:44]

Oh, that's nice.  Done everywhere.

+        return fmt.Sprintf("literal %s rep=%T", v.Name(), v.Value)
 }
 
 func (v *Parameter) String() string {
         return fmt.Sprintf("parameter %s : %s", v.Name(), v.Type())
 }
 
 func (v *Capture) String() string {
         return fmt.Sprintf("capture %s : %s", v.Name(), v.Type())
 }
 
 func (v *Global) String() string {
         return fmt.Sprintf("global %s : %s", v.Name(), v.Type())
 }
 
 func (v *Builtin) String() string {
         return fmt.Sprintf("builtin %s : %s", v.Name(), v.Type())
 }
 
 func (r *Function) String() string {
         return fmt.Sprintf("function %s : %s", r.Name(), r.Type())
+}
+
+// FullName returns the name of this function qualified by the
+// package name, unless it is anonymous or synthetic.
+//
+// TODO(adonovan): move to func.go when it's submitted.
+//
+func (f *Function) FullName() string {
+        if f.Enclosing != nil || f.Pkg == nil {
+                return f.Name_ // anonymous or synthetic
+        }
+        return fmt.Sprintf("%s.%s", f.Pkg.ImportPath, f.Name_)
+}
+
+// FullName returns g's package-qualified name.
+func (g *Global) FullName() string {
+        return fmt.Sprintf("%s.%s", g.Pkg.ImportPath, g.Name_)
 }
 
 // Instruction.String()
 
 func (v *Alloc) String() string {
         op := "local"
         if v.Heap {
                 op = "new"
         }
         return fmt.Sprintf("%s %s", op, indirectType(v.Type()))
@@ skipping 237 matching lines @@
 }
 
 func (s *Store) String() string {
         return fmt.Sprintf("*%s = %s", relName(s.Addr, s), relName(s.Val, s))
 }
 
 func (s *MapUpdate) String() string {
         return fmt.Sprintf("%s[%s] = %s", relName(s.Map, s), relName(s.Key, s), relName(s.Value, s))
 }
 
-// Package.String()

[iant, 2013/01/25 05:33:02]

Not sure this comment adds much here.

[adonovan, 2013/01/25 15:04:44]

Deleted.

-
 func (p *Package) String() string {
         // TODO(adonovan): prettify output.
         var b bytes.Buffer
         fmt.Fprintf(&b, "Package %s at %s:\n", p.ImportPath, p.Prog.Files.File(p.Pos).Name())
 
         // TODO(adonovan): make order deterministic.
         maxname := 0
         for name := range p.Members {
                 if l := len(name); l > maxname {
                         maxname = l
@@ skipping 22 matching lines @@
         }
         return b.String()
 }
 
 func commaOk(x bool) string {
         if x {
                 return ",ok"
         }
         return ""
 }