[dev.typeparams] cmd/compile: simplify import* functions

CL 280634 remove Sym.Importdef, so ipkg in importsym is not used
anymore. So we can remove it from importsym and all other import*
functions, which just call importsym internally.

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

diff --git a/src/cmd/compile/internal/typecheck/export.go b/src/cmd/compile/internal/typecheck/export.go
index 63d0a1ec6c656ce23e504458eacb456e01d12783..30726d4327f7ce8edf3d0879d73d939f094d90b0 100644 (file)
--- a/src/cmd/compile/internal/typecheck/export.go
+++ b/src/cmd/compile/internal/typecheck/export.go
@@ -15,22 +15,22 @@ import (
 
 // importalias declares symbol s as an imported type alias with type t.
 // ipkg is the package being imported
-func importalias(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-       return importobj(ipkg, pos, s, ir.OTYPE, ir.PEXTERN, t)
+func importalias(pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       return importobj(pos, s, ir.OTYPE, ir.PEXTERN, t)
 }
 
 // importconst declares symbol s as an imported constant with type t and value val.
 // ipkg is the package being imported
-func importconst(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
-       n := importobj(ipkg, pos, s, ir.OLITERAL, ir.PEXTERN, t)
+func importconst(pos src.XPos, s *types.Sym, t *types.Type, val constant.Value) *ir.Name {
+       n := importobj(pos, s, ir.OLITERAL, ir.PEXTERN, t)
        n.SetVal(val)
        return n
 }
 
 // importfunc declares symbol s as an imported function with type t.
 // ipkg is the package being imported
-func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-       n := importobj(ipkg, pos, s, ir.ONAME, ir.PFUNC, t)
+func importfunc(pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       n := importobj(pos, s, ir.ONAME, ir.PFUNC, t)
        n.Func = ir.NewFunc(pos)
        n.Func.Nname = n
        return n
@@ -38,8 +38,8 @@ func importfunc(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.
 
 // importobj declares symbol s as an imported object representable by op.
 // ipkg is the package being imported
-func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
-       n := importsym(ipkg, pos, s, op, ctxt)
+func importobj(pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class, t *types.Type) *ir.Name {
+       n := importsym(pos, s, op, ctxt)
        n.SetType(t)
        if ctxt == ir.PFUNC {
                n.Sym().SetFunc(true)
@@ -47,7 +47,7 @@ func importobj(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
        return n
 }
 
-func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
+func importsym(pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Class) *ir.Name {
        if n := s.PkgDef(); n != nil {
                base.Fatalf("importsym of symbol that already exists: %v", n)
        }
@@ -61,14 +61,14 @@ func importsym(ipkg *types.Pkg, pos src.XPos, s *types.Sym, op ir.Op, ctxt ir.Cl
 // importtype returns the named type declared by symbol s.
 // If no such type has been declared yet, a forward declaration is returned.
 // ipkg is the package being imported
-func importtype(ipkg *types.Pkg, pos src.XPos, s *types.Sym) *ir.Name {
-       n := importsym(ipkg, pos, s, ir.OTYPE, ir.PEXTERN)
+func importtype(pos src.XPos, s *types.Sym) *ir.Name {
+       n := importsym(pos, s, ir.OTYPE, ir.PEXTERN)
        n.SetType(types.NewNamed(n))
        return n
 }
 
 // importvar declares symbol s as an imported variable with type t.
 // ipkg is the package being imported
-func importvar(ipkg *types.Pkg, pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
-       return importobj(ipkg, pos, s, ir.ONAME, ir.PEXTERN, t)
+func importvar(pos src.XPos, s *types.Sym, t *types.Type) *ir.Name {
+       return importobj(pos, s, ir.ONAME, ir.PEXTERN, t)
 }

diff --git a/src/cmd/compile/internal/typecheck/iimport.go b/src/cmd/compile/internal/typecheck/iimport.go
index 81f8ea05d9cffdb3417890f9ad2e2fe6a3077fef..d94f649a4520fa1f31e14b668f55d8d656622e32 100644 (file)
--- a/src/cmd/compile/internal/typecheck/iimport.go
+++ b/src/cmd/compile/internal/typecheck/iimport.go
@@ -294,13 +294,13 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
        case 'A':
                typ := r.typ()
 
-               return importalias(r.p.ipkg, pos, sym, typ)
+               return importalias(pos, sym, typ)
 
        case 'C':
                typ := r.typ()
                val := r.value(typ)
 
-               n := importconst(r.p.ipkg, pos, sym, typ, val)
+               n := importconst(pos, sym, typ, val)
                r.constExt(n)
                return n
 
@@ -311,7 +311,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
                }
                typ := r.signature(nil, tparams)
 
-               n := importfunc(r.p.ipkg, pos, sym, typ)
+               n := importfunc(pos, sym, typ)
                r.funcExt(n)
                return n
 
@@ -323,7 +323,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
 
                // Types can be recursive. We need to setup a stub
                // declaration before recursing.
-               n := importtype(r.p.ipkg, pos, sym)
+               n := importtype(pos, sym)
                t := n.Type()
                if rparams != nil {
                        t.SetRParams(rparams)
@@ -401,7 +401,7 @@ func (r *importReader) doDecl(sym *types.Sym) *ir.Name {
        case 'V':
                typ := r.typ()
 
-               n := importvar(r.p.ipkg, pos, sym, typ)
+               n := importvar(pos, sym, typ)
                r.varExt(n)
                return n
 

diff --git a/src/cmd/compile/internal/typecheck/syms.go b/src/cmd/compile/internal/typecheck/syms.go
index f29af82db2cc25670a60ef4192fd5623a4ee4806..ed3aaecc5a2a2a777cd748d22eca98f4b65f2ce1 100644 (file)
--- a/src/cmd/compile/internal/typecheck/syms.go
+++ b/src/cmd/compile/internal/typecheck/syms.go
@@ -75,9 +75,9 @@ func InitRuntime() {
                typ := typs[d.typ]
                switch d.tag {
                case funcTag:
-                       importfunc(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+                       importfunc(src.NoXPos, sym, typ)
                case varTag:
-                       importvar(ir.Pkgs.Runtime, src.NoXPos, sym, typ)
+                       importvar(src.NoXPos, sym, typ)
                default:
                        base.Fatalf("unhandled declaration tag %v", d.tag)
                }