From e8475c94b82813889daa2b8188135f32f0625429 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 6 Apr 2017 20:27:33 -0700 Subject: [PATCH] cmd/compile/internal/types: shorten struct type names They are in the types package, no need to mention the Type suffix. Change-Id: Ie4fe1e3c1793514145e33f9df373d715f63e1aad Reviewed-on: https://go-review.googlesource.com/39911 Run-TryBot: Robert Griesemer Reviewed-by: Matthew Dempsky --- src/cmd/compile/internal/gc/align.go | 4 +- src/cmd/compile/internal/gc/bimport.go | 8 +- src/cmd/compile/internal/types/sizeof_test.go | 24 +-- src/cmd/compile/internal/types/type.go | 188 +++++++++--------- 4 files changed, 112 insertions(+), 112 deletions(-) diff --git a/src/cmd/compile/internal/gc/align.go b/src/cmd/compile/internal/gc/align.go index 3f0ff2c545..06cb524093 100644 --- a/src/cmd/compile/internal/gc/align.go +++ b/src/cmd/compile/internal/gc/align.go @@ -58,7 +58,7 @@ func expandiface(t *types.Type) { // Access fields directly to avoid recursively calling dowidth // within Type.Fields(). - t.Extra.(*types.InterType).Fields.Set(fields) + t.Extra.(*types.Interface).Fields.Set(fields) } func offmod(t *types.Type) { @@ -337,7 +337,7 @@ func dowidth(t *types.Type) { w = widstruct(t1, t1.Recvs(), 0, 0) w = widstruct(t1, t1.Params(), w, Widthreg) w = widstruct(t1, t1.Results(), w, Widthreg) - t1.Extra.(*types.FuncType).Argwid = w + t1.Extra.(*types.Func).Argwid = w if w%int64(Widthreg) != 0 { Warn("bad type %v %d\n", t1, w) } diff --git a/src/cmd/compile/internal/gc/bimport.go b/src/cmd/compile/internal/gc/bimport.go index 8b3669f19c..64f410fa80 100644 --- a/src/cmd/compile/internal/gc/bimport.go +++ b/src/cmd/compile/internal/gc/bimport.go @@ -505,16 +505,16 @@ func (p *importer) typ() *types.Type { t = p.newtyp(TARRAY) bound := p.int64() elem := p.typ() - t.Extra = &types.ArrayType{Elem: elem, Bound: bound} + t.Extra = &types.Array{Elem: elem, Bound: bound} case sliceTag: t = p.newtyp(TSLICE) elem := p.typ() - t.Extra = types.SliceType{Elem: elem} + t.Extra = types.Slice{Elem: elem} case dddTag: t = p.newtyp(TDDDFIELD) - t.Extra = types.DDDFieldType{T: p.typ()} + t.Extra = types.DDDField{T: p.typ()} case structTag: t = p.newtyp(TSTRUCT) @@ -523,7 +523,7 @@ func (p *importer) typ() *types.Type { case pointerTag: t = p.newtyp(types.Tptr) - t.Extra = types.PtrType{Elem: p.typ()} + t.Extra = types.Ptr{Elem: p.typ()} case signatureTag: t = p.newtyp(TFUNC) diff --git a/src/cmd/compile/internal/types/sizeof_test.go b/src/cmd/compile/internal/types/sizeof_test.go index a073f9b1a7..e3fa761692 100644 --- a/src/cmd/compile/internal/types/sizeof_test.go +++ b/src/cmd/compile/internal/types/sizeof_test.go @@ -24,18 +24,18 @@ func TestSizeof(t *testing.T) { }{ {Sym{}, 60, 104}, {Type{}, 52, 88}, - {MapType{}, 20, 40}, - {ForwardType{}, 20, 32}, - {FuncType{}, 28, 48}, - {StructType{}, 12, 24}, - {InterType{}, 4, 8}, - {ChanType{}, 8, 16}, - {ArrayType{}, 12, 16}, - {DDDFieldType{}, 4, 8}, - {FuncArgsType{}, 4, 8}, - {ChanArgsType{}, 4, 8}, - {PtrType{}, 4, 8}, - {SliceType{}, 4, 8}, + {Map{}, 20, 40}, + {Forward{}, 20, 32}, + {Func{}, 28, 48}, + {Struct{}, 12, 24}, + {Interface{}, 4, 8}, + {Chan{}, 8, 16}, + {Array{}, 12, 16}, + {DDDField{}, 4, 8}, + {FuncArgs{}, 4, 8}, + {ChanArgs{}, 4, 8}, + {Ptr{}, 4, 8}, + {Slice{}, 4, 8}, } for _, tt := range tests { diff --git a/src/cmd/compile/internal/types/type.go b/src/cmd/compile/internal/types/type.go index 89bf90700f..386d2f8d57 100644 --- a/src/cmd/compile/internal/types/type.go +++ b/src/cmd/compile/internal/types/type.go @@ -123,18 +123,18 @@ type Type struct { // As an optimization, those etype-specific structs which contain exactly // one pointer-shaped field are stored as values rather than pointers when possible. // - // TMAP: *MapType - // TFORW: *ForwardType - // TFUNC: *FuncType - // TSTRUCT: *StructType - // TINTER: *InterType - // TDDDFIELD: DDDFieldType - // TFUNCARGS: FuncArgsType - // TCHANARGS: ChanArgsType - // TCHAN: *ChanType - // TPTR32, TPTR64: PtrType - // TARRAY: *ArrayType - // TSLICE: SliceType + // TMAP: *Map + // TFORW: *Forward + // TFUNC: *Func + // TSTRUCT: *Struct + // TINTER: *Inter + // TDDDFIELD: DDDField + // TFUNCARGS: FuncArgs + // TCHANARGS: ChanArgs + // TCHAN: *Chan + // TPTR32, TPTR64: Ptr + // TARRAY: *Array + // TSLICE: Slice Extra interface{} // Width is the width of this Type in bytes. @@ -181,8 +181,8 @@ func (t *Type) SetNoalg(b bool) { t.flags.set(typeNoalg, b) } func (t *Type) SetDeferwidth(b bool) { t.flags.set(typeDeferwidth, b) } func (t *Type) SetRecur(b bool) { t.flags.set(typeRecur, b) } -// MapType contains Type fields specific to maps. -type MapType struct { +// Map contains Type fields specific to maps. +type Map struct { Key *Type // Key type Val *Type // Val (elem) type @@ -192,25 +192,25 @@ type MapType struct { } // MapType returns t's extra map-specific fields. -func (t *Type) MapType() *MapType { +func (t *Type) MapType() *Map { t.wantEtype(TMAP) - return t.Extra.(*MapType) + return t.Extra.(*Map) } -// ForwardType contains Type fields specific to forward types. -type ForwardType struct { +// Forward contains Type fields specific to forward types. +type Forward struct { Copyto []*Node // where to copy the eventual value to Embedlineno src.XPos // first use of this type as an embedded type } // ForwardType returns t's extra forward-type-specific fields. -func (t *Type) ForwardType() *ForwardType { +func (t *Type) ForwardType() *Forward { t.wantEtype(TFORW) - return t.Extra.(*ForwardType) + return t.Extra.(*Forward) } -// FuncType contains Type fields specific to func types. -type FuncType struct { +// Func contains Type fields specific to func types. +type Func struct { Receiver *Type // function receiver Results *Type // function results Params *Type // function params @@ -226,13 +226,13 @@ type FuncType struct { } // FuncType returns t's extra func-specific fields. -func (t *Type) FuncType() *FuncType { +func (t *Type) FuncType() *Func { t.wantEtype(TFUNC) - return t.Extra.(*FuncType) + return t.Extra.(*Func) } // StructType contains Type fields specific to struct types. -type StructType struct { +type Struct struct { fields Fields // Maps have three associated internal structs (see struct MapType). @@ -253,56 +253,56 @@ const ( ) // StructType returns t's extra struct-specific fields. -func (t *Type) StructType() *StructType { +func (t *Type) StructType() *Struct { t.wantEtype(TSTRUCT) - return t.Extra.(*StructType) + return t.Extra.(*Struct) } -// InterType contains Type fields specific to interface types. -type InterType struct { +// Interface contains Type fields specific to interface types. +type Interface struct { Fields Fields } -// PtrType contains Type fields specific to pointer types. -type PtrType struct { +// Ptr contains Type fields specific to pointer types. +type Ptr struct { Elem *Type // element type } -// DDDFieldType contains Type fields specific to TDDDFIELD types. -type DDDFieldType struct { +// DDDField contains Type fields specific to TDDDFIELD types. +type DDDField struct { T *Type // reference to a slice type for ... args } -// ChanArgsType contains Type fields specific to TCHANARGS types. -type ChanArgsType struct { +// ChanArgs contains Type fields specific to TCHANARGS types. +type ChanArgs struct { T *Type // reference to a chan type whose elements need a width check } -// // FuncArgsType contains Type fields specific to TFUNCARGS types. -type FuncArgsType struct { +// // FuncArgs contains Type fields specific to TFUNCARGS types. +type FuncArgs struct { T *Type // reference to a func type whose elements need a width check } -// ChanType contains Type fields specific to channel types. -type ChanType struct { +// Chan contains Type fields specific to channel types. +type Chan struct { Elem *Type // element type Dir ChanDir // channel direction } // ChanType returns t's extra channel-specific fields. -func (t *Type) ChanType() *ChanType { +func (t *Type) ChanType() *Chan { t.wantEtype(TCHAN) - return t.Extra.(*ChanType) + return t.Extra.(*Chan) } -// ArrayType contains Type fields specific to array types. -type ArrayType struct { +// Array contains Type fields specific to array types. +type Array struct { Elem *Type // element type Bound int64 // number of elements; <0 if unknown yet } -// SliceType contains Type fields specific to slice types. -type SliceType struct { +// Slice contains Type fields specific to slice types. +type Slice struct { Elem *Type // element type } @@ -406,25 +406,25 @@ func New(et EType) *Type { // TODO(josharian): lazily initialize some of these? switch t.Etype { case TMAP: - t.Extra = new(MapType) + t.Extra = new(Map) case TFORW: - t.Extra = new(ForwardType) + t.Extra = new(Forward) case TFUNC: - t.Extra = new(FuncType) + t.Extra = new(Func) case TSTRUCT: - t.Extra = new(StructType) + t.Extra = new(Struct) case TINTER: - t.Extra = new(InterType) + t.Extra = new(Interface) case TPTR32, TPTR64: - t.Extra = PtrType{} + t.Extra = Ptr{} case TCHANARGS: - t.Extra = ChanArgsType{} + t.Extra = ChanArgs{} case TFUNCARGS: - t.Extra = FuncArgsType{} + t.Extra = FuncArgs{} case TDDDFIELD: - t.Extra = DDDFieldType{} + t.Extra = DDDField{} case TCHAN: - t.Extra = new(ChanType) + t.Extra = new(Chan) } return t } @@ -435,7 +435,7 @@ func NewArray(elem *Type, bound int64) *Type { Fatalf("NewArray: invalid bound %v", bound) } t := New(TARRAY) - t.Extra = &ArrayType{Elem: elem, Bound: bound} + t.Extra = &Array{Elem: elem, Bound: bound} t.SetNotInHeap(elem.NotInHeap()) return t } @@ -450,7 +450,7 @@ func NewSlice(elem *Type) *Type { } t := New(TSLICE) - t.Extra = SliceType{Elem: elem} + t.Extra = Slice{Elem: elem} elem.SliceOf = t return t } @@ -458,7 +458,7 @@ func NewSlice(elem *Type) *Type { // NewDDDArray returns a new [...]T array Type. func NewDDDArray(elem *Type) *Type { t := New(TARRAY) - t.Extra = &ArrayType{Elem: elem, Bound: -1} + t.Extra = &Array{Elem: elem, Bound: -1} t.SetNotInHeap(elem.NotInHeap()) return t } @@ -504,7 +504,7 @@ func NewPtr(elem *Type) *Type { } t := New(Tptr) - t.Extra = PtrType{Elem: elem} + t.Extra = Ptr{Elem: elem} t.Width = int64(Widthptr) t.Align = uint8(Widthptr) if NewPtrCacheEnabled { @@ -516,21 +516,21 @@ func NewPtr(elem *Type) *Type { // NewDDDField returns a new TDDDFIELD type for slice type s. func NewDDDField(s *Type) *Type { t := New(TDDDFIELD) - t.Extra = DDDFieldType{T: s} + t.Extra = DDDField{T: s} return t } // NewChanArgs returns a new TCHANARGS type for channel type c. func NewChanArgs(c *Type) *Type { t := New(TCHANARGS) - t.Extra = ChanArgsType{T: c} + t.Extra = ChanArgs{T: c} return t } // NewFuncArgs returns a new TFUNCARGS type for func type f. func NewFuncArgs(f *Type) *Type { t := New(TFUNCARGS) - t.Extra = FuncArgsType{T: f} + t.Extra = FuncArgs{T: f} return t } @@ -562,28 +562,28 @@ func SubstAny(t *Type, types *[]*Type) *Type { elem := SubstAny(t.Elem(), types) if elem != t.Elem() { t = t.Copy() - t.Extra = PtrType{Elem: elem} + t.Extra = Ptr{Elem: elem} } case TARRAY: elem := SubstAny(t.Elem(), types) if elem != t.Elem() { t = t.Copy() - t.Extra.(*ArrayType).Elem = elem + t.Extra.(*Array).Elem = elem } case TSLICE: elem := SubstAny(t.Elem(), types) if elem != t.Elem() { t = t.Copy() - t.Extra = SliceType{Elem: elem} + t.Extra = Slice{Elem: elem} } case TCHAN: elem := SubstAny(t.Elem(), types) if elem != t.Elem() { t = t.Copy() - t.Extra.(*ChanType).Elem = elem + t.Extra.(*Chan).Elem = elem } case TMAP: @@ -591,8 +591,8 @@ func SubstAny(t *Type, types *[]*Type) *Type { val := SubstAny(t.Val(), types) if key != t.Key() || val != t.Val() { t = t.Copy() - t.Extra.(*MapType).Key = key - t.Extra.(*MapType).Val = val + t.Extra.(*Map).Key = key + t.Extra.(*Map).Val = val } case TFUNC: @@ -638,25 +638,25 @@ func (t *Type) Copy() *Type { // copy any *T Extra fields, to avoid aliasing switch t.Etype { case TMAP: - x := *t.Extra.(*MapType) + x := *t.Extra.(*Map) nt.Extra = &x case TFORW: - x := *t.Extra.(*ForwardType) + x := *t.Extra.(*Forward) nt.Extra = &x case TFUNC: - x := *t.Extra.(*FuncType) + x := *t.Extra.(*Func) nt.Extra = &x case TSTRUCT: - x := *t.Extra.(*StructType) + x := *t.Extra.(*Struct) nt.Extra = &x case TINTER: - x := *t.Extra.(*InterType) + x := *t.Extra.(*Interface) nt.Extra = &x case TCHAN: - x := *t.Extra.(*ChanType) + x := *t.Extra.(*Chan) nt.Extra = &x case TARRAY: - x := *t.Extra.(*ArrayType) + x := *t.Extra.(*Array) nt.Extra = &x } // TODO(mdempsky): Find out why this is necessary and explain. @@ -736,13 +736,13 @@ var ParamsResults = [2]func(*Type) *Type{ // Key returns the key type of map type t. func (t *Type) Key() *Type { t.wantEtype(TMAP) - return t.Extra.(*MapType).Key + return t.Extra.(*Map).Key } // Val returns the value type of map type t. func (t *Type) Val() *Type { t.wantEtype(TMAP) - return t.Extra.(*MapType).Val + return t.Extra.(*Map).Val } // Elem returns the type of elements of t. @@ -750,13 +750,13 @@ func (t *Type) Val() *Type { func (t *Type) Elem() *Type { switch t.Etype { case TPTR32, TPTR64: - return t.Extra.(PtrType).Elem + return t.Extra.(Ptr).Elem case TARRAY: - return t.Extra.(*ArrayType).Elem + return t.Extra.(*Array).Elem case TSLICE: - return t.Extra.(SliceType).Elem + return t.Extra.(Slice).Elem case TCHAN: - return t.Extra.(*ChanType).Elem + return t.Extra.(*Chan).Elem } Fatalf("Type.Elem %s", t.Etype) return nil @@ -765,26 +765,26 @@ func (t *Type) Elem() *Type { // DDDField returns the slice ... type for TDDDFIELD type t. func (t *Type) DDDField() *Type { t.wantEtype(TDDDFIELD) - return t.Extra.(DDDFieldType).T + return t.Extra.(DDDField).T } // ChanArgs returns the channel type for TCHANARGS type t. func (t *Type) ChanArgs() *Type { t.wantEtype(TCHANARGS) - return t.Extra.(ChanArgsType).T + return t.Extra.(ChanArgs).T } // FuncArgs returns the channel type for TFUNCARGS type t. func (t *Type) FuncArgs() *Type { t.wantEtype(TFUNCARGS) - return t.Extra.(FuncArgsType).T + return t.Extra.(FuncArgs).T } // Nname returns the associated function's nname. func (t *Type) Nname() *Node { switch t.Etype { case TFUNC: - return t.Extra.(*FuncType).Nname + return t.Extra.(*Func).Nname } Fatalf("Type.Nname %v %v", t.Etype, t) return nil @@ -794,7 +794,7 @@ func (t *Type) Nname() *Node { func (t *Type) SetNname(n *Node) { switch t.Etype { case TFUNC: - t.Extra.(*FuncType).Nname = n + t.Extra.(*Func).Nname = n default: Fatalf("Type.SetNname %v %v", t.Etype, t) } @@ -802,7 +802,7 @@ func (t *Type) SetNname(n *Node) { // IsFuncArgStruct reports whether t is a struct representing function parameters. func (t *Type) IsFuncArgStruct() bool { - return t.Etype == TSTRUCT && t.Extra.(*StructType).Funarg != FunargNone + return t.Etype == TSTRUCT && t.Extra.(*Struct).Funarg != FunargNone } func (t *Type) Methods() *Fields { @@ -818,10 +818,10 @@ func (t *Type) AllMethods() *Fields { func (t *Type) Fields() *Fields { switch t.Etype { case TSTRUCT: - return &t.Extra.(*StructType).fields + return &t.Extra.(*Struct).fields case TINTER: Dowidth(t) - return &t.Extra.(*InterType).Fields + return &t.Extra.(*Interface).Fields } Fatalf("Fields: type %v does not have fields", t) return nil @@ -873,7 +873,7 @@ func (t *Type) IsDDDArray() bool { if t.Etype != TARRAY { return false } - return t.Extra.(*ArrayType).Bound < 0 + return t.Extra.(*Array).Bound < 0 } func (t *Type) WidthCalculated() bool { @@ -884,7 +884,7 @@ func (t *Type) WidthCalculated() bool { // It includes the receiver, parameters, and results. func (t *Type) ArgWidth() int64 { t.wantEtype(TFUNC) - return t.Extra.(*FuncType).Argwid + return t.Extra.(*Func).Argwid } func (t *Type) Size() int64 { @@ -1255,7 +1255,7 @@ func (t *Type) FieldName(i int) string { func (t *Type) NumElem() int64 { t.wantEtype(TARRAY) - at := t.Extra.(*ArrayType) + at := t.Extra.(*Array) if at.Bound < 0 { Fatalf("NumElem array %v does not have bound yet", t) } @@ -1267,7 +1267,7 @@ func (t *Type) NumElem() int64 { // For other uses, create a new array with NewArray instead. func (t *Type) SetNumElem(n int64) { t.wantEtype(TARRAY) - at := t.Extra.(*ArrayType) + at := t.Extra.(*Array) if at.Bound >= 0 { Fatalf("SetNumElem array %v already has bound %d", t, at.Bound) } @@ -1278,7 +1278,7 @@ func (t *Type) SetNumElem(n int64) { // The direction will be one of Crecv, Csend, or Cboth. func (t *Type) ChanDir() ChanDir { t.wantEtype(TCHAN) - return t.Extra.(*ChanType).Dir + return t.Extra.(*Chan).Dir } func (t *Type) IsMemory() bool { return false } -- 2.48.1