[dev.regabi] cmd/compile: convert types.Node (a pointer) to types.IRNode (an interface)

The pointer hack was nice and saved a word, but it's untenable
in a world where nodes are themselves interfaces with different
underlying types. Bite the bullet and use an interface to hold the
Node when in types.Sym and types.Type.

This has the nice benefit of removing AsTypesNode entirely.
AsNode is still useful because of its nil handling.

Change-Id: I298cba9ff788b956ee287283bec78010e8b601e5
Reviewed-on: https://go-review.googlesource.com/c/go/+/272933
Trust: Russ Cox <rsc@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/gc/closure.go b/src/cmd/compile/internal/gc/closure.go
index 1b926ec17e48b5b03efb3f817b172ce971e180d4..2dce7b7f037684d6cc7ff85597826c6d22a1125a 100644 (file)
--- a/src/cmd/compile/internal/gc/closure.go
+++ b/src/cmd/compile/internal/gc/closure.go
@@ -270,7 +270,7 @@ func transformclosure(dcl *ir.Node) {
                        decls = append(decls, v)
 
                        fld := types.NewField(src.NoXPos, v.Sym(), v.Type())
-                       fld.Nname = ir.AsTypesNode(v)
+                       fld.Nname = v
                        params = append(params, fld)
                }
 
