Local modifications of golang source: Sort the keys of a map when printing them.

third_party/golang/src/fmt/print.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package fmt
 
 import (
         "errors"
         "io"
         "os"
         "reflect"
+        "sort"
         "sync"
         "unicode/utf8"
 )
 
 // Some constants in the form of bytes, to avoid string overhead.
 // Needlessly fastidious, I suppose.
 var (
         commaSpaceBytes  = []byte(", ")
         nilAngleBytes    = []byte("<nil>")
         nilParenBytes    = []byte("(nil)")
@@ skipping 821 matching lines @@
         }
         if handled := p.handleMethods(verb, depth); handled {
                 return false
         }
 
         return p.printReflectValue(value, verb, depth)
 }
 
 var byteType = reflect.TypeOf(byte(0))
 
+// Note(rudominer) Local change. We sort map keys when they are of numeric or string type.
+type valueComparison func(a, b reflect.Value) bool
+
+type valueSlice struct {
+        less   valueComparison
+        values []reflect.Value
+}
+
+func (v valueSlice) Len() int {
+        return len(v.values)
+}
+
+func (v valueSlice) Less(i, j int) bool {
+        return v.less(v.values[i], v.values[j])
+}
+
+func (v valueSlice) Swap(i, j int) {
+        v.values[i], v.values[j] = v.values[j], v.values[i]
+}
+
 // printReflectValue is the fallback for both printArg and printValue.
 // It uses reflect to print the value.
 func (p *pp) printReflectValue(value reflect.Value, verb rune, depth int) (wasString bool) {
         oldValue := p.value
         p.value = value
 BigSwitch:
         switch f := value; f.Kind() {
         case reflect.Invalid:
                 p.buf.WriteString("<invalid reflect.Value>")
         case reflect.Bool:
@@ skipping 21 matching lines @@
                         p.buf.WriteString(f.Type().String())
                         if f.IsNil() {
                                 p.buf.WriteString("(nil)")
                                 break
                         }
                         p.buf.WriteByte('{')
                 } else {
                         p.buf.Write(mapBytes)
                 }
                 keys := f.MapKeys()
+                // Note(rudominer) Local change. We sort map keys when they are of numeric or string type.
+                var compare valueComparison = nil
+                switch f.Type().Key().Kind() {
+                case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                        compare = func(a, b reflect.Value) bool { return a.Int() < b.Int() }
+                case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+                        compare = func(a, b reflect.Value) bool { return a.Uint() < b.Uint() }
+                case reflect.Float32, reflect.Float64:
+                        compare = func(a, b reflect.Value) bool { return a.Float() < b.Float() }
+                case reflect.String:
+                        compare = func(a, b reflect.Value) bool { return a.String() < b.String() }
+                }
+                if compare != nil {
+                        sort.Sort(valueSlice{compare, keys})
+                }
                 for i, key := range keys {
                         if i > 0 {
                                 if p.fmt.sharpV {
                                         p.buf.Write(commaSpaceBytes)
                                 } else {
                                         p.buf.WriteByte(' ')
                                 }
                         }
                         p.printValue(key, verb, depth+1)
                         p.buf.WriteByte(':')
@@ skipping 354 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printArg(arg, 'v', 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }