mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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>
This commit is contained in:
Robert Griesemer 2021-10-25 20:54:05 -07:00
parent d611f09200
commit a155a307fb
12 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cmd/compile/internal/types2/assignments.go
View File

@ -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)
}

8
src/cmd/compile/internal/types2/builtins.go
View File

@ -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
}
}

2
src/cmd/compile/internal/types2/call.go
View File

@ -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

20
src/cmd/compile/internal/types2/conversions.go
View File

@ -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

6
src/cmd/compile/internal/types2/expr.go
View File

@ -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

6
src/cmd/compile/internal/types2/index.go
View File

@ -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}

8
src/cmd/compile/internal/types2/lookup.go
View File

@ -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
}
}

6
src/cmd/compile/internal/types2/predicates.go
View File

@ -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.

2
src/cmd/compile/internal/types2/sizes.go
View File

@ -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
}

20
src/cmd/compile/internal/types2/type.go
View File

@ -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) }

2
src/cmd/compile/internal/types2/typestring.go
View File

@ -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
}

2
src/cmd/compile/internal/types2/typexpr.go
View File

@ -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() {