@@ -511,7 +511,7 @@ func makepartialcall(dot *ir.Node, t0 *types.Type, meth *types.Sym) *ir.Node {
        // typecheckslice() requires that Curfn is set when processing an ORETURN.
        Curfn = dcl
        typecheckslice(dcl.Body().Slice(), ctxStmt)
-       sym.Def = ir.AsTypesNode(dcl)
+       sym.Def = dcl
        xtop = append(xtop, dcl)
        Curfn = savecurfn
        base.Pos = saveLineNo

diff --git a/src/cmd/compile/internal/gc/dcl.go b/src/cmd/compile/internal/gc/dcl.go
index 8b3274890f3c2ce3b044599cef46a3bf589c7a6e..8980c47e2c39e69c4050bd5a1e7d9743d8226f5c 100644 (file)
--- a/src/cmd/compile/internal/gc/dcl.go
+++ b/src/cmd/compile/internal/gc/dcl.go
@@ -118,7 +118,7 @@ func declare(n *ir.Node, ctxt ir.Class) {
 
        s.Block = types.Block
        s.Lastlineno = base.Pos
-       s.Def = ir.AsTypesNode(n)
+       s.Def = n
        n.Name().Vargen = int32(gen)
        n.SetClass(ctxt)
        if ctxt == ir.PFUNC {
@@ -235,7 +235,7 @@ func typenodl(pos src.XPos, t *types.Type) *ir.Node {
        // then t->nod might be out of date, so
        // check t->nod->type too
        if ir.AsNode(t.Nod) == nil || ir.AsNode(t.Nod).Type() != t {
-               t.Nod = ir.AsTypesNode(ir.NodAt(pos, ir.OTYPE, nil, nil))
+               t.Nod = ir.NodAt(pos, ir.OTYPE, nil, nil)
                ir.AsNode(t.Nod).SetType(t)
                ir.AsNode(t.Nod).SetSym(t.Sym)
        }
@@ -490,7 +490,7 @@ func funcarg2(f *types.Field, ctxt ir.Class) {
                return
        }
        n := ir.NewNameAt(f.Pos, f.Sym)
-       f.Nname = ir.AsTypesNode(n)
+       f.Nname = n
        n.SetType(f.Type)
        n.SetIsDDD(f.IsDDD())
        declare(n, ctxt)
@@ -614,7 +614,7 @@ func tofunargs(l []*ir.Node, funarg types.Funarg) *types.Type {
                f.SetIsDDD(n.IsDDD())
                if n.Right() != nil {
                        n.Right().SetType(f.Type)
-                       f.Nname = ir.AsTypesNode(n.Right())
+                       f.Nname = n.Right()
                }
                if f.Broke() {
                        t.SetBroke(true)
@@ -872,7 +872,7 @@ func addmethod(n *ir.Node, msym *types.Sym, t *types.Type, local, nointerface bo
        }
 
        f := types.NewField(base.Pos, msym, t)
-       f.Nname = ir.AsTypesNode(n.Func().Nname)
+       f.Nname = n.Func().Nname
        f.SetNointerface(nointerface)
 
        mt.Methods().Append(f)

diff --git a/src/cmd/compile/internal/gc/embed.go b/src/cmd/compile/internal/gc/embed.go
index d515696add2421e7883afd60657e135ec2635a94..03703f68d5fa31dce0f5ee24ea133ca01589bfdd 100644 (file)
--- a/src/cmd/compile/internal/gc/embed.go
+++ b/src/cmd/compile/internal/gc/embed.go
@@ -114,7 +114,7 @@ func varEmbed(p *noder, names []*ir.Node, typ *ir.Node, exprs []*ir.Node, embeds
        if dclcontext != ir.PEXTERN {
                numLocalEmbed++
                v = ir.NewNameAt(v.Pos(), lookupN("embed.", numLocalEmbed))
-               v.Sym().Def = ir.AsTypesNode(v)
+               v.Sym().Def = v
                v.Name().Param.Ntype = typ
                v.SetClass(ir.PEXTERN)
                externdcl = append(externdcl, v)

diff --git a/src/cmd/compile/internal/gc/escape.go b/src/cmd/compile/internal/gc/escape.go
index 866bdf8a6f6a710147ba2daf4bef5e74f2ad7bf3..f1786e74dcf10e669dd520eb7bde4264e98c2cd4 100644 (file)
--- a/src/cmd/compile/internal/gc/escape.go
+++ b/src/cmd/compile/internal/gc/escape.go
@@ -229,13 +229,13 @@ func (e *Escape) walkFunc(fn *ir.Node) {
        ir.InspectList(fn.Body(), func(n *ir.Node) bool {
                switch n.Op() {
                case ir.OLABEL:
-                       n.Sym().Label = ir.AsTypesNode(nonlooping)
+                       n.Sym().Label = nonlooping
 
                case ir.OGOTO:
                        // If we visited the label before the goto,
                        // then this is a looping label.
-                       if n.Sym().Label == ir.AsTypesNode(nonlooping) {
-                               n.Sym().Label = ir.AsTypesNode(looping)
+                       if n.Sym().Label == nonlooping {
+                               n.Sym().Label = looping
                        }
                }
 

diff --git a/src/cmd/compile/internal/gc/export.go b/src/cmd/compile/internal/gc/export.go
index 1f0288a5911a3edc64c8f1c5358ef9075a9d511c..ace461fc90fec2971165dc51ba86fc05e5956954 100644 (file)
--- a/src/cmd/compile/internal/gc/export.go
+++ b/src/cmd/compile/internal/gc/export.go
@@ -86,7 +86,7 @@ func importsym(ipkg *types.Pkg, s *types.Sym, op ir.Op) *ir.Node {
                }
 
                n = dclname(s)
-               s.SetPkgDef(ir.AsTypesNode(n))
+               s.SetPkgDef(n)
                s.Importdef = ipkg
        }
        if n.Op() != ir.ONONAME && n.Op() != op {
@@ -103,7 +103,7 @@ func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *types.Type {
        if n.Op() != ir.OTYPE {
                t := types.New(types.TFORW)
                t.Sym = s
-               t.Nod = ir.AsTypesNode(n)
+               t.Nod = n
 
                n.SetOp(ir.OTYPE)
                n.SetPos(pos)

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index d7320f3cccbbb107b417aad6a7248ef19fed8627..a89ff528e5266fe4e517b5447a41fdfb89eddccc 100644 (file)
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -69,7 +69,7 @@ func tempAt(pos src.XPos, curfn *ir.Node, t *types.Type) *ir.Node {
                Pkg:  ir.LocalPkg,
        }
        n := ir.NewNameAt(pos, s)
-       s.Def = ir.AsTypesNode(n)
+       s.Def = n
        n.SetType(t)
        n.SetClass(ir.PAUTO)
        n.SetEsc(EscNever)

diff --git a/src/cmd/compile/internal/gc/iimport.go b/src/cmd/compile/internal/gc/iimport.go
index 71063566659b2cdc6e72c6938972f8841743758e..5d845d90e84dcbea61665bc7219f4a64dc000e7d 100644 (file)
--- a/src/cmd/compile/internal/gc/iimport.go
+++ b/src/cmd/compile/internal/gc/iimport.go
@@ -151,7 +151,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
                        ir.NumImport[pkgName]++
 
                        // TODO(mdempsky): This belongs somewhere else.
-                       pkg.Lookup("_").Def = ir.AsTypesNode(ir.BlankNode)
+                       pkg.Lookup("_").Def = ir.BlankNode
                } else {
                        if pkg.Name != pkgName {
                                base.Fatalf("conflicting package names %v and %v for path %q", pkg.Name, pkgName, pkg.Path)
@@ -175,7 +175,7 @@ func iimport(pkg *types.Pkg, in *bio.Reader) (fingerprint goobj.FingerprintType)
                        if s.Def != nil {
                                base.Fatalf("unexpected definition for %v: %v", s, ir.AsNode(s.Def))
                        }
-                       s.Def = ir.AsTypesNode(npos(src.NoXPos, dclname(s)))
+                       s.Def = npos(src.NoXPos, dclname(s))
                }
        }
 
@@ -337,7 +337,7 @@ func (r *importReader) doDecl(n *ir.Node) {
                        // methodSym already marked m.Sym as a function.
 
                        f := types.NewField(mpos, msym, mtyp)
-                       f.Nname = ir.AsTypesNode(m)
+                       f.Nname = m
                        ms[i] = f
                }
                t.Methods().Set(ms)

diff --git a/src/cmd/compile/internal/gc/init.go b/src/cmd/compile/internal/gc/init.go
index b66ee6f9533d39a8ae254fa1757fcc63a94c6d1e..02a6175c6bf9d648e9f6a3ae235b3cd0fb4a96fd 100644 (file)
--- a/src/cmd/compile/internal/gc/init.go
+++ b/src/cmd/compile/internal/gc/init.go
@@ -93,7 +93,7 @@ func fninit(n []*ir.Node) {
        nn := NewName(sym)
        nn.SetType(types.Types[types.TUINT8]) // fake type
        nn.SetClass(ir.PEXTERN)
-       sym.Def = ir.AsTypesNode(nn)
+       sym.Def = nn
        exportsym(nn)
        lsym := sym.Linksym()
        ot := 0

diff --git a/src/cmd/compile/internal/gc/noder.go b/src/cmd/compile/internal/gc/noder.go
index 98819fadde5aa4445f3cf4f0a18dd59af1f22a81..d9642f4b672f961c49842272b816c661e328237d 100644 (file)
--- a/src/cmd/compile/internal/gc/noder.go
+++ b/src/cmd/compile/internal/gc/noder.go
@@ -373,7 +373,7 @@ func (p *noder) importDecl(imp *syntax.ImportDecl) {
        if my.Def != nil {
                redeclare(pack.Pos(), my, "as imported package name")
        }
-       my.Def = ir.AsTypesNode(pack)
+       my.Def = pack
        my.Lastlineno = pack.Pos()
        my.Block = 1 // at top level
 }

diff --git a/src/cmd/compile/internal/gc/obj.go b/src/cmd/compile/internal/gc/obj.go
index 9f0cefbd1cb9add0667a80b206e6e9965577cc0b..05f8358fdfa6dc5bbe812f549e995127fe8dfe54 100644 (file)
--- a/src/cmd/compile/internal/gc/obj.go
+++ b/src/cmd/compile/internal/gc/obj.go
@@ -480,7 +480,7 @@ func slicedata(pos src.XPos, s string) *ir.Node {
        symname := fmt.Sprintf(".gobytes.%d", slicedataGen)
        sym := ir.LocalPkg.Lookup(symname)
        symnode := NewName(sym)
-       sym.Def = ir.AsTypesNode(symnode)
+       sym.Def = symnode
 
        lsym := sym.Linksym()
        off := dstringdata(lsym, 0, s, pos, "slice")

diff --git a/src/cmd/compile/internal/gc/reflect.go b/src/cmd/compile/internal/gc/reflect.go
index 4559dd3a219f5a92e1046150910ddd80d9905d7b..664b3cc942139695540891adcfafabfdfcfcd513 100644 (file)
--- a/src/cmd/compile/internal/gc/reflect.go
+++ b/src/cmd/compile/internal/gc/reflect.go
@@ -997,7 +997,7 @@ func typename(t *types.Type) *ir.Node {
                n.SetType(types.Types[types.TUINT8])
                n.SetClass(ir.PEXTERN)
                n.SetTypecheck(1)
-               s.Def = ir.AsTypesNode(n)
+               s.Def = n
        }
 
        n := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
@@ -1016,7 +1016,7 @@ func itabname(t, itype *types.Type) *ir.Node {
                n.SetType(types.Types[types.TUINT8])
                n.SetClass(ir.PEXTERN)
                n.SetTypecheck(1)
-               s.Def = ir.AsTypesNode(n)
+               s.Def = n
                itabs = append(itabs, itabEntry{t: t, itype: itype, lsym: s.Linksym()})
        }
 
@@ -1882,7 +1882,7 @@ func zeroaddr(size int64) *ir.Node {
                x.SetType(types.Types[types.TUINT8])
                x.SetClass(ir.PEXTERN)
                x.SetTypecheck(1)
-               s.Def = ir.AsTypesNode(x)
+               s.Def = x
        }
        z := ir.Nod(ir.OADDR, ir.AsNode(s.Def), nil)
        z.SetType(types.NewPtr(types.Types[types.TUINT8]))

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 018b94d9d80113368027de54a675a42a417d76ba..262aa0e95cf597d29fd009f52e746e0646a1868d 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -7072,7 +7072,7 @@ func (e *ssafn) SplitSlot(parent *ssa.LocalSlot, suffix string, offset int64, t
 
        s := &types.Sym{Name: node.Sym().Name + suffix, Pkg: ir.LocalPkg}
        n := ir.NewNameAt(parent.N.Pos(), s)
-       s.Def = ir.AsTypesNode(n)
+       s.Def = n
        ir.AsNode(s.Def).Name().SetUsed(true)
        n.SetType(t)
        n.SetClass(ir.PAUTO)

diff --git a/src/cmd/compile/internal/gc/typecheck.go b/src/cmd/compile/internal/gc/typecheck.go
index 4bc7f035f5090441b05382632b210446c94a8135..0559dabe32ac96cf9966c808f30f3a98f92d5ead 100644 (file)
--- a/src/cmd/compile/internal/gc/typecheck.go
+++ b/src/cmd/compile/internal/gc/typecheck.go
@@ -3486,7 +3486,7 @@ func setUnderlying(t, underlying *types.Type) {
        *t = *underlying
 
        // Restore unnecessarily clobbered attributes.
-       t.Nod = ir.AsTypesNode(n)
+       t.Nod = n
        t.Sym = n.Sym()
        if n.Name() != nil {
                t.Vargen = n.Name().Vargen
@@ -3691,7 +3691,7 @@ func typecheckdef(n *ir.Node) {
                                // For package-level type aliases, set n.Sym.Def so we can identify
                                // it as a type alias during export. See also #31959.
                                if n.Name().Curfn == nil {
-                                       n.Sym().Def = ir.AsTypesNode(p.Ntype)
+                                       n.Sym().Def = p.Ntype
                                }
                        }
                        break
@@ -3799,7 +3799,7 @@ func markbreaklist(l ir.Nodes, implicit *ir.Node) {
                if n.Op() == ir.OLABEL && i+1 < len(s) && n.Name().Defn == s[i+1] {
                        switch n.Name().Defn.Op() {
                        case ir.OFOR, ir.OFORUNTIL, ir.OSWITCH, ir.OTYPESW, ir.OSELECT, ir.ORANGE:
-                               n.Sym().Label = ir.AsTypesNode(n.Name().Defn)
+                               n.Sym().Label = n.Name().Defn
                                markbreak(n.Name().Defn, n.Name().Defn)
                                n.Sym().Label = nil
                                i++
@@ -3998,7 +3998,7 @@ func deadcodeexpr(n *ir.Node) *ir.Node {
 func setTypeNode(n *ir.Node, t *types.Type) {
        n.SetOp(ir.OTYPE)
        n.SetType(t)
-       n.Type().Nod = ir.AsTypesNode(n)
+       n.Type().Nod = n
 }
 
 // getIotaValue returns the current value for "iota",

diff --git a/src/cmd/compile/internal/gc/universe.go b/src/cmd/compile/internal/gc/universe.go
index be22b7e9dbee9fc63951bfbf569f23dce8a53a8b..978e53ac159a72e61595933d3bb58208b076eaf3 100644 (file)
--- a/src/cmd/compile/internal/gc/universe.go
+++ b/src/cmd/compile/internal/gc/universe.go
@@ -109,19 +109,19 @@ func lexinit() {
                        }
                        types.Types[etype] = t
                }
-               s2.Def = ir.AsTypesNode(typenod(t))
+               s2.Def = typenod(t)
                ir.AsNode(s2.Def).SetName(new(ir.Name))
        }
 
        for _, s := range &builtinFuncs {
                s2 := ir.BuiltinPkg.Lookup(s.name)
-               s2.Def = ir.AsTypesNode(NewName(s2))
+               s2.Def = NewName(s2)
                ir.AsNode(s2.Def).SetSubOp(s.op)
        }
 
        for _, s := range &unsafeFuncs {
                s2 := unsafepkg.Lookup(s.name)
-               s2.Def = ir.AsTypesNode(NewName(s2))
+               s2.Def = NewName(s2)
                ir.AsNode(s2.Def).SetSubOp(s.op)
        }
 
@@ -130,38 +130,38 @@ func lexinit() {
        types.Types[types.TANY] = types.New(types.TANY)
 
        s := ir.BuiltinPkg.Lookup("true")
-       s.Def = ir.AsTypesNode(nodbool(true))
+       s.Def = nodbool(true)
        ir.AsNode(s.Def).SetSym(lookup("true"))
        ir.AsNode(s.Def).SetName(new(ir.Name))
        ir.AsNode(s.Def).SetType(types.UntypedBool)
 
        s = ir.BuiltinPkg.Lookup("false")
-       s.Def = ir.AsTypesNode(nodbool(false))
+       s.Def = nodbool(false)
        ir.AsNode(s.Def).SetSym(lookup("false"))
        ir.AsNode(s.Def).SetName(new(ir.Name))
        ir.AsNode(s.Def).SetType(types.UntypedBool)
 
        s = lookup("_")
        s.Block = -100
-       s.Def = ir.AsTypesNode(NewName(s))
+       s.Def = NewName(s)
        types.Types[types.TBLANK] = types.New(types.TBLANK)
        ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
        ir.BlankNode = ir.AsNode(s.Def)
 
        s = ir.BuiltinPkg.Lookup("_")
        s.Block = -100
-       s.Def = ir.AsTypesNode(NewName(s))
+       s.Def = NewName(s)
        types.Types[types.TBLANK] = types.New(types.TBLANK)
        ir.AsNode(s.Def).SetType(types.Types[types.TBLANK])
 
        types.Types[types.TNIL] = types.New(types.TNIL)
        s = ir.BuiltinPkg.Lookup("nil")
-       s.Def = ir.AsTypesNode(nodnil())
+       s.Def = nodnil()
        ir.AsNode(s.Def).SetSym(s)
        ir.AsNode(s.Def).SetName(new(ir.Name))
 
        s = ir.BuiltinPkg.Lookup("iota")
-       s.Def = ir.AsTypesNode(ir.Nod(ir.OIOTA, nil, nil))
+       s.Def = ir.Nod(ir.OIOTA, nil, nil)
        ir.AsNode(s.Def).SetSym(s)
        ir.AsNode(s.Def).SetName(new(ir.Name))
 }
@@ -181,7 +181,7 @@ func typeinit() {
        t := types.New(types.TUNSAFEPTR)
        types.Types[types.TUNSAFEPTR] = t
        t.Sym = unsafepkg.Lookup("Pointer")
-       t.Sym.Def = ir.AsTypesNode(typenod(t))
+       t.Sym.Def = typenod(t)
        ir.AsNode(t.Sym.Def).SetName(new(ir.Name))
        dowidth(types.Types[types.TUNSAFEPTR])
 
@@ -343,7 +343,7 @@ func lexinit1() {
        types.Errortype = makeErrorInterface()
        types.Errortype.Sym = s
        types.Errortype.Orig = makeErrorInterface()
-       s.Def = ir.AsTypesNode(typenod(types.Errortype))
+       s.Def = typenod(types.Errortype)
        dowidth(types.Errortype)
 
        // We create separate byte and rune types for better error messages
@@ -358,7 +358,7 @@ func lexinit1() {
        s = ir.BuiltinPkg.Lookup("byte")
        types.Bytetype = types.New(types.TUINT8)
        types.Bytetype.Sym = s
-       s.Def = ir.AsTypesNode(typenod(types.Bytetype))
+       s.Def = typenod(types.Bytetype)
        ir.AsNode(s.Def).SetName(new(ir.Name))
        dowidth(types.Bytetype)
 
@@ -366,7 +366,7 @@ func lexinit1() {
        s = ir.BuiltinPkg.Lookup("rune")
        types.Runetype = types.New(types.TINT32)
        types.Runetype.Sym = s
-       s.Def = ir.AsTypesNode(typenod(types.Runetype))
+       s.Def = typenod(types.Runetype)
        ir.AsNode(s.Def).SetName(new(ir.Name))
        dowidth(types.Runetype)
 
@@ -384,7 +384,7 @@ func lexinit1() {
                t := types.New(s.etype)
                t.Sym = s1
                types.Types[s.etype] = t
-               s1.Def = ir.AsTypesNode(typenod(t))
+               s1.Def = typenod(t)
                ir.AsNode(s1.Def).SetName(new(ir.Name))
                s1.Origpkg = ir.BuiltinPkg
 

diff --git a/src/cmd/compile/internal/ir/dump.go b/src/cmd/compile/internal/ir/dump.go
index 43d0742c73c33e99bdddff30378863e0d9ac7097..c4ea5af3d1feb6c10a1ce1291591d1dc107a9754 100644 (file)
--- a/src/cmd/compile/internal/ir/dump.go
+++ b/src/cmd/compile/internal/ir/dump.go
@@ -150,9 +150,6 @@ func (p *dumper) dump(x reflect.Value, depth int) {
        case src.XPos:
                p.printf("%s", base.FmtPos(v))
                return
-
-       case *types.Node:
-               x = reflect.ValueOf(AsNode(v))
        }
 
        switch x.Kind() {

diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index dce1bfdbefa1d76ed86933211dc2c68f0b90f390..b42ca5b8a3c3c9057c7e0e14b6bf95f7cce881fd 100644 (file)
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -10,7 +10,6 @@ import (
        "go/constant"
        "sort"
        "strings"
-       "unsafe"
 
        "cmd/compile/internal/base"
        "cmd/compile/internal/types"
@@ -1340,9 +1339,12 @@ type SymAndPos struct {
        Pos src.XPos  // line of call
 }
 
-func AsNode(n *types.Node) *Node { return (*Node)(unsafe.Pointer(n)) }
-
-func AsTypesNode(n *Node) *types.Node { return (*types.Node)(unsafe.Pointer(n)) }
+func AsNode(n types.IRNode) *Node {
+       if n == nil {
+               return nil
+       }
+       return n.(*Node)
+}
 
 var BlankNode *Node
 

diff --git a/src/cmd/compile/internal/types/scope.go b/src/cmd/compile/internal/types/scope.go
index 40d3d86ef11a4168db0f5f7c0221a1e94353ed88..33a02c543d1532e02e3a854c525d351e0ecf54c2 100644 (file)
--- a/src/cmd/compile/internal/types/scope.go
+++ b/src/cmd/compile/internal/types/scope.go
@@ -15,7 +15,7 @@ var Block int32        // current block number
 // restored once the block scope ends.
 type dsym struct {
        sym        *Sym // sym == nil indicates stack mark
-       def        *Node
+       def        IRNode
        block      int32
        lastlineno src.XPos // last declaration for diagnostic
 }
@@ -79,16 +79,16 @@ func IsDclstackValid() bool {
 }
 
 // PkgDef returns the definition associated with s at package scope.
-func (s *Sym) PkgDef() *Node {
+func (s *Sym) PkgDef() IRNode {
        return *s.pkgDefPtr()
 }
 
 // SetPkgDef sets the definition associated with s at package scope.
-func (s *Sym) SetPkgDef(n *Node) {
+func (s *Sym) SetPkgDef(n IRNode) {
        *s.pkgDefPtr() = n
 }
 
-func (s *Sym) pkgDefPtr() **Node {
+func (s *Sym) pkgDefPtr() *IRNode {
        // Look for outermost saved declaration, which must be the
        // package scope definition, if present.
        for _, d := range dclstack {

diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go
index 0cf343e8f13a838cbc7a4cb518cb2dd62888f316..2821d9a3c70541dc90a68e29fbd939d2792047c6 100644 (file)
--- a/src/cmd/compile/internal/types/sizeof_test.go
+++ b/src/cmd/compile/internal/types/sizeof_test.go
@@ -20,8 +20,8 @@ func TestSizeof(t *testing.T) {
                _32bit uintptr     // size on 32bit platforms
                _64bit uintptr     // size on 64bit platforms
        }{
-               {Sym{}, 52, 88},
-               {Type{}, 52, 88},
+               {Sym{}, 60, 104},
+               {Type{}, 56, 96},
                {Map{}, 20, 40},
                {Forward{}, 20, 32},
                {Func{}, 28, 48},

diff --git a/src/cmd/compile/internal/types/sym.go b/src/cmd/compile/internal/types/sym.go
index 07bce4d5cdbb81a3d4a18c0f4b135c54d4ea1610..046104d0dcf790bf66e5b3f51cf2d1dc0e42acd6 100644 (file)
--- a/src/cmd/compile/internal/types/sym.go
+++ b/src/cmd/compile/internal/types/sym.go
@@ -33,12 +33,12 @@ type Sym struct {
        Name string // object name
 
        // saved and restored by dcopy
-       Def        *Node    // definition: ONAME OTYPE OPACK or OLITERAL
+       Def        IRNode    // definition: ONAME OTYPE OPACK or OLITERAL
        Block      int32    // blocknumber to catch redeclaration
        Lastlineno src.XPos // last declaration for diagnostic
 
        flags   bitset8
-       Label   *Node // corresponding label (ephemeral)
+       Label   IRNode // corresponding label (ephemeral)
        Origpkg *Pkg  // original package for . import
 }
 

diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index b93409aac1a3c3888357635ef70b1698af324bef..8499a36edc8f51ff67dfdd486a58a97481fb59f0 100644 (file)
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -10,10 +10,10 @@ import (
        "fmt"
 )
 
-// Our own “Node” so we can refer to *gc.Node without actually
-// having a gc.Node. Necessary to break import cycles.
-// TODO(gri) try to eliminate soon
-type Node struct{ _ int }
+// IRNode represents an ir.Node, but without needing to import cmd/compile/internal/ir,
+// which would cause an import cycle. The uses in other packages must type assert
+// values of type IRNode to ir.Node or a more specific type.
+type IRNode interface{ Type() *Type }
 
 //go:generate stringer -type EType -trimprefix T
 
@@ -141,8 +141,8 @@ type Type struct {
        methods    Fields
        allMethods Fields
 
-       Nod  *Node // canonical OTYPE node
-       Orig *Type // original type (type literal or predefined type)
+       Nod  IRNode // canonical OTYPE node
+       Orig *Type  // original type (type literal or predefined type)
 
        // Cache of composite types, with this type being the element type.
        Cache struct {
@@ -360,7 +360,7 @@ type Field struct {
 
        // For fields that represent function parameters, Nname points
        // to the associated ONAME Node.
-       Nname *Node
+       Nname IRNode
 
        // Offset in bytes of this field or method within its enclosing struct
        // or interface Type.