cmd/compile/internal/types2: clean up asT converters (step 2 of 2)

This CL renames the toT converters back to their asT names.

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

diff --git a/src/cmd/compile/internal/types2/assignments.go b/src/cmd/compile/internal/types2/assignments.go
index 0d647a493dd8b398f4766cd168e9ea38d37b97c9..bfc55786830cb88dad7d2927820c10b0841802e9 100644 (file)
--- a/src/cmd/compile/internal/types2/assignments.go
+++ b/src/cmd/compile/internal/types2/assignments.go
@@ -71,7 +71,7 @@ func (check *Checker) assignment(x *operand, T Type, context string) {
        // x.typ is typed
 
        // A generic (non-instantiated) function value cannot be assigned to a variable.
-       if sig := toSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 {
+       if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 {
                check.errorf(x, "cannot use generic function %s without instantiation in %s", x, context)
        }
 

diff --git a/src/cmd/compile/internal/types2/builtins.go b/src/cmd/compile/internal/types2/builtins.go
index b08a1343f36fce012dbc384cea872c11a03c0ea7..7897dafa4610a6986c185e1f006ce09536187d04 100644 (file)
--- a/src/cmd/compile/internal/types2/builtins.go
+++ b/src/cmd/compile/internal/types2/builtins.go
@@ -294,7 +294,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                // (applyTypeFunc never calls f with a type parameter)
                f := func(typ Type) Type {
                        assert(asTypeParam(typ) == nil)
-                       if t := toBasic(typ); t != nil {
+                       if t := asBasic(typ); t != nil {
                                switch t.kind {
                                case Float32:
                                        return Typ[Complex64]
@@ -418,7 +418,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                // (applyTypeFunc never calls f with a type parameter)
                f := func(typ Type) Type {
                        assert(asTypeParam(typ) == nil)
-                       if t := toBasic(typ); t != nil {
+                       if t := asBasic(typ); t != nil {
                                switch t.kind {
                                case Complex64:
                                        return Typ[Float32]
@@ -704,7 +704,7 @@ func (check *Checker) builtin(x *operand, call *syntax.CallExpr, id builtinId) (
                        return
                }
 
-               typ := toPointer(x.typ)
+               typ := asPointer(x.typ)
                if typ == nil {
                        check.errorf(x, invalidArg+"%s is not a pointer", x)
                        return
@@ -884,7 +884,7 @@ func makeSig(res Type, args ...Type) *Signature {
 // otherwise it returns typ.
 func arrayPtrDeref(typ Type) Type {
        if p, ok := typ.(*Pointer); ok {
-               if a := toArray(p.base); a != nil {
+               if a := asArray(p.base); a != nil {
                        return a
                }
        }

diff --git a/src/cmd/compile/internal/types2/call.go b/src/cmd/compile/internal/types2/call.go
index e4d57d45434767e241d3d9eae2241e9527ae3cae..1618e88feff4ebd483cd746e321dec3cbb43d24b 100644 (file)
--- a/src/cmd/compile/internal/types2/call.go
+++ b/src/cmd/compile/internal/types2/call.go
@@ -130,7 +130,7 @@ func (check *Checker) callExpr(x *operand, call *syntax.CallExpr) exprKind {
                case 1:
                        check.expr(x, call.ArgList[0])
                        if x.mode != invalid {
-                               if t := toInterface(T); t != nil {
+                               if t := asInterface(T); t != nil {
                                        if !t.IsMethodSet() {
                                                check.errorf(call, "cannot use interface %s in conversion (contains specific type constraints or is comparable)", T)
                                                break

diff --git a/src/cmd/compile/internal/types2/conversions.go b/src/cmd/compile/internal/types2/conversions.go
index 8897a15c4fed57827c5176c39a06a20a23f297c3..a456f89f7e02d2e1ccac0b50ad6237e9587b4885 100644 (file)
--- a/src/cmd/compile/internal/types2/conversions.go
+++ b/src/cmd/compile/internal/types2/conversions.go
@@ -21,7 +21,7 @@ func (check *Checker) conversion(x *operand, T Type) {
        switch {
        case constArg && isConstType(T):
                // constant conversion (T cannot be a type parameter)
-               switch t := toBasic(T); {
+               switch t := asBasic(T); {
                case representableConst(x.val, check, t, &x.val):
                        ok = true
                case isInteger(x.typ) && isString(t):
@@ -200,9 +200,9 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool {
 
        // "V a slice, T is a pointer-to-array type,
        // and the slice and array types have identical element types."
-       if s := toSlice(V); s != nil {
-               if p := toPointer(T); p != nil {
-                       if a := toArray(p.Elem()); a != nil {
+       if s := asSlice(V); s != nil {
+               if p := asPointer(T); p != nil {
+                       if a := asArray(p.Elem()); a != nil {
                                if Identical(s.Elem(), a.Elem()) {
                                        if check == nil || check.allowVersion(check.pkg, 1, 17) {
                                                return true
@@ -230,26 +230,26 @@ func convertibleToImpl(check *Checker, V, T Type, cause *string) bool {
 // use the toT convenience converters in the predicates below.
 
 func isUintptr(typ Type) bool {
-       t := toBasic(typ)
+       t := asBasic(typ)
        return t != nil && t.kind == Uintptr
 }
 
 func isUnsafePointer(typ Type) bool {
-       // TODO(gri): Is this toBasic(typ) instead of typ.(*Basic) correct?
+       // TODO(gri): Is this asBasic(typ) instead of typ.(*Basic) correct?
        //            (The former calls under(), while the latter doesn't.)
        //            The spec does not say so, but gc claims it is. See also
        //            issue 6326.
-       t := toBasic(typ)
+       t := asBasic(typ)
        return t != nil && t.kind == UnsafePointer
 }
 
 func isPointer(typ Type) bool {
-       return toPointer(typ) != nil
+       return asPointer(typ) != nil
 }
 
 func isBytesOrRunes(typ Type) bool {
-       if s := toSlice(typ); s != nil {
-               t := toBasic(s.elem)
+       if s := asSlice(typ); s != nil {
+               t := asBasic(s.elem)
                return t != nil && (t.kind == Byte || t.kind == Rune)
        }
        return false

diff --git a/src/cmd/compile/internal/types2/expr.go b/src/cmd/compile/internal/types2/expr.go
index c87e7fba82e230ab8247fec94360d3ea9f7a2ff7..9142eee85cee03e3fb78eac0253fec6d52f08b04 100644 (file)
--- a/src/cmd/compile/internal/types2/expr.go
+++ b/src/cmd/compile/internal/types2/expr.go
@@ -116,7 +116,7 @@ func (check *Checker) overflow(x *operand) {
        // x.typ cannot be a type parameter (type
        // parameters cannot be constant types).
        if isTyped(x.typ) {
-               check.representable(x, toBasic(x.typ))
+               check.representable(x, asBasic(x.typ))
                return
        }
 
@@ -617,7 +617,7 @@ func (check *Checker) updateExprType(x syntax.Expr, typ Type, final bool) {
        // If the new type is not final and still untyped, just
        // update the recorded type.
        if !final && isUntyped(typ) {
-               old.typ = toBasic(typ)
+               old.typ = asBasic(typ)
                check.untyped[x] = old
                return
        }
@@ -1387,7 +1387,7 @@ func (check *Checker) exprInternal(x *operand, e syntax.Expr, hint Type) exprKin
                                        duplicate := false
                                        // if the key is of interface type, the type is also significant when checking for duplicates
                                        xkey := keyVal(x.val)
-                                       if toInterface(utyp.key) != nil {
+                                       if asInterface(utyp.key) != nil {
                                                for _, vtyp := range visited[xkey] {
                                                        if Identical(vtyp, x.typ) {
                                                                duplicate = true

diff --git a/src/cmd/compile/internal/types2/index.go b/src/cmd/compile/internal/types2/index.go
index 325d3c2585a2d38c7b9d618946b7920b5e82f09e..62f49b95dabdd67e29610dffddd0feb7d2b36020 100644 (file)
--- a/src/cmd/compile/internal/types2/index.go
+++ b/src/cmd/compile/internal/types2/index.go
@@ -34,7 +34,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
                return false
 
        case value:
-               if sig := toSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 {
+               if sig := asSignature(x.typ); sig != nil && sig.TypeParams().Len() > 0 {
                        // function instantiation
                        return true
                }
@@ -72,7 +72,7 @@ func (check *Checker) indexExpr(x *operand, e *syntax.IndexExpr) (isFuncInst boo
                x.typ = typ.elem
 
        case *Pointer:
-               if typ := toArray(typ.base); typ != nil {
+               if typ := asArray(typ.base); typ != nil {
                        valid = true
                        length = typ.len
                        x.mode = variable
@@ -242,7 +242,7 @@ func (check *Checker) sliceExpr(x *operand, e *syntax.SliceExpr) {
                x.typ = &Slice{elem: u.elem}
 
        case *Pointer:
-               if u := toArray(u.base); u != nil {
+               if u := asArray(u.base); u != nil {
                        valid = true
                        length = u.len
                        x.typ = &Slice{elem: u.elem}

diff --git a/src/cmd/compile/internal/types2/lookup.go b/src/cmd/compile/internal/types2/lookup.go
index 652a04a6e38a51e6dbddf009902df5958be9b3b6..e0fd74482ab04307272fb20b972e6a1811cc8ac4 100644 (file)
--- a/src/cmd/compile/internal/types2/lookup.go
+++ b/src/cmd/compile/internal/types2/lookup.go
@@ -306,7 +306,7 @@ func (check *Checker) missingMethod(V Type, T *Interface, static bool) (method,
                return
        }
 
-       if ityp := toInterface(V); ityp != nil {
+       if ityp := asInterface(V); ityp != nil {
                // TODO(gri) the methods are sorted - could do this more efficiently
                for _, m := range T.typeSet().methods {
                        _, f := ityp.typeSet().LookupMethod(m.pkg, m.name)
@@ -417,7 +417,7 @@ func (check *Checker) assertableTo(V *Interface, T Type) (method, wrongType *Fun
        // no static check is required if T is an interface
        // spec: "If T is an interface type, x.(T) asserts that the
        //        dynamic type of x implements the interface T."
-       if toInterface(T) != nil && !forceStrict {
+       if asInterface(T) != nil && !forceStrict {
                return
        }
        return check.missingMethod(T, V, false)
@@ -435,8 +435,8 @@ func deref(typ Type) (Type, bool) {
 // derefStructPtr dereferences typ if it is a (named or unnamed) pointer to a
 // (named or unnamed) struct and returns its base. Otherwise it returns typ.
 func derefStructPtr(typ Type) Type {
-       if p := toPointer(typ); p != nil {
-               if toStruct(p.base) != nil {
+       if p := asPointer(typ); p != nil {
+               if asStruct(p.base) != nil {
                        return p.base
                }
        }

diff --git a/src/cmd/compile/internal/types2/predicates.go b/src/cmd/compile/internal/types2/predicates.go
index f89575b24c1672d4c8437888598af598260fce9c..4faa09ebd0dc2384d0fe4dac54911746a2ce51e3 100644 (file)
--- a/src/cmd/compile/internal/types2/predicates.go
+++ b/src/cmd/compile/internal/types2/predicates.go
@@ -56,7 +56,7 @@ func isNumericOrString(typ Type) bool { return is(typ, IsNumeric|IsString) }
 // are not fully set up.
 func isTyped(typ Type) bool {
        // isTyped is called with types that are not fully
-       // set up. Must not call toBasic()!
+       // set up. Must not call asBasic()!
        t, _ := typ.(*Basic)
        return t == nil || t.info&IsUntyped == 0
 }
@@ -70,13 +70,13 @@ func isOrdered(typ Type) bool { return is(typ, IsOrdered) }
 
 func isConstType(typ Type) bool {
        // Type parameters are never const types.
-       t := toBasic(typ)
+       t := asBasic(typ)
        return t != nil && t.info&IsConstType != 0
 }
 
 // IsInterface reports whether typ is an interface type.
 func IsInterface(typ Type) bool {
-       return toInterface(typ) != nil
+       return asInterface(typ) != nil
 }
 
 // Comparable reports whether values of type T are comparable.

diff --git a/src/cmd/compile/internal/types2/sizes.go b/src/cmd/compile/internal/types2/sizes.go
index 28597340e3181619e3670a8a6022945d62fc78b6..6a3d19d8eaf293971266e4424ab57e97698092b1 100644 (file)
--- a/src/cmd/compile/internal/types2/sizes.go
+++ b/src/cmd/compile/internal/types2/sizes.go
@@ -243,7 +243,7 @@ func (conf *Config) offsetsof(T *Struct) []int64 {
 func (conf *Config) offsetof(typ Type, index []int) int64 {
        var o int64
        for _, i := range index {
-               s := toStruct(typ)
+               s := asStruct(typ)
                o += conf.offsetsof(s)[i]
                typ = s.fields[i].typ
        }

diff --git a/src/cmd/compile/internal/types2/type.go b/src/cmd/compile/internal/types2/type.go
index 9ff8ad57d2388f65049bad8f7a05c37491bf94bb..33d3d3642c63f7bfa4bddbdf1e7adb1f72dd636c 100644 (file)
--- a/src/cmd/compile/internal/types2/type.go
+++ b/src/cmd/compile/internal/types2/type.go
@@ -29,37 +29,37 @@ func under(t Type) Type {
 
 // Convenience converters
 
-func toBasic(t Type) *Basic {
+func asBasic(t Type) *Basic {
        u, _ := under(t).(*Basic)
        return u
 }
 
-func toArray(t Type) *Array {
+func asArray(t Type) *Array {
        u, _ := under(t).(*Array)
        return u
 }
 
-func toSlice(t Type) *Slice {
+func asSlice(t Type) *Slice {
        u, _ := under(t).(*Slice)
        return u
 }
 
-func toStruct(t Type) *Struct {
+func asStruct(t Type) *Struct {
        u, _ := under(t).(*Struct)
        return u
 }
 
-func toPointer(t Type) *Pointer {
+func asPointer(t Type) *Pointer {
        u, _ := under(t).(*Pointer)
        return u
 }
 
-func toSignature(t Type) *Signature {
+func asSignature(t Type) *Signature {
        u, _ := under(t).(*Signature)
        return u
 }
 
-func toInterface(t Type) *Interface {
+func asInterface(t Type) *Interface {
        u, _ := under(t).(*Interface)
        return u
 }
@@ -83,8 +83,8 @@ func asTypeParam(t Type) *TypeParam {
 
 // Exported for the compiler.
 
-func AsPointer(t Type) *Pointer     { return toPointer(t) }
+func AsPointer(t Type) *Pointer     { return asPointer(t) }
 func AsNamed(t Type) *Named         { return asNamed(t) }
-func AsSignature(t Type) *Signature { return toSignature(t) }
-func AsInterface(t Type) *Interface { return toInterface(t) }
+func AsSignature(t Type) *Signature { return asSignature(t) }
+func AsInterface(t Type) *Interface { return asInterface(t) }
 func AsTypeParam(t Type) *TypeParam { return asTypeParam(t) }

diff --git a/src/cmd/compile/internal/types2/typestring.go b/src/cmd/compile/internal/types2/typestring.go
index 1804df2d995eae0f0adc7d32da283f4be92654ce..709499792be753723fe94a7cf3e839c0aee369b4 100644 (file)
--- a/src/cmd/compile/internal/types2/typestring.go
+++ b/src/cmd/compile/internal/types2/typestring.go
@@ -355,7 +355,7 @@ func (w *typeWriter) tuple(tup *Tuple, variadic bool) {
                                } else {
                                        // special case:
                                        // append(s, "foo"...) leads to signature func([]byte, string...)
-                                       if t := toBasic(typ); t == nil || t.kind != String {
+                                       if t := asBasic(typ); t == nil || t.kind != String {
                                                w.error("expected string type")
                                                continue
                                        }

diff --git a/src/cmd/compile/internal/types2/typexpr.go b/src/cmd/compile/internal/types2/typexpr.go
index 3704cda6a82d765d44b93c8aa6918237abf4fee8..d8183bfd9c9d726349f6c2d8459f000e8c884cce 100644 (file)
--- a/src/cmd/compile/internal/types2/typexpr.go
+++ b/src/cmd/compile/internal/types2/typexpr.go
@@ -148,7 +148,7 @@ func (check *Checker) varType(e syntax.Expr) Type {
        // are in the middle of type-checking parameter declarations that might belong to
        // interface methods. Delay this check to the end of type-checking.
        check.later(func() {
-               if t := toInterface(typ); t != nil {
+               if t := asInterface(typ); t != nil {
                        pos := syntax.StartPos(e)
                        tset := computeInterfaceTypeSet(check, pos, t) // TODO(gri) is this the correct position?
                        if !tset.IsMethodSet() {