qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 15:00:03 -07:00
Code Releases Activity

[dev.unified] cmd/compile/internal/noder: better switch statements

Browse Source 
Walk desugars switch statements into a bunch of OEQ comparisons, and
sometimes (although rarely in practice) this currently requires
converting the tag value to the case value's type. And because this
conversion is inserted during walk, unified IR can't wire up
appropriate RTTI operands for the conversion.

As a simple solution, if any of the case values are *not* assignable
to the tag value's type, we instead convert them all to `any`. This
works because `any(x) == any(y)` yields the same value as `x == y`, as
long as neither `x` nor `y` are `nil`.

We never have to worry about `x` or `y` being `nil` either, because:

1. `switch nil` is invalid, so `x` can never be `nil`.

2. If the tag type is a channel, map, or function type, they
can *only* be compared against `nil`; so the case values will always
be assignable to the tag value's type, and so we won't convert to
`any`.

3. For other nullable types, the previous commit (adding explicit
`nil` handling to unified IR) ensures that `case nil:` is actually
treated as `case tagType(nil):`.

Change-Id: I3adcb9cf0d42a91a12b1a163c58d4133a24fca5e
Reviewed-on: https://go-review.googlesource.com/c/go/+/418101
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
Matthew Dempsky 2022-07-18 12:28:11 -07:00
parent 318027044a
commit a4c5198a3c
1 changed files with 37 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/cmd/compile/internal/noder/writer.go
View File

@ -1311,7 +1311,7 @@ func (w *writer) switchStmt(stmt *syntax.SwitchStmt) {
w.pos(stmt)
w.stmt(stmt.Init)
var iface types2.Type
var iface, tagType types2.Type
if guard, ok := stmt.Tag.(*syntax.TypeSwitchGuard); w.Bool(ok) {
iface = w.p.typeOf(guard.X)
@ -1322,7 +1322,32 @@ func (w *writer) switchStmt(stmt *syntax.SwitchStmt) {
}
w.expr(guard.X)
} else {
w.optExpr(stmt.Tag)
tag := stmt.Tag
if tag != nil {
tagType = w.p.typeOf(tag)
} else {
tagType = types2.Typ[types2.Bool]
}
// Walk is going to emit comparisons between the tag value and
// each case expression, and we want these comparisons to always
// have the same type. If there are any case values that can't be
// converted to the tag value's type, then convert everything to
// `any` instead.
Outer:
for _, clause := range stmt.Body {
for _, cas := range unpackListExpr(clause.Cases) {
if casType := w.p.typeOf(cas); !types2.AssignableTo(casType, tagType) {
tagType = types2.NewInterfaceType(nil, nil)
break Outer
}
}
}
if w.Bool(tag != nil) {
w.implicitConvExpr(tag, tagType, tag)
}
}
w.Len(len(stmt.Body))
@ -1334,15 +1359,22 @@ func (w *writer) switchStmt(stmt *syntax.SwitchStmt) {
w.pos(clause)
cases := unpackListExpr(clause.Cases)
if iface != nil {
cases := unpackListExpr(clause.Cases)
w.Len(len(cases))
for _, cas := range cases {
w.exprType(iface, cas, true)
}
} else {
// TODO(mdempsky): Implicit conversions to tagType, if appropriate.
w.exprList(clause.Cases)
// As if w.exprList(clause.Cases),
// but with implicit conversions to tagType.
w.Sync(pkgbits.SyncExprList)
w.Sync(pkgbits.SyncExprs)
w.Len(len(cases))
for _, cas := range cases {
w.implicitConvExpr(cas, tagType, cas)
}
}
if obj, ok := w.p.info.Implicits[clause]; ok {