[dev.typeparams] cmd/compile/internal/types2: translate syntax to token constants...

This makes the respective files match the respective go/types files
a tad more.

Change-Id: Ie555e18ed23c493379a1e56b96276867190106f0
Reviewed-on: https://go-review.googlesource.com/c/go/+/287492
Trust: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Findley <rfindley@google.com>

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 22dc47b1e76757f25106fbf3eb8520d9309a9313..3378c606ad354c9c787667b1c5bd252062a8db5b 100644 (file)
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -83,61 +83,6 @@ func (check *Checker) op(m opPredicates, x *operand, op syntax.Operator) bool {
        return true
 }
 
-func op2token(op syntax.Operator) token.Token {
-       switch op {
-       case syntax.Def: // :
-               unreachable()
-       case syntax.Not: // !
-               return token.NOT
-       case syntax.Recv: // <-
-               unreachable()
-
-       case syntax.OrOr: // ||
-               return token.LOR
-       case syntax.AndAnd: // &&
-               return token.LAND
-
-       case syntax.Eql: // ==
-               return token.EQL
-       case syntax.Neq: // !=
-               return token.NEQ
-       case syntax.Lss: // <
-               return token.LSS
-       case syntax.Leq: // <=
-               return token.LEQ
-       case syntax.Gtr: // >
-               return token.GTR
-       case syntax.Geq: // >=
-               return token.GEQ
-
-       case syntax.Add: // +
-               return token.ADD
-       case syntax.Sub: // -
-               return token.SUB
-       case syntax.Or: // |
-               return token.OR
-       case syntax.Xor: // ^
-               return token.XOR
-
-       case syntax.Mul: // *
-               return token.MUL
-       case syntax.Div: // /
-               return token.QUO
-       case syntax.Rem: // %
-               return token.REM
-       case syntax.And: // &
-               return token.AND
-       case syntax.AndNot: // &^
-               return token.AND_NOT
-       case syntax.Shl: // <<
-               return token.SHL
-       case syntax.Shr: // >>
-               return token.SHR
-       }
-
-       return token.ILLEGAL
-}
-
 // The unary expression e may be nil. It's passed in for better error messages only.
 func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator) {
        switch op {
@@ -182,7 +127,7 @@ func (check *Checker) unary(x *operand, e *syntax.Operation, op syntax.Operator)
                if isUnsigned(typ) {
                        prec = uint(check.conf.sizeof(typ) * 8)
                }
-               x.val = constant.UnaryOp(op2token(op), x.val, prec)
+               x.val = constant.UnaryOp(op2tok[op], x.val, prec)
                // Typed constants must be representable in
                // their type after each constant operation.
                if isTyped(typ) {
@@ -738,7 +683,7 @@ func (check *Checker) comparison(x, y *operand, op syntax.Operator) {
        }
 
        if x.mode == constant_ && y.mode == constant_ {
-               x.val = constant.MakeBool(constant.Compare(x.val, op2token(op), y.val))
+               x.val = constant.MakeBool(constant.Compare(x.val, op2tok[op], y.val))
                // The operands are never materialized; no need to update
                // their types.
        } else {
@@ -819,7 +764,7 @@ func (check *Checker) shift(x, y *operand, e *syntax.Operation, op syntax.Operat
                                x.typ = Typ[UntypedInt]
                        }
                        // x is a constant so xval != nil and it must be of Int kind.
-                       x.val = constant.Shift(xval, op2token(op), uint(s))
+                       x.val = constant.Shift(xval, op2tok[op], uint(s))
                        // Typed constants must be representable in
                        // their type after each constant operation.
                        if isTyped(x.typ) {
@@ -965,7 +910,7 @@ func (check *Checker) binary(x *operand, e *syntax.Operation, lhs, rhs syntax.Ex
                yval := y.val
                typ := x.typ.Basic()
                // force integer division of integer operands
-               tok := op2token(op)
+               tok := op2tok[op]
                if op == syntax.Div && isInteger(typ) {
                        tok = token.QUO_ASSIGN
                }
@@ -1951,3 +1896,33 @@ func (check *Checker) singleValue(x *operand) {
                }
        }
 }
+
+// op2tok translates syntax.Operators into token.Tokens.
+var op2tok = [...]token.Token{
+       syntax.Def:  token.ILLEGAL,
+       syntax.Not:  token.NOT,
+       syntax.Recv: token.ILLEGAL,
+
+       syntax.OrOr:   token.LOR,
+       syntax.AndAnd: token.LAND,
+
+       syntax.Eql: token.EQL,
+       syntax.Neq: token.NEQ,
+       syntax.Lss: token.LSS,
+       syntax.Leq: token.LEQ,
+       syntax.Gtr: token.GTR,
+       syntax.Geq: token.GEQ,
+
+       syntax.Add: token.ADD,
+       syntax.Sub: token.SUB,
+       syntax.Or:  token.OR,
+       syntax.Xor: token.XOR,
+
+       syntax.Mul:    token.MUL,
+       syntax.Div:    token.QUO,
+       syntax.Rem:    token.REM,
+       syntax.And:    token.AND,
+       syntax.AndNot: token.AND_NOT,
+       syntax.Shl:    token.SHL,
+       syntax.Shr:    token.SHR,
+}

diff --git a/src/cmd/compile/internal/types2/operand.go b/src/cmd/compile/internal/types2/operand.go
index a14120c2c9d929e1134486658051c7f7c6f745fa..dcd29fbce0e27476ca5a7ded0cce2518763019e7 100644 (file)
--- a/src/cmd/compile/internal/types2/operand.go
+++ b/src/cmd/compile/internal/types2/operand.go
@@ -206,29 +206,23 @@ func (x *operand) String() string {
 
 // setConst sets x to the untyped constant for literal lit.
 func (x *operand) setConst(k syntax.LitKind, lit string) {
-       var tok token.Token
        var kind BasicKind
        switch k {
        case syntax.IntLit:
-               tok = token.INT
                kind = UntypedInt
        case syntax.FloatLit:
-               tok = token.FLOAT
                kind = UntypedFloat
        case syntax.ImagLit:
-               tok = token.IMAG
                kind = UntypedComplex
        case syntax.RuneLit:
-               tok = token.CHAR
                kind = UntypedRune
        case syntax.StringLit:
-               tok = token.STRING
                kind = UntypedString
        default:
                unreachable()
        }
 
-       val := constant.MakeFromLiteral(lit, tok, 0)
+       val := constant.MakeFromLiteral(lit, kind2tok[k], 0)
        if val.Kind() == constant.Unknown {
                x.mode = invalid
                x.typ = Typ[Invalid]
@@ -334,3 +328,12 @@ func (x *operand) assignableTo(check *Checker, T Type, reason *string) bool {
 
        return false
 }
+
+// kind2tok translates syntax.LitKinds into token.Tokens.
+var kind2tok = [...]token.Token{
+       syntax.IntLit:    token.INT,
+       syntax.FloatLit:  token.FLOAT,
+       syntax.ImagLit:   token.IMAG,
+       syntax.RuneLit:   token.CHAR,
+       syntax.StringLit: token.STRING,
+}