[dev.typeparams] cmd/compile: allow typecheck of OCHECKNIL

This CL makes OCHECKNIL typecheckable. Simplifies IR construction code
slightly, and gives one convenient place to check for misuse.

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

diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 922a01bfbe9aa7d6dea6ab34e03e5955ef883105..cd00f1b3d117f37585134a809d531799e535d351 100644 (file)
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -237,6 +237,15 @@ func plural(n int) string {
        return "s"
 }
 
+// tcCheckNil typechecks an OCHECKNIL node.
+func tcCheckNil(n *ir.UnaryExpr) ir.Node {
+       n.X = Expr(n.X)
+       if !n.X.Type().IsPtrShaped() {
+               base.FatalfAt(n.Pos(), "%L is not pointer shaped", n.X)
+       }
+       return n
+}
+
 // tcFor typechecks an OFOR node.
 func tcFor(n *ir.ForStmt) ir.Node {
        Stmts(n.Init())

diff --git a/src/cmd/compile/internal/typecheck/typecheck.go b/src/cmd/compile/internal/typecheck/typecheck.go
index b1a4e193d638ba6e58a02224b1aefbfcb4142b1a..0367f7b0341ba35bb2dd98c6c711328b13c6a7c9 100644 (file)
--- a/src/cmd/compile/internal/typecheck/typecheck.go
+++ b/src/cmd/compile/internal/typecheck/typecheck.go
@@ -876,6 +876,10 @@ func typecheck1(n ir.Node, top int) ir.Node {
                n := n.(*ir.TailCallStmt)
                return n
 
+       case ir.OCHECKNIL:
+               n := n.(*ir.UnaryExpr)
+               return tcCheckNil(n)
+
        case ir.OSELECT:
                tcSelect(n.(*ir.SelectStmt))
                return n

diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 62eb4298f4d63e67fa43d6c0d0304a3e42b080af..be0f4c5208c26e10c3834da6b2550a4204acf699 100644 (file)
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -677,9 +677,8 @@ func walkUnsafeSlice(n *ir.BinaryExpr, init *ir.Nodes) ir.Node {
 
        ptr := walkExpr(n.X, init)
 
-       c := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, ptr)
-       c.SetTypecheck(1)
-       init.Append(c)
+       check := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, ptr)
+       init.Append(typecheck.Stmt(check))
 
        // TODO(mdempsky): checkptr instrumentation. Maybe merge into length
        // check above, along with nil check? Need to be careful about

diff --git a/src/cmd/compile/internal/walk/closure.go b/src/cmd/compile/internal/walk/closure.go
index feda3c3b4f8cf0922952f46abbf70bdf36d85163..5db907d01dc0967961afddc62887dcbb96a68101 100644 (file)
--- a/src/cmd/compile/internal/walk/closure.go
+++ b/src/cmd/compile/internal/walk/closure.go
@@ -178,11 +178,9 @@ func walkCallPart(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {
                n.X = cheapExpr(n.X, init)
                n.X = walkExpr(n.X, nil)
 
-               tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
-
-               c := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
-               c.SetTypecheck(1)
-               init.Append(c)
+               tab := ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X)
+               check := ir.NewUnaryExpr(base.Pos, ir.OCHECKNIL, tab)
+               init.Append(typecheck.Stmt(check))
        }
 
        typ := typecheck.PartialCallType(n)

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index b9aff032404ea8850c96ceaabf756ae769eb588d..4d40cf890e6d910bd0cf35e4121afd90a216722a 100644 (file)
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -762,7 +762,7 @@ func (o *orderState) stmt(n ir.Node) {
                o.out = append(o.out, n)
                o.cleanTemp(t)
 
-       case ir.OCLOSE, ir.ORECV:
+       case ir.OCHECKNIL, ir.OCLOSE, ir.OPANIC, ir.ORECV:
                n := n.(*ir.UnaryExpr)
                t := o.markTemp()
                n.X = o.expr(n.X, nil)
@@ -835,16 +835,6 @@ func (o *orderState) stmt(n ir.Node) {
                orderBlock(&n.Else, o.free)
                o.out = append(o.out, n)
 
-       case ir.OPANIC:
-               n := n.(*ir.UnaryExpr)
-               t := o.markTemp()
-               n.X = o.expr(n.X, nil)
-               if !n.X.Type().IsEmptyInterface() {
-                       base.FatalfAt(n.Pos(), "bad argument to panic: %L", n.X)
-               }
-               o.out = append(o.out, n)
-               o.cleanTemp(t)
-
        case ir.ORANGE:
                // n.Right is the expression being ranged over.
                // order it, and then make a copy if we need one.