cmd/compile: unexport Type.Vargen

This field is only used outside of packages types in two places, and
they follow the same pattern. So this CL creates a Type.Setvargen
function that they can use instead, so that Type.Vargen can be
unexported.

A bit clumsy, but it works for now.

Change-Id: I7b4f33fac635e2464df2fbc0607ab40902f6f09f
Reviewed-on: https://go-review.googlesource.com/c/go/+/345469
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>

diff --git a/src/cmd/compile/internal/noder/decl.go b/src/cmd/compile/internal/noder/decl.go
index b23dd47600898f3aa104790f406ae12f7055f74c..54a13b498b959c7eaf211d38954efdfeb14c8084 100644 (file)
--- a/src/cmd/compile/internal/noder/decl.go
+++ b/src/cmd/compile/internal/noder/decl.go
@@ -154,8 +154,7 @@ func (g *irgen) typeDecl(out *ir.Nodes, decl *syntax.TypeDecl) {
        name, obj := g.def(decl.Name)
        ntyp, otyp := name.Type(), obj.Type()
        if ir.CurFunc != nil {
-               typecheck.TypeGen++
-               ntyp.Vargen = typecheck.TypeGen
+               ntyp.SetVargen()
        }
 
        pragmas := g.pragmaFlags(decl.Pragma, typePragmas)

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index db1b11c4cfd0a952a4aa22f1b4d3751381d25e19..404af5b1b2c3f009189d85bda6cffec83a878310 100644 (file)
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -1736,11 +1736,6 @@ func CheckMapKeys() {
        mapqueue = nil
 }
 
-// TypeGen tracks the number of function-scoped defined types that
-// have been declared. It's used to generate unique linker symbols for
-// their runtime type descriptors.
-var TypeGen int32
-
 func typecheckdeftype(n *ir.Name) {
        if base.EnableTrace && base.Flag.LowerT {
                defer tracePrint("typecheckdeftype", n)(nil)
@@ -1748,8 +1743,7 @@ func typecheckdeftype(n *ir.Name) {
 
        t := types.NewNamed(n)
        if n.Curfn != nil {
-               TypeGen++
-               t.Vargen = TypeGen
+               t.SetVargen()
        }
 
        if n.Pragma()&ir.NotInHeap != 0 {

diff --git a/src/cmd/compile/internal/types/fmt.go b/src/cmd/compile/internal/types/fmt.go
index b1b850640071a3bc8d4d979bcbc49983494c0803..74ebfad5bb913937b2983f5d3db1208ca4422963 100644 (file)
--- a/src/cmd/compile/internal/types/fmt.go
+++ b/src/cmd/compile/internal/types/fmt.go
@@ -361,8 +361,8 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
                // output too. It seems like it should, but that mode is currently
                // used in string representation used by reflection, which is
                // user-visible and doesn't expect this.
-               if mode == fmtTypeID && t.Vargen != 0 {
-                       fmt.Fprintf(b, "·%d", t.Vargen)
+               if mode == fmtTypeID && t.vargen != 0 {
+                       fmt.Fprintf(b, "·%d", t.vargen)
                }
                return
        }

diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go
index 975280753a435a98cf50c4bad4ec94924b8cf313..06348c509462453a95fc5efa6fc5f422539746ba 100644 (file)
--- a/src/cmd/compile/internal/types/type.go
+++ b/src/cmd/compile/internal/types/type.go
@@ -178,7 +178,7 @@ type Type struct {
        }
 
        sym    *Sym  // symbol containing name, for named types
-       Vargen int32 // unique name for OTYPE/ONAME
+       vargen int32 // unique name for OTYPE/ONAME
 
        kind  Kind  // kind of type
        Align uint8 // the required alignment of this type, in bytes (0 means Width and Align have not yet been computed)
@@ -1221,8 +1221,8 @@ func (t *Type) cmp(x *Type) Cmp {
 
        if x.sym != nil {
                // Syms non-nil, if vargens match then equal.
-               if t.Vargen != x.Vargen {
-                       return cmpForNe(t.Vargen < x.Vargen)
+               if t.vargen != x.vargen {
+                       return cmpForNe(t.vargen < x.vargen)
                }
                return CMPeq
        }
@@ -1768,6 +1768,25 @@ func (t *Type) Obj() Object {
        return nil
 }
 
+// typeGen tracks the number of function-scoped defined types that
+// have been declared. It's used to generate unique linker symbols for
+// their runtime type descriptors.
+var typeGen int32
+
+// SetVargen assigns a unique generation number to type t, which must
+// be a defined type declared within function scope. The generation
+// number is used to distinguish it from other similarly spelled
+// defined types from the same package.
+//
+// TODO(mdempsky): Come up with a better solution.
+func (t *Type) SetVargen() {
+       base.Assertf(t.Sym() != nil, "SetVargen on anonymous type %v", t)
+       base.Assertf(t.vargen == 0, "type %v already has Vargen %v", t, t.vargen)
+
+       typeGen++
+       t.vargen = typeGen
+}
+
 // SetUnderlying sets the underlying type. SetUnderlying automatically updates any
 // types that were waiting for this type to be completed.
 func (t *Type) SetUnderlying(underlying *Type) {