cmd/compile/internal/types2: rename is_X predicates back to isX (step 2 of 2)

This is s/is_/is/ throughout. No other changes.

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

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index c92eccf76547ea226fcab1a61ecce70cd39b6d87..548d55e10c564330e8601890ae7b397d483bd5ba 100644 (file)
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -146,7 +146,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                var val constant.Value
                switch typ = arrayPtrDeref(under(x.typ)); t := typ.(type) {
                case *Basic:
-                       if is_String(t) && id == _Len {
+                       if isString(t) && id == _Len {
                                if x.mode == constant_ {
                                        mode = constant_
                                        val = constant.MakeInt64(int64(len(constant.StringVal(x.val))))
@@ -182,7 +182,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                        if t.underIs(func(t Type) bool {
                                switch t := arrayPtrDeref(t).(type) {
                                case *Basic:
-                                       if is_String(t) && id == _Len {
+                                       if isString(t) && id == _Len {
                                                return true
                                        }
                                case *Array, *Slice, *Chan:
@@ -267,7 +267,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                        //    because shifts of floats are not permitted)
                        if x.mode == constant_ && y.mode == constant_ {
                                toFloat := func(x *operand) {
-                                       if is_Numeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 {
+                                       if isNumeric(x.typ) && constant.Sign(constant.Imag(x.val)) == 0 {
                                                x.typ = Typ[UntypedFloat]
                                        }
                                }
@@ -398,7 +398,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                        if x.mode == constant_ {
                                // an untyped constant number can always be considered
                                // as a complex constant
-                               if is_Numeric(x.typ) {
+                               if isNumeric(x.typ) {
                                        x.typ = Typ[UntypedComplex]
                                }
                        } else {
@@ -726,7 +726,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                // assert(pred) causes a typechecker error if pred is false.
                // The result of assert is the value of pred if there is no error.
                // Note: assert is only available in self-test mode.
-               if x.mode != constant_ || !is_Boolean(x.typ) {
+               if x.mode != constant_ || !isBoolean(x.typ) {
                        check.errorf(x, invalidArg+"%s is not a boolean constant", x)
                        return
                }
@@ -802,7 +802,7 @@ func structure(typ Type) Type {
 func structureString(typ Type) Type {
        var su Type
        if underIs(typ, func(u Type) bool {
-               if is_String(u) {
+               if isString(u) {
                        u = NewSlice(universeByte)
                }
                if su != nil && !Identical(su, u) {

diff --git a/src/cmd/compile/internal/types2/check.go b/src/cmd/compile/internal/types2/check.go
index f69514e38a0c6e9383048ef99df26eeac2a3d266..b9a76a8990058e921ce71154281a13357ef5b81f 100644 (file)
--- a/src/cmd/compile/internal/types2/check.go
+++ b/src/cmd/compile/internal/types2/check.go
@@ -462,7 +462,7 @@ func (check *Checker) recordCommaOkTypes(x syntax.Expr, a [2]Type) {
        if a[0] == nil || a[1] == nil {
                return
        }
-       assert(isTyped(a[0]) && isTyped(a[1]) && (is_Boolean(a[1]) || a[1] == universeError))
+       assert(isTyped(a[0]) && isTyped(a[1]) && (isBoolean(a[1]) || a[1] == universeError))
        if m := check.Types; m != nil {
                for {
                        tv := m[x]

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index c029f1147d04b041ba5af6b2cfcf2389451510d7..bd7b82fabffa354b92b0673117977267800a8da4 100644 (file)
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -22,7 +22,7 @@ func (check *Checker) conversion(x *operand, T Type) {
                        // nothing to do
                case representableConst(x.val, check, t, val):
                        return true
-               case is_Integer(x.typ) && is_String(t):
+               case isInteger(x.typ) && isString(t):
                        codepoint := unicode.ReplacementChar
                        if i, ok := constant.Uint64Val(x.val); ok && i <= unicode.MaxRune {
                                codepoint = rune(i)
@@ -93,7 +93,7 @@ func (check *Checker) conversion(x *operand, T Type) {
                        // ok
                } else if IsInterface(T) || constArg && !isConstType(T) {
                        final = Default(x.typ)
-               } else if is_Integer(x.typ) && allString(T) {
+               } else if isInteger(x.typ) && allString(T) {
                        final = x.typ
                }
                check.updateExprType(x.expr, final, true)
@@ -197,22 +197,22 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool {
        }
 
        // "V and T are both integer or floating point types"
-       if is_IntegerOrFloat(V) && is_IntegerOrFloat(T) {
+       if isIntegerOrFloat(V) && isIntegerOrFloat(T) {
                return true
        }
 
        // "V and T are both complex types"
-       if is_Complex(V) && is_Complex(T) {
+       if isComplex(V) && isComplex(T) {
                return true
        }
 
        // "V is an integer or a slice of bytes or runes and T is a string type"
-       if (is_Integer(V) || isBytesOrRunes(Vu)) && is_String(T) {
+       if (isInteger(V) || isBytesOrRunes(Vu)) && isString(T) {
                return true
        }
 
        // "V is a string and T is a slice of bytes or runes"
-       if is_String(V) && isBytesOrRunes(Tu) {
+       if isString(V) && isBytesOrRunes(Tu) {
                return true
        }
 

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index 1db5af00da87501196451c004b481956cd189495..95b96f23345aa14f413d1ee9f23e32609d0c6b4d 100644 (file)
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -225,7 +225,7 @@ func (check *Checker) unary(x *operand, e *syntax.Operation) {
                        return
                }
                var prec uint
-               if is_Unsigned(x.typ) {
+               if isUnsigned(x.typ) {
                        prec = uint(check.conf.sizeof(x.typ) * 8)
                }
                x.val = constant.UnaryOp(op2tok[e.Op], x.val, prec)
@@ -302,7 +302,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
        }
 
        switch {
-       case is_Integer(typ):
+       case isInteger(typ):
                x := constant.ToInt(x)
                if x.Kind() != constant.Int {
                        return false
@@ -357,7 +357,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
                        return true
                }
 
-       case is_Float(typ):
+       case isFloat(typ):
                x := constant.ToFloat(x)
                if x.Kind() != constant.Float {
                        return false
@@ -387,7 +387,7 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
                        unreachable()
                }
 
-       case is_Complex(typ):
+       case isComplex(typ):
                x := constant.ToComplex(x)
                if x.Kind() != constant.Complex {
                        return false
@@ -419,10 +419,10 @@ func representableConst(x constant.Value, check *Checker, typ *Basic, rounded *c
                        unreachable()
                }
 
-       case is_String(typ):
+       case isString(typ):
                return x.Kind() == constant.String
 
-       case is_Boolean(typ):
+       case isBoolean(typ):
                return x.Kind() == constant.Bool
        }
 
@@ -474,7 +474,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er
        assert(x.mode == constant_)
        v := x.val
        if !representableConst(x.val, check, typ, &v) {
-               if is_Numeric(x.typ) && is_Numeric(typ) {
+               if isNumeric(x.typ) && isNumeric(typ) {
                        // numeric conversion : error msg
                        //
                        // integer -> integer : overflows
@@ -482,7 +482,7 @@ func (check *Checker) representation(x *operand, typ *Basic) (constant.Value, er
                        // float   -> integer : truncated
                        // float   -> float   : overflows
                        //
-                       if !is_Integer(x.typ) && is_Integer(typ) {
+                       if !isInteger(x.typ) && isInteger(typ) {
                                return nil, _TruncatedFloat
                        } else {
                                return nil, _NumericOverflow
@@ -630,7 +630,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
                // If x is the lhs of a shift, its final type must be integer.
                // We already know from the shift check that it is representable
                // as an integer if it is a constant.
-               if !is_Integer(typ) {
+               if !isInteger(typ) {
                        check.errorf(x, invalidOp+"shifted operand %s (type %s) must be integer", x, typ)
                        return
                }
@@ -692,7 +692,7 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
                // both x and target are untyped
                xkind := x.typ.(*Basic).kind
                tkind := target.(*Basic).kind
-               if is_Numeric(x.typ) && is_Numeric(target) {
+               if isNumeric(x.typ) && isNumeric(target) {
                        if xkind < tkind {
                                return target, nil, 0
                        }
@@ -725,18 +725,18 @@ func (check *Checker) implicitTypeAndValue(x *operand, target Type) (Type, const
                // the value nil.
                switch x.typ.(*Basic).kind {
                case UntypedBool:
-                       if !is_Boolean(target) {
+                       if !isBoolean(target) {
                                return nil, nil, _InvalidUntypedConversion
                        }
                case UntypedInt, UntypedRune, UntypedFloat, UntypedComplex:
-                       if !is_Numeric(target) {
+                       if !isNumeric(target) {
                                return nil, nil, _InvalidUntypedConversion
                        }
                case UntypedString:
                        // Non-constant untyped string values are not permitted by the spec and
                        // should not occur during normal typechecking passes, but this path is
                        // reachable via the AssignableTo API.
-                       if !is_String(target) {
+                       if !isString(target) {
                                return nil, nil, _InvalidUntypedConversion
                        }
                default:
@@ -856,7 +856,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
                }
        }
 
-       // Caution: Check for isUntyped first because is_Integer includes untyped
+       // Caution: Check for isUntyped first because isInteger includes untyped
        //          integers (was bug #43697).
        if isUntyped(y.typ) {
                check.convertUntyped(y, Typ[Uint])
@@ -880,7 +880,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
                        if x.val.Kind() == constant.Unknown || y.val.Kind() == constant.Unknown {
                                x.val = constant.MakeUnknown()
                                // ensure the correct type - see comment below
-                               if !is_Integer(x.typ) {
+                               if !isInteger(x.typ) {
                                        x.typ = Typ[UntypedInt]
                                }
                                return
@@ -897,7 +897,7 @@ func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) {
                        // (e.g., 2.0, an untyped float) - this can only happen for untyped
                        // non-integer numeric constants. Correct the type so that the shift
                        // result is of integer type.
-                       if !is_Integer(x.typ) {
+                       if !isInteger(x.typ) {
                                x.typ = Typ[UntypedInt]
                        }
                        // x is a constant so xval != nil and it must be of Int kind.
@@ -1054,7 +1054,7 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
                }
 
                // check for divisor underflow in complex division (see issue 20227)
-               if x.mode == constant_ && y.mode == constant_ && is_Complex(x.typ) {
+               if x.mode == constant_ && y.mode == constant_ && isComplex(x.typ) {
                        re, im := constant.Real(y.val), constant.Imag(y.val)
                        re2, im2 := constant.BinaryOp(re, token.MUL, re), constant.BinaryOp(im, token.MUL, im)
                        if constant.Sign(re2) == 0 && constant.Sign(im2) == 0 {
@@ -1074,7 +1074,7 @@ func (check *Checker) binary(x *operand, e syntax.Expr, lhs, rhs syntax.Expr, op
                }
                // force integer division for integer operands
                tok := op2tok[op]
-               if op == syntax.Div && is_Integer(x.typ) {
+               if op == syntax.Div && isInteger(x.typ) {
                        tok = token.QUO_ASSIGN
                }
                x.val = constant.BinaryOp(x.val, tok, y.val)

diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 1b080139f3c3724c0cf7b89970dbb952c3bbb20f..67110704e97f0d79d197b62f79ea3dd0181a9167 100644 (file)
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -51,7 +51,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
        length := int64(-1) // valid if >= 0
        switch typ := under(x.typ).(type) {
        case *Basic:
-               if is_String(typ) {
+               if isString(typ) {
                        valid = true
                        if x.mode == constant_ {
                                length = int64(len(constant.StringVal(x.val)))
@@ -109,7 +109,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
                        var k, e Type  // k is only set for maps
                        switch t := u.(type) {
                        case *Basic:
-                               if is_String(t) {
+                               if isString(t) {
                                        e = universeByte
                                        mode = value
                                }
@@ -217,7 +217,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
                return
 
        case *Basic:
-               if is_String(u) {
+               if isString(u) {
                        if e.Full {
                                check.error(x, invalidOp+"3-index slice of string")
                                x.mode = invalid

diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index 980d254084f405631a0c20cbc43b6c229832050f..5a82608671d1c41e97e4a041756822751291d78a 100644 (file)
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -25,18 +25,18 @@ func isGeneric(typ Type) bool {
        return named != nil && named.obj != nil && named.targs == nil && named.TypeParams() != nil
 }
 
-// The is_X predicates below report whether t is an X.
+// The isX predicates below report whether t is an X.
 // If t is a type parameter the result is false; i.e.,
 // these predicates don't look inside a type parameter.
 
-func is_Boolean(t Type) bool        { return isBasic(t, IsBoolean) }
-func is_Integer(t Type) bool        { return isBasic(t, IsInteger) }
-func is_Unsigned(t Type) bool       { return isBasic(t, IsUnsigned) }
-func is_Float(t Type) bool          { return isBasic(t, IsFloat) }
-func is_Complex(t Type) bool        { return isBasic(t, IsComplex) }
-func is_Numeric(t Type) bool        { return isBasic(t, IsNumeric) }
-func is_String(t Type) bool         { return isBasic(t, IsString) }
-func is_IntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) }
+func isBoolean(t Type) bool        { return isBasic(t, IsBoolean) }
+func isInteger(t Type) bool        { return isBasic(t, IsInteger) }
+func isUnsigned(t Type) bool       { return isBasic(t, IsUnsigned) }
+func isFloat(t Type) bool          { return isBasic(t, IsFloat) }
+func isComplex(t Type) bool        { return isBasic(t, IsComplex) }
+func isNumeric(t Type) bool        { return isBasic(t, IsNumeric) }
+func isString(t Type) bool         { return isBasic(t, IsString) }
+func isIntegerOrFloat(t Type) bool { return isBasic(t, IsInteger|IsFloat) }
 
 // isBasic reports whether under(t) is a basic type with the specified info.
 // If t is a type parameter the result is false; i.e.,
@@ -47,10 +47,10 @@ func isBasic(t Type, info BasicInfo) bool {
 }
 
 // The allX predicates below report whether t is an X.
-// If t is a type parameter the result is true if is_X is true
+// If t is a type parameter the result is true if isX is true
 // for all specified types of the type parameter's type set.
-// allX is an optimized version of is_X(structure(t)) (which
-// is the same as underIs(t, is_X)).
+// allX is an optimized version of isX(structure(t)) (which
+// is the same as underIs(t, isX)).
 
 func allBoolean(t Type) bool         { return allBasic(t, IsBoolean) }
 func allInteger(t Type) bool         { return allBasic(t, IsInteger) }

diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index 8f93ca6b872305953829e52949ec8de8363f54ec..6a3d19d8eaf293971266e4424ab57e97698092b1 100644 (file)
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -82,7 +82,7 @@ func (s *StdSizes) Alignof(T Type) int64 {
                return 1
        }
        // complex{64,128} are aligned like [2]float{32,64}.
-       if is_Complex(T) {
+       if isComplex(T) {
                a /= 2
        }
        if a > s.MaxAlign {

diff --git a/src/cmd/compile/internal/types2/stmt.go b/src/cmd/compile/internal/types2/stmt.go
index b8b53a868e6e4f4903109d561af2154d9fc7bda0..eaf420aca77ebeac4deec66786de82fb3e522b06 100644 (file)
--- a/src/cmd/compile/internal/types2/stmt.go
+++ b/src/cmd/compile/internal/types2/stmt.go
@@ -942,7 +942,7 @@ func (check *Checker) rangeStmt(inner stmtContext, s *syntax.ForStmt, rclause *s
 func rangeKeyVal(typ Type) (key, val Type) {
        switch typ := arrayPtrDeref(typ).(type) {
        case *Basic:
-               if is_String(typ) {
+               if isString(typ) {
                        return Typ[Int], universeRune // use 'rune' name
                }
        case *Array:

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 70071769800d67aaa327562ad55b5a7f2c04b24b..95893fd1e1d50afb8ac9f5c453c87fd9e7096d08 100644 (file)
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -513,7 +513,7 @@ func (check *Checker) arrayLength(e syntax.Expr) int64 {
                return -1
        }
 
-       if isUntyped(x.typ) || is_Integer(x.typ) {
+       if isUntyped(x.typ) || isInteger(x.typ) {
                if val := constant.ToInt(x.val); val.Kind() == constant.Int {
                        if representableConst(val, check, Typ[Int], nil) {
                                if n, ok := constant.Int64Val(val); ok && n >= 0 {