all: remove redundant Swiss prefixes

Now that there is only one map implementation we can simplify names.

For golang#54766.

Change-Id: I6a6a636cc6a8fc5e7712c27782fc0ced7467b939
Reviewed-on: https://go-review.googlesource.com/c/go/+/691596
Reviewed-by: Keith Randall <[email protected]>
Auto-Submit: Michael Pratt <[email protected]>
Reviewed-by: Keith Randall <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: prattmic

src/cmd/compile/internal/reflectdata/map.go

@@ -15,10 +15,10 @@ import (
 	"internal/abi"
 )
 
-// SwissMapGroupType makes the map slot group type given the type of the map.
-func SwissMapGroupType(t *types.Type) *types.Type {
-	if t.MapType().SwissGroup != nil {
-		return t.MapType().SwissGroup
+// MapGroupType makes the map slot group type given the type of the map.
+func MapGroupType(t *types.Type) *types.Type {
+	if t.MapType().Group != nil {
+		return t.MapType().Group
 	}
 
 	// Builds a type representing a group structure for the given map type.
@@ -29,7 +29,7 @@ func SwissMapGroupType(t *types.Type) *types.Type {
 	//
 	// type group struct {
 	//     ctrl uint64
-	//     slots [abi.SwissMapGroupSlots]struct {
+	//     slots [abi.MapGroupSlots]struct {
 	//         key  keyType
 	//         elem elemType
 	//     }
@@ -39,10 +39,10 @@ func SwissMapGroupType(t *types.Type) *types.Type {
 	elemtype := t.Elem()
 	types.CalcSize(keytype)
 	types.CalcSize(elemtype)
-	if keytype.Size() > abi.SwissMapMaxKeyBytes {
+	if keytype.Size() > abi.MapMaxKeyBytes {
 		keytype = types.NewPtr(keytype)
 	}
-	if elemtype.Size() > abi.SwissMapMaxElemBytes {
+	if elemtype.Size() > abi.MapMaxElemBytes {
 		elemtype = types.NewPtr(elemtype)
 	}
 
@@ -53,7 +53,7 @@ func SwissMapGroupType(t *types.Type) *types.Type {
 	slot := types.NewStruct(slotFields)
 	slot.SetNoalg(true)
 
-	slotArr := types.NewArray(slot, abi.SwissMapGroupSlots)
+	slotArr := types.NewArray(slot, abi.MapGroupSlots)
 	slotArr.SetNoalg(true)
 
 	fields := []*types.Field{
@@ -76,25 +76,25 @@ func SwissMapGroupType(t *types.Type) *types.Type {
 		// the end to ensure pointers are valid.
 		base.Fatalf("bad group size for %v", t)
 	}
-	if t.Key().Size() > abi.SwissMapMaxKeyBytes && !keytype.IsPtr() {
+	if t.Key().Size() > abi.MapMaxKeyBytes && !keytype.IsPtr() {
 		base.Fatalf("key indirect incorrect for %v", t)
 	}
-	if t.Elem().Size() > abi.SwissMapMaxElemBytes && !elemtype.IsPtr() {
+	if t.Elem().Size() > abi.MapMaxElemBytes && !elemtype.IsPtr() {
 		base.Fatalf("elem indirect incorrect for %v", t)
 	}
 
-	t.MapType().SwissGroup = group
+	t.MapType().Group = group
 	group.StructType().Map = t
 	return group
 }
 
-var cachedSwissTableType *types.Type
+var cachedMapTableType *types.Type
 
-// swissTableType returns a type interchangeable with internal/runtime/maps.table.
+// mapTableType returns a type interchangeable with internal/runtime/maps.table.
 // Make sure this stays in sync with internal/runtime/maps/table.go.
-func swissTableType() *types.Type {
-	if cachedSwissTableType != nil {
-		return cachedSwissTableType
+func mapTableType() *types.Type {
+	if cachedMapTableType != nil {
+		return cachedMapTableType
 	}
 
 	// type table struct {
@@ -135,17 +135,17 @@ func swissTableType() *types.Type {
 		base.Fatalf("internal/runtime/maps.table size not correct: got %d, want %d", table.Size(), size)
 	}
 
-	cachedSwissTableType = table
+	cachedMapTableType = table
 	return table
 }
 
-var cachedSwissMapType *types.Type
+var cachedMapType *types.Type
 
-// SwissMapType returns a type interchangeable with internal/runtime/maps.Map.
+// MapType returns a type interchangeable with internal/runtime/maps.Map.
 // Make sure this stays in sync with internal/runtime/maps/map.go.
-func SwissMapType() *types.Type {
-	if cachedSwissMapType != nil {
-		return cachedSwissMapType
+func MapType() *types.Type {
+	if cachedMapType != nil {
+		return cachedMapType
 	}
 
 	// type Map struct {
@@ -191,23 +191,23 @@ func SwissMapType() *types.Type {
 		base.Fatalf("internal/runtime/maps.Map size not correct: got %d, want %d", m.Size(), size)
 	}
 
-	cachedSwissMapType = m
+	cachedMapType = m
 	return m
 }
 
-var cachedSwissIterType *types.Type
+var cachedMapIterType *types.Type
 
-// SwissMapIterType returns a type interchangeable with runtime.hiter.
-// Make sure this stays in sync with runtime/map.go.
-func SwissMapIterType() *types.Type {
-	if cachedSwissIterType != nil {
-		return cachedSwissIterType
+// MapIterType returns a type interchangeable with internal/runtime/maps.Iter.
+// Make sure this stays in sync with internal/runtime/maps/table.go.
+func MapIterType() *types.Type {
+	if cachedMapIterType != nil {
+		return cachedMapIterType
 	}
 
 	// type Iter struct {
 	//    key  unsafe.Pointer // *Key
 	//    elem unsafe.Pointer // *Elem
-	//    typ  unsafe.Pointer // *SwissMapType
+	//    typ  unsafe.Pointer // *MapType
 	//    m    *Map
 	//
 	//    groupSlotOffset uint64
@@ -231,13 +231,13 @@ func SwissMapIterType() *types.Type {
 		makefield("key", types.Types[types.TUNSAFEPTR]),  // Used in range.go for TMAP.
 		makefield("elem", types.Types[types.TUNSAFEPTR]), // Used in range.go for TMAP.
 		makefield("typ", types.Types[types.TUNSAFEPTR]),
-		makefield("m", types.NewPtr(SwissMapType())),
+		makefield("m", types.NewPtr(MapType())),
 		makefield("groupSlotOffset", types.Types[types.TUINT64]),
 		makefield("dirOffset", types.Types[types.TUINT64]),
 		makefield("clearSeq", types.Types[types.TUINT64]),
 		makefield("globalDepth", types.Types[types.TUINT8]),
 		makefield("dirIdx", types.Types[types.TINT]),
-		makefield("tab", types.NewPtr(swissTableType())),
+		makefield("tab", types.NewPtr(mapTableType())),
 		makefield("group", types.Types[types.TUNSAFEPTR]),
 		makefield("entryIdx", types.Types[types.TUINT64]),
 	}
@@ -257,13 +257,13 @@ func SwissMapIterType() *types.Type {
 		base.Fatalf("internal/runtime/maps.Iter size not correct: got %d, want %d", iter.Size(), size)
 	}
 
-	cachedSwissIterType = iter
+	cachedMapIterType = iter
 	return iter
 }
 
-func writeSwissMapType(t *types.Type, lsym *obj.LSym, c rttype.Cursor) {
-	// internal/abi.SwissMapType
-	gtyp := SwissMapGroupType(t)
+func writeMapType(t *types.Type, lsym *obj.LSym, c rttype.Cursor) {
+	// internal/abi.MapType
+	gtyp := MapGroupType(t)
 	s1 := writeType(t.Key())
 	s2 := writeType(t.Elem())
 	s3 := writeType(gtyp)
@@ -287,16 +287,16 @@ func writeSwissMapType(t *types.Type, lsym *obj.LSym, c rttype.Cursor) {
 	c.Field("ElemOff").WriteUintptr(uint64(elemOff))
 	var flags uint32
 	if needkeyupdate(t.Key()) {
-		flags |= abi.SwissMapNeedKeyUpdate
+		flags |= abi.MapNeedKeyUpdate
 	}
 	if hashMightPanic(t.Key()) {
-		flags |= abi.SwissMapHashMightPanic
+		flags |= abi.MapHashMightPanic
 	}
-	if t.Key().Size() > abi.SwissMapMaxKeyBytes {
-		flags |= abi.SwissMapIndirectKey
+	if t.Key().Size() > abi.MapMaxKeyBytes {
+		flags |= abi.MapIndirectKey
 	}
-	if t.Elem().Size() > abi.SwissMapMaxKeyBytes {
-		flags |= abi.SwissMapIndirectElem
+	if t.Elem().Size() > abi.MapMaxKeyBytes {
+		flags |= abi.MapIndirectElem
 	}
 	c.Field("Flags").WriteUint32(flags)
 

src/cmd/compile/internal/reflectdata/reflect.go

@@ -872,7 +872,7 @@ func writeType(t *types.Type) *obj.LSym {
 		}
 
 	case types.TMAP:
-		writeSwissMapType(t, lsym, c)
+		writeMapType(t, lsym, c)
 
 	case types.TPTR:
 		// internal/abi.PtrType

src/cmd/compile/internal/rttype/rttype.go

@@ -54,7 +54,7 @@ func Init() {
 	ChanType = FromReflect(reflect.TypeOf(abi.ChanType{}))
 	FuncType = FromReflect(reflect.TypeOf(abi.FuncType{}))
 	InterfaceType = FromReflect(reflect.TypeOf(abi.InterfaceType{}))
-	MapType = FromReflect(reflect.TypeOf(abi.SwissMapType{}))
+	MapType = FromReflect(reflect.TypeOf(abi.MapType{}))
 	PtrType = FromReflect(reflect.TypeOf(abi.PtrType{}))
 	SliceType = FromReflect(reflect.TypeOf(abi.SliceType{}))
 	StructType = FromReflect(reflect.TypeOf(abi.StructType{}))

src/cmd/compile/internal/ssagen/intrinsics.go

@@ -1508,7 +1508,7 @@ func initIntrinsics(cfg *intrinsicBuildConfig) {
 			// No PSIGNB, simply do byte equality with ctrlEmpty.
 
 			// Load ctrlEmpty into each byte of a control word.
-			var ctrlsEmpty uint64 = abi.SwissMapCtrlEmpty
+			var ctrlsEmpty uint64 = abi.MapCtrlEmpty
 			e := s.constInt64(types.Types[types.TUINT64], int64(ctrlsEmpty))
 			// Explicit copy to fp register. See
 			// https://go.dev/issue/70451.

src/cmd/compile/internal/ssagen/ssa.go

@@ -94,7 +94,7 @@ func InitConfig() {
 	_ = types.NewPtr(types.Types[types.TINT16])                             // *int16
 	_ = types.NewPtr(types.Types[types.TINT64])                             // *int64
 	_ = types.NewPtr(types.ErrorType)                                       // *error
-	_ = types.NewPtr(reflectdata.SwissMapType())                            // *internal/runtime/maps.Map
+	_ = types.NewPtr(reflectdata.MapType())                                 // *internal/runtime/maps.Map
 	_ = types.NewPtr(deferstruct())                                         // *runtime._defer
 	types.NewPtrCacheEnabled = false
 	ssaConfig = ssa.NewConfig(base.Ctxt.Arch.Name, *types_, base.Ctxt, base.Flag.N == 0, Arch.SoftFloat)
@@ -3080,7 +3080,7 @@ func (s *state) exprCheckPtr(n ir.Node, checkPtrOK bool) *ssa.Value {
 		}
 
 		// map <--> *internal/runtime/maps.Map
-		mt := types.NewPtr(reflectdata.SwissMapType())
+		mt := types.NewPtr(reflectdata.MapType())
 		if to.Kind() == types.TMAP && from == mt {
 			return v
 		}
@@ -5752,7 +5752,7 @@ func (s *state) referenceTypeBuiltin(n *ir.UnaryExpr, x *ssa.Value) *ssa.Value {
 	case ir.OLEN:
 		if n.X.Type().IsMap() {
 			// length is stored in the first word, but needs conversion to int.
-			loadType := reflectdata.SwissMapType().Field(0).Type // uint64
+			loadType := reflectdata.MapType().Field(0).Type // uint64
 			load := s.load(loadType, x)
 			s.vars[n] = s.conv(nil, load, loadType, lenType) // integer conversion doesn't need Node
 		} else {

src/cmd/compile/internal/types/fmt.go

@@ -474,7 +474,7 @@ func tconv2(b *bytes.Buffer, t *Type, verb rune, mode fmtMode, visited map[*Type
 			// Format the bucket struct for map[x]y as map.group[x]y.
 			// This avoids a recursive print that generates very long names.
 			switch t {
-			case mt.SwissGroup:
+			case mt.Group:
 				b.WriteString("map.group[")
 			default:
 				base.Fatalf("unknown internal map type")

src/cmd/compile/internal/types/type.go

@@ -280,7 +280,7 @@ type Map struct {
 	Key  *Type // Key type
 	Elem *Type // Val (elem) type
 
-	SwissGroup *Type // internal struct type representing a slot group
+	Group *Type // internal struct type representing a slot group
 }
 
 // MapType returns t's extra map-specific fields.

src/cmd/compile/internal/walk/builtin.go

@@ -313,7 +313,7 @@ func walkMakeChan(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 // walkMakeMap walks an OMAKEMAP node.
 func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 	t := n.Type()
-	mapType := reflectdata.SwissMapType()
+	mapType := reflectdata.MapType()
 	hint := n.Len
 
 	// var m *Map
@@ -326,38 +326,38 @@ func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		m = stackTempAddr(init, mapType)
 
 		// Allocate one group pointed to by m.dirPtr on stack if hint
-		// is not larger than SwissMapGroupSlots. In case hint is
+		// is not larger than MapGroupSlots. In case hint is
 		// larger, runtime.makemap will allocate on the heap.
 		// Maximum key and elem size is 128 bytes, larger objects
 		// are stored with an indirection. So max bucket size is 2048+eps.
 		if !ir.IsConst(hint, constant.Int) ||
-			constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(abi.SwissMapGroupSlots)) {
+			constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(abi.MapGroupSlots)) {
 
-			// In case hint is larger than SwissMapGroupSlots
+			// In case hint is larger than MapGroupSlots
 			// runtime.makemap will allocate on the heap, see
 			// #20184
 			//
-			// if hint <= abi.SwissMapGroupSlots {
+			// if hint <= abi.MapGroupSlots {
 			//     var gv group
 			//     g = &gv
-			//     g.ctrl = abi.SwissMapCtrlEmpty
+			//     g.ctrl = abi.MapCtrlEmpty
 			//     m.dirPtr = g
 			// }
 
-			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(base.Pos, abi.SwissMapGroupSlots)), nil, nil)
+			nif := ir.NewIfStmt(base.Pos, ir.NewBinaryExpr(base.Pos, ir.OLE, hint, ir.NewInt(base.Pos, abi.MapGroupSlots)), nil, nil)
 			nif.Likely = true
 
-			groupType := reflectdata.SwissMapGroupType(t)
+			groupType := reflectdata.MapGroupType(t)
 
 			// var gv group
 			// g = &gv
 			g := stackTempAddr(&nif.Body, groupType)
 
 			// Can't use ir.NewInt because bit 63 is set, which
 			// makes conversion to uint64 upset.
-			empty := ir.NewBasicLit(base.Pos, types.UntypedInt, constant.MakeUint64(abi.SwissMapCtrlEmpty))
+			empty := ir.NewBasicLit(base.Pos, types.UntypedInt, constant.MakeUint64(abi.MapCtrlEmpty))
 
-			// g.ctrl = abi.SwissMapCtrlEmpty
+			// g.ctrl = abi.MapCtrlEmpty
 			csym := groupType.Field(0).Sym // g.ctrl see reflectdata/map.go
 			ca := ir.NewAssignStmt(base.Pos, ir.NewSelectorExpr(base.Pos, ir.ODOT, g, csym), empty)
 			nif.Body.Append(ca)
@@ -370,12 +370,12 @@ func walkMakeMap(n *ir.MakeExpr, init *ir.Nodes) ir.Node {
 		}
 	}
 
-	if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(abi.SwissMapGroupSlots)) {
+	if ir.IsConst(hint, constant.Int) && constant.Compare(hint.Val(), token.LEQ, constant.MakeInt64(abi.MapGroupSlots)) {
 		// Handling make(map[any]any) and
-		// make(map[any]any, hint) where hint <= abi.SwissMapGroupSlots
+		// make(map[any]any, hint) where hint <= abi.MapGroupSlots
 		// specially allows for faster map initialization and
 		// improves binary size by using calls with fewer arguments.
-		// For hint <= abi.SwissMapGroupSlots no groups will be
+		// For hint <= abi.MapGroupSlots no groups will be
 		// allocated by makemap. Therefore, no groups need to be
 		// allocated in this code path.
 		if n.Esc() == ir.EscNone {

src/cmd/compile/internal/walk/order.go

@@ -966,8 +966,8 @@ func (o *orderState) stmt(n ir.Node) {
 			n.X = o.copyExpr(r)
 
 			// n.Prealloc is the temp for the iterator.
-			// SwissMapIterType contains pointers and needs to be zeroed.
-			n.Prealloc = o.newTemp(reflectdata.SwissMapIterType(), true)
+			// MapIterType contains pointers and needs to be zeroed.
+			n.Prealloc = o.newTemp(reflectdata.MapIterType(), true)
 		}
 		n.Key = o.exprInPlace(n.Key)
 		n.Value = o.exprInPlace(n.Value)

src/cmd/compile/internal/walk/range.go

@@ -246,7 +246,7 @@ func walkRange(nrange *ir.RangeStmt) ir.Node {
 		hit := nrange.Prealloc
 		th := hit.Type()
 		// depends on layout of iterator struct.
-		// See cmd/compile/internal/reflectdata/map.go:SwissMapIterType
+		// See cmd/compile/internal/reflectdata/map.go:MapIterType
 		keysym := th.Field(0).Sym
 		elemsym := th.Field(1).Sym // ditto
 		iterInit := "mapIterStart"