From db84f5315ff19fd2ad70f07193749ef377a028e2 Mon Sep 17 00:00:00 2001 From: Matthew Dempsky Date: Thu, 11 Aug 2022 10:48:12 -0700 Subject: [PATCH] cmd/compile/internal/noder: fix implicit conversion position In go.dev/cl/413396, I implemented implicit conversions by setting the conversion's position to the enclosing statement that necessitated the conversion. However, users actually want the position information to be at the expression itself, and this seems sensible anyway. This was noticed because x/tools had a test for: fmt.Println(42) and it was checking where the escape analysis diagnostic for `42` (really `any(42)`) was reported. Historically, we reported the column of the `4`; but CL 413396 caused unified IR to instead report the column of the `(` instead (the position associated with the call expression, which forced `42` to be implicitly converted from `int` to `any`). I chalk this mistake up to being accustomed to working with ir, where we can't reliably use n.Pos() because of how ONAME positions work, so I was trying to avoid relying on the implicitly converted expression's own position. Change-Id: I762076af6f65ebe6d444d64630722a5016dc2698 Reviewed-on: https://go-review.googlesource.com/c/go/+/422976 Reviewed-by: David Chase Run-TryBot: Matthew Dempsky TryBot-Result: Gopher Robot --- src/cmd/compile/internal/noder/writer.go | 32 ++++++++++++------------ 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/src/cmd/compile/internal/noder/writer.go b/src/cmd/compile/internal/noder/writer.go index ef84a53cf3..52fa542f6b 100644 --- a/src/cmd/compile/internal/noder/writer.go +++ b/src/cmd/compile/internal/noder/writer.go @@ -1060,7 +1060,7 @@ func (w *writer) stmt1(stmt syntax.Stmt) { if stmt.Op != syntax.Shl && stmt.Op != syntax.Shr { typ = w.p.typeOf(stmt.Lhs) } - w.implicitConvExpr(stmt, typ, stmt.Rhs) + w.implicitConvExpr(typ, stmt.Rhs) default: w.assignStmt(stmt, stmt.Lhs, stmt.Rhs) @@ -1125,7 +1125,7 @@ func (w *writer) stmt1(stmt syntax.Stmt) { w.Code(stmtSend) w.pos(stmt) w.expr(stmt.Chan) - w.implicitConvExpr(stmt, chanType.Elem(), stmt.Value) + w.implicitConvExpr(chanType.Elem(), stmt.Value) case *syntax.SwitchStmt: w.Code(stmtSwitch) @@ -1376,7 +1376,7 @@ func (w *writer) switchStmt(stmt *syntax.SwitchStmt) { } if w.Bool(tag != nil) { - w.implicitConvExpr(tag, tagType, tag) + w.implicitConvExpr(tagType, tag) } } @@ -1406,7 +1406,7 @@ func (w *writer) switchStmt(stmt *syntax.SwitchStmt) { w.Sync(pkgbits.SyncExprs) w.Len(len(cases)) for _, cas := range cases { - w.implicitConvExpr(cas, tagType, cas) + w.implicitConvExpr(tagType, cas) } } @@ -1569,7 +1569,7 @@ func (w *writer) expr(expr syntax.Expr) { w.Code(exprIndex) w.expr(expr.X) w.pos(expr) - w.implicitConvExpr(expr, keyType, expr.Index) + w.implicitConvExpr(keyType, expr.Index) if keyType != nil { w.rtype(xtyp) } @@ -1619,9 +1619,9 @@ func (w *writer) expr(expr syntax.Expr) { w.Code(exprBinaryOp) w.op(binOps[expr.Op]) - w.implicitConvExpr(expr, commonType, expr.X) + w.implicitConvExpr(commonType, expr.X) w.pos(expr) - w.implicitConvExpr(expr, commonType, expr.Y) + w.implicitConvExpr(commonType, expr.Y) case *syntax.CallExpr: tv, ok := w.p.info.Types[expr.Fun] @@ -1814,23 +1814,23 @@ func (w *writer) multiExpr(pos poser, dstType func(int) types2.Type, exprs []syn w.Bool(false) // N:N assignment w.Len(len(exprs)) for i, expr := range exprs { - w.implicitConvExpr(pos, dstType(i), expr) + w.implicitConvExpr(dstType(i), expr) } } -// implicitConvExpr is like expr, but if dst is non-nil and different from -// expr's type, then an implicit conversion operation is inserted at -// pos. -func (w *writer) implicitConvExpr(pos poser, dst types2.Type, expr syntax.Expr) { +// implicitConvExpr is like expr, but if dst is non-nil and different +// from expr's type, then an implicit conversion operation is inserted +// at expr's position. +func (w *writer) implicitConvExpr(dst types2.Type, expr syntax.Expr) { src := w.p.typeOf(expr) if dst != nil && !types2.Identical(src, dst) { if !types2.AssignableTo(src, dst) { - w.p.fatalf(pos, "%v is not assignable to %v", src, dst) + w.p.fatalf(expr.Pos(), "%v is not assignable to %v", src, dst) } w.Code(exprConvert) w.Bool(true) // implicit w.typ(dst) - w.pos(pos) + w.pos(expr) w.convRTTI(src, dst) w.Bool(isTypeParam(dst)) // fallthrough @@ -1882,12 +1882,12 @@ func (w *writer) compLit(lit *syntax.CompositeLit) { if kv, ok := elem.(*syntax.KeyValueExpr); w.Bool(ok) { // use position of expr.Key rather than of elem (which has position of ':') w.pos(kv.Key) - w.implicitConvExpr(kv.Key, keyType, kv.Key) + w.implicitConvExpr(keyType, kv.Key) elem = kv.Value } } w.pos(elem) - w.implicitConvExpr(elem, elemType, elem) + w.implicitConvExpr(elemType, elem) } }