1
0
mirror of https://github.com/golang/go synced 2024-11-11 18:31:38 -07:00

cmd/compile/internal/noder: stop preserving original const strings

One of the more tedious quirks of the original frontend (i.e.,
typecheck) to preserve was that it preserved the original
representation of constants into the backend. To fit into the unified
IR model, I ended up implementing a fairly heavyweight workaround:
simply record the original constant's string expression in the export
data, so that diagnostics could still report it back, and match the
old test expectations.

But now that there's just a single frontend to support, it's easy
enough to just update the test expectations and drop this support for
"raw" constant expressions.

Change-Id: I1d859c5109d679879d937a2b213e777fbddf4f2f
Reviewed-on: https://go-review.googlesource.com/c/go/+/526376
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
This commit is contained in:
Matthew Dempsky 2023-09-06 14:00:30 -07:00 committed by Gopher Robot
parent c6d550a668
commit 18c6ec1e4a
11 changed files with 12 additions and 96 deletions

View File

@ -498,20 +498,6 @@ func NewParenExpr(pos src.XPos, x Node) *ParenExpr {
func (n *ParenExpr) Implicit() bool { return n.flags&miniExprImplicit != 0 } func (n *ParenExpr) Implicit() bool { return n.flags&miniExprImplicit != 0 }
func (n *ParenExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) } func (n *ParenExpr) SetImplicit(b bool) { n.flags.set(miniExprImplicit, b) }
// A RawOrigExpr represents an arbitrary Go expression as a string value.
// When printed in diagnostics, the string value is written out exactly as-is.
type RawOrigExpr struct {
miniExpr
Raw string
}
func NewRawOrigExpr(pos src.XPos, op Op, raw string) *RawOrigExpr {
n := &RawOrigExpr{Raw: raw}
n.pos = pos
n.op = op
return n
}
// A ResultExpr represents a direct access to a result. // A ResultExpr represents a direct access to a result.
type ResultExpr struct { type ResultExpr struct {
miniExpr miniExpr

View File

@ -567,11 +567,6 @@ func exprFmt(n Node, s fmt.State, prec int) {
return return
} }
if n, ok := n.(*RawOrigExpr); ok {
fmt.Fprint(s, n.Raw)
return
}
switch n.Op() { switch n.Op() {
case OPAREN: case OPAREN:
n := n.(*ParenExpr) n := n.(*ParenExpr)

View File

@ -1171,25 +1171,6 @@ func (n *RangeStmt) editChildrenWithHidden(edit func(Node) Node) {
} }
} }
func (n *RawOrigExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
func (n *RawOrigExpr) copy() Node {
c := *n
c.init = copyNodes(c.init)
return &c
}
func (n *RawOrigExpr) doChildren(do func(Node) bool) bool {
if doNodes(n.init, do) {
return true
}
return false
}
func (n *RawOrigExpr) editChildren(edit func(Node) Node) {
editNodes(n.init, edit)
}
func (n *RawOrigExpr) editChildrenWithHidden(edit func(Node) Node) {
editNodes(n.init, edit)
}
func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) } func (n *ResultExpr) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) }
func (n *ResultExpr) copy() Node { func (n *ResultExpr) copy() Node {
c := *n c := *n

View File

@ -1,34 +0,0 @@
// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package noder
import (
"fmt"
"cmd/compile/internal/ir"
"cmd/compile/internal/syntax"
)
// constExprOp returns an ir.Op that represents the outermost
// operation of the given constant expression. It's intended for use
// with ir.RawOrigExpr.
func constExprOp(expr syntax.Expr) ir.Op {
switch expr := expr.(type) {
default:
panic(fmt.Sprintf("%s: unexpected expression: %T", expr.Pos(), expr))
case *syntax.BasicLit:
return ir.OLITERAL
case *syntax.Name, *syntax.SelectorExpr:
return ir.ONAME
case *syntax.CallExpr:
return ir.OCALL
case *syntax.Operation:
if expr.Y == nil {
return unOps[expr.Op]
}
return binOps[expr.Op]
}
}

View File

@ -40,11 +40,6 @@ func typed(typ *types.Type, n ir.Node) ir.Node {
// Values // Values
func OrigConst(pos src.XPos, typ *types.Type, val constant.Value, op ir.Op, raw string) ir.Node {
orig := ir.NewRawOrigExpr(pos, op, raw)
return ir.NewConstExpr(val, typed(typ, orig))
}
// FixValue returns val after converting and truncating it as // FixValue returns val after converting and truncating it as
// appropriate for typ. // appropriate for typ.
func FixValue(typ *types.Type, val constant.Value) constant.Value { func FixValue(typ *types.Type, val constant.Value) constant.Value {

View File

@ -2172,9 +2172,7 @@ func (r *reader) expr() (res ir.Node) {
pos := r.pos() pos := r.pos()
typ := r.typ() typ := r.typ()
val := FixValue(typ, r.Value()) val := FixValue(typ, r.Value())
op := r.op() return typed(typ, ir.NewBasicLit(pos, val))
orig := r.String()
return typecheck.Expr(OrigConst(pos, typ, val, op, orig))
case exprNil: case exprNil:
pos := r.pos() pos := r.pos()

View File

@ -1748,11 +1748,6 @@ func (w *writer) expr(expr syntax.Expr) {
assert(typ != nil) assert(typ != nil)
w.typ(typ) w.typ(typ)
w.Value(tv.Value) w.Value(tv.Value)
// TODO(mdempsky): These details are only important for backend
// diagnostics. Explore writing them out separately.
w.op(constExprOp(expr))
w.String(syntax.String(expr))
return return
} }

View File

@ -151,7 +151,7 @@ func f9() {
func f10() { func f10() {
// These don't escape but are too big for the stack // These don't escape but are too big for the stack
var x [1 << 30]byte // ERROR "moved to heap: x" var x [1 << 30]byte // ERROR "moved to heap: x"
var y = make([]byte, 1<<30) // ERROR "make\(\[\]byte, 1 << 30\) escapes to heap" var y = make([]byte, 1<<30) // ERROR "make\(\[\]byte, 1073741824\) escapes to heap"
_ = x[0] + y[0] _ = x[0] + y[0]
} }

View File

@ -115,7 +115,7 @@ func is2(x [2]int) bool {
return v.IsValid() || v.IsNil() || v.IsZero() return v.IsValid() || v.IsNil() || v.IsZero()
} }
func is3(x struct { a, b int }) bool { func is3(x struct{ a, b int }) bool {
v := reflect.ValueOf(x) // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape"
return v.IsValid() || v.IsNil() || v.IsZero() return v.IsValid() || v.IsNil() || v.IsZero()
} }
@ -352,9 +352,9 @@ func select2(ch chan string, x string) { // ERROR "leaking param: ch$" "leaking
} }
var ( var (
intTyp = reflect.TypeOf(int(0)) // ERROR "int\(0\) does not escape" intTyp = reflect.TypeOf(int(0)) // ERROR "0 does not escape"
uintTyp = reflect.TypeOf(uint(0)) // ERROR "uint\(0\) does not escape" uintTyp = reflect.TypeOf(uint(0)) // ERROR "uint\(0\) does not escape"
stringTyp = reflect.TypeOf(string("")) // ERROR "string\(.*\) does not escape" stringTyp = reflect.TypeOf(string("")) // ERROR ".. does not escape"
bytesTyp = reflect.TypeOf([]byte{}) // ERROR "\[\]byte{} does not escape" bytesTyp = reflect.TypeOf([]byte{}) // ERROR "\[\]byte{} does not escape"
) )

View File

@ -137,7 +137,7 @@ const (
var v4InV6Prefix = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff} var v4InV6Prefix = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff}
func IPv4(a, b, c, d byte) IP { func IPv4(a, b, c, d byte) IP {
p := make(IP, IPv6len) // ERROR "make\(IP, IPv6len\) escapes to heap" p := make(IP, IPv6len) // ERROR "make\(IP, 16\) escapes to heap"
copy(p, v4InV6Prefix) copy(p, v4InV6Prefix)
p[12] = a p[12] = a
p[13] = b p[13] = b

View File

@ -61,7 +61,7 @@ func test1(iter int) {
} }
if len(m) != maxI { if len(m) != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }
@ -85,7 +85,7 @@ func test2(iter int) {
} }
if len(m) != maxI { if len(m) != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }
@ -111,7 +111,7 @@ func test3(iter int) {
} }
if *m != maxI { if *m != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }
@ -137,7 +137,7 @@ func test4(iter int) {
} }
if *m != maxI { if *m != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }
@ -168,7 +168,7 @@ func test5(iter int) {
} }
if *m != maxI { if *m != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }
@ -186,6 +186,6 @@ func test6(iter int) {
} }
if *m != maxI { if *m != maxI {
panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap" panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "500 escapes to heap$" "... argument does not escape$" "fmt.Sprintf\(.*\) escapes to heap"
} }
} }