languages/go
languages/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-05 16:04:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

[dev.regabi] cmd/compile: remove CTRUNE

Browse source 
Since CL 255217, we've been able to rely on types.UntypedRune to
identify untyped rune literals, rather than needing Mpint.Rune /
CTRUNE. This makes way for switching to using go/constant, which
doesn't have a separate notion of rune constants distinct from integer
constants.

Passes toolstash-check.

Change-Id: I319861f4758aeea17345c101b167cb307e706a0e
Reviewed-on: https://go-review.googlesource.com/c/go/+/272652
Reviewed-by: Robert Griesemer <gri@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
This commit is contained in:
Matthew Dempsky 2020-11-13 18:33:19 -08:00
parent 6dae48fb0b
commit c767d73227
7 changed files with 72 additions and 88 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

88
src/cmd/compile/internal/gc/const.go
View file

@ -19,7 +19,6 @@ const (
CTxxx Ctype = iota
CTINT
CTRUNE
CTFLT
CTCPLX
CTSTR
@ -29,7 +28,7 @@ const (
type Val struct {
// U contains one of:
// bool bool when Ctype() == CTBOOL
// *Mpint int when Ctype() == CTINT, rune when Ctype() == CTRUNE
// *Mpint int when Ctype() == CTINT
// *Mpflt float when Ctype() == CTFLT
// *Mpcplx pair of floats when Ctype() == CTCPLX
// string string when Ctype() == CTSTR
@ -37,7 +36,7 @@ type Val struct {
}
func (v Val) Ctype() Ctype {
switch x := v.U.(type) {
switch v.U.(type) {
default:
Fatalf("unexpected Ctype for %T", v.U)
panic("unreachable")
@ -46,9 +45,6 @@ func (v Val) Ctype() Ctype {
case bool:
return CTBOOL
case *Mpint:
if x.Rune {
return CTRUNE
}
return CTINT
case *Mpflt:
return CTFLT
@ -384,7 +380,7 @@ func convertVal(v Val, t *types.Type, explicit bool) Val {
return v
}
case CTINT, CTRUNE:
case CTINT:
if explicit && t.IsString() {
return tostr(v)
}
@ -449,11 +445,6 @@ func toflt(v Val) Val {
func toint(v Val) Val {
switch u := v.U.(type) {
case *Mpint:
if u.Rune {
i := new(Mpint)
i.Set(u)
v.U = i
}
case *Mpflt:
i := new(Mpint)
@ -560,11 +551,7 @@ func consttype(n *Node) Ctype {
}
func Isconst(n *Node, ct Ctype) bool {
t := consttype(n)
// If the caller is asking for CTINT, allow CTRUNE too.
// Makes life easier for back ends.
return t == ct || (ct == CTINT && t == CTRUNE)
return consttype(n) == ct
}
// evconst rewrites constant expressions into OLITERAL nodes.
@ -710,7 +697,7 @@ func compareOp(x Val, op Op, y Val) bool {
return x != y
}
case CTINT, CTRUNE:
case CTINT:
x, y := x.U.(*Mpint), y.U.(*Mpint)
return cmpZero(x.Cmp(y), op)
@ -784,11 +771,10 @@ Outer:
return Val{U: x || y}
}
case CTINT, CTRUNE:
case CTINT:
x, y := x.U.(*Mpint), y.U.(*Mpint)
u := new(Mpint)
u.Rune = x.Rune || y.Rune
u.Set(x)
switch op {
case OADD:
@ -879,16 +865,15 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
switch op {
case OPLUS:
switch x.Ctype() {
case CTINT, CTRUNE, CTFLT, CTCPLX:
case CTINT, CTFLT, CTCPLX:
return x
}
case ONEG:
switch x.Ctype() {
case CTINT, CTRUNE:
case CTINT:
x := x.U.(*Mpint)
u := new(Mpint)
u.Rune = x.Rune
u.Set(x)
u.Neg()
return Val{U: u}
@ -912,11 +897,10 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
case OBITNOT:
switch x.Ctype() {
case CTINT, CTRUNE:
case CTINT:
x := x.U.(*Mpint)
u := new(Mpint)
u.Rune = x.Rune
if t.IsSigned() || t.IsUntyped() {
// Signed values change sign.
u.SetInt64(-1)
@ -937,14 +921,11 @@ func unaryOp(op Op, x Val, t *types.Type) Val {
}
func shiftOp(x Val, op Op, y Val) Val {
if x.Ctype() != CTRUNE {
x = toint(x)
}
x = toint(x)
y = toint(y)
u := new(Mpint)
u.Set(x.U.(*Mpint))
u.Rune = x.U.(*Mpint).Rune
switch op {
case OLSH:
u.Lsh(y.U.(*Mpint))
@ -1010,7 +991,7 @@ func represents(t *types.Type, v Val) bool {
}
vt := idealType(v.Ctype())
return t == vt
return t == vt || (t == types.UntypedRune && vt == types.UntypedInt)
}
func setboolconst(n *Node, v bool) {
@ -1039,8 +1020,6 @@ func idealType(ct Ctype) *types.Type {
return types.UntypedBool
case CTINT:
return types.UntypedInt
case CTRUNE:
return types.UntypedRune
case CTFLT:
return types.UntypedFloat
case CTCPLX:
@ -1091,31 +1070,30 @@ func defaultlit2(l *Node, r *Node, force bool) (*Node, *Node) {
return l, r
}
func ctype(t *types.Type) Ctype {
switch t {
case types.UntypedBool:
return CTBOOL
case types.UntypedString:
return CTSTR
case types.UntypedInt:
return CTINT
case types.UntypedRune:
return CTRUNE
case types.UntypedFloat:
return CTFLT
case types.UntypedComplex:
return CTCPLX
}
Fatalf("bad type %v", t)
panic("unreachable")
}
func mixUntyped(t1, t2 *types.Type) *types.Type {
t := t1
if ctype(t2) > ctype(t1) {
t = t2
if t1 == t2 {
return t1
}
return t
rank := func(t *types.Type) int {
switch t {
case types.UntypedInt:
return 0
case types.UntypedRune:
return 1
case types.UntypedFloat:
return 2
case types.UntypedComplex:
return 3
}
Fatalf("bad type %v", t)
panic("unreachable")
}
if rank(t2) > rank(t1) {
return t2
}
return t1
}
func defaultType(t *types.Type) *types.Type {

55
src/cmd/compile/internal/gc/fmt.go
View file

@ -526,28 +526,12 @@ func (v Val) Format(s fmt.State, verb rune) {
func (v Val) vconv(s fmt.State, flag FmtFlag) {
switch u := v.U.(type) {
case *Mpint:
if !u.Rune {
if flag&FmtSharp != 0 {
fmt.Fprint(s, u.String())
return
}
fmt.Fprint(s, u.GoString())
if flag&FmtSharp != 0 {
fmt.Fprint(s, u.String())
return
}
switch x := u.Int64(); {
case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
fmt.Fprintf(s, "'%c'", int(x))
case 0 <= x && x < 1<<16:
fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
case 0 <= x && x <= utf8.MaxRune:
fmt.Fprintf(s, "'\\U%08x'", uint64(x))
default:
fmt.Fprintf(s, "('\\x00' + %v)", u)
}
fmt.Fprint(s, u.GoString())
return
case *Mpflt:
if flag&FmtSharp != 0 {
@ -1336,19 +1320,40 @@ func (n *Node) exprfmt(s fmt.State, prec int, mode fmtMode) {
}
}
needUnparen := false
if n.Type != nil && !n.Type.IsUntyped() {
// Need parens when type begins with what might
// be misinterpreted as a unary operator: * or <-.
if n.Type.IsPtr() || (n.Type.IsChan() && n.Type.ChanDir() == types.Crecv) {
mode.Fprintf(s, "(%v)(%v)", n.Type, n.Val())
return
mode.Fprintf(s, "(%v)(", n.Type)
} else {
mode.Fprintf(s, "%v(%v)", n.Type, n.Val())
return
mode.Fprintf(s, "%v(", n.Type)
}
needUnparen = true
}
mode.Fprintf(s, "%v", n.Val())
if n.Type == types.UntypedRune {
u := n.Val().U.(*Mpint)
switch x := u.Int64(); {
case ' ' <= x && x < utf8.RuneSelf && x != '\\' && x != '\'':
fmt.Fprintf(s, "'%c'", int(x))
case 0 <= x && x < 1<<16:
fmt.Fprintf(s, "'\\u%04x'", uint(int(x)))
case 0 <= x && x <= utf8.MaxRune:
fmt.Fprintf(s, "'\\U%08x'", uint64(x))
default:
fmt.Fprintf(s, "('\\x00' + %v)", u)
}
} else {
mode.Fprintf(s, "%v", n.Val())
}
if needUnparen {
mode.Fprintf(s, ")")
}
// Special case: name used as local variable in export.
// _ becomes ~b%d internally; print as _ for export

1
src/cmd/compile/internal/gc/iimport.go
View file

@ -363,7 +363,6 @@ func (p *importReader) value(typ *types.Type) (v Val) {
v.U = p.string()
case CTINT:
x := new(Mpint)
x.Rune = typ == types.UntypedRune
p.mpint(&x.Val, typ)
v.U = x
case CTFLT:

5
src/cmd/compile/internal/gc/mpint.go
View file

@ -13,9 +13,8 @@ import (
// Mpint represents an integer constant.
type Mpint struct {
Val big.Int
Ovf bool // set if Val overflowed compiler limit (sticky)
Rune bool // set if syntax indicates default type rune
Val big.Int
Ovf bool // set if Val overflowed compiler limit (sticky)
}
func (a *Mpint) SetOverflow() {

4
src/cmd/compile/internal/gc/noder.go
View file

@ -656,6 +656,9 @@ func (p *noder) expr(expr syntax.Expr) *Node {
return p.mkname(expr)
case *syntax.BasicLit:
n := nodlit(p.basicLit(expr))
if expr.Kind == syntax.RuneLit {
n.Type = types.UntypedRune
}
n.SetDiag(expr.Bad) // avoid follow-on errors if there was a syntax error
return n
case *syntax.CompositeLit:
@ -1428,7 +1431,6 @@ func (p *noder) basicLit(lit *syntax.BasicLit) Val {
case syntax.RuneLit:
x := new(Mpint)
x.Rune = true
if !lit.Bad {
u, _ := strconv.Unquote(s)
var r rune

2
src/cmd/compile/internal/gc/typecheck.go
View file

@ -3724,7 +3724,7 @@ func checkmake(t *types.Type, arg string, np **Node) bool {
// Do range checks for constants before defaultlit
// to avoid redundant "constant NNN overflows int" errors.
switch consttype(n) {
case CTINT, CTRUNE, CTFLT, CTCPLX:
case CTINT, CTFLT, CTCPLX:
v := toint(n.Val()).U.(*Mpint)
if v.CmpInt64(0) < 0 {
yyerror("negative %s argument in make(%v)", arg, t)

5
src/cmd/compile/internal/gc/walk.go
View file

@ -1931,10 +1931,11 @@ func walkprint(nn *Node, init *Nodes) *Node {
calls := []*Node{mkcall("printlock", nil, init)}
for i, n := range nn.List.Slice() {
if n.Op == OLITERAL {
switch n.Val().Ctype() {
case CTRUNE:
if n.Type == types.UntypedRune {
n = defaultlit(n, types.Runetype)
}
switch n.Val().Ctype() {
case CTINT:
n = defaultlit(n, types.Types[TINT64])