code review 4324043: fmt: remove uintptrGetter type checks

src/pkg/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 (
         "bytes"
         "io"
         "os"
@@ skipping 502 matching lines @@
         case 'X':
                 p.fmt.fmt_sX(s)
         case 'q':
                 p.fmt.fmt_q(s)
         default:
                 p.badVerb(verb, value)
         }
 }
 
 func (p *pp) fmtPointer(field interface{}, value reflect.Value, verb int, goSyntax bool) {
-        v, ok := value.(uintptrGetter)
-        if !ok { // reflect.PtrValue is a uintptrGetter, so failure means it's not a pointer at all.
+        var u uintptr
+        switch value.(type) {
+        case *reflect.ChanValue, *reflect.FuncValue, *reflect.MapValue, *reflect.PtrValue, *reflect.SliceValue, *reflect.UnsafePointerValue:
+                u = value.(uintptrGetter).Get()
+        default:
                 p.badVerb(verb, field)
                 return
         }
-        u := v.Get()
         if goSyntax {
                 p.add('(')
                 p.buf.WriteString(reflect.Typeof(field).String())
                 p.add(')')
                 p.add('(')
                 if u == 0 {
                         p.buf.Write(nilBytes)
                 } else {
-                        p.fmt0x64(uint64(v.Get()), true)
+                        p.fmt0x64(uint64(u), true)
                 }
                 p.add(')')
         } else {
                 p.fmt0x64(uint64(u), !p.fmt.sharp)
         }
 }
 
 var (
         intBits     = reflect.Typeof(0).Bits()
         floatBits   = reflect.Typeof(0.0).Bits()
@@ skipping 256 matching lines @@
                                 p.fmt0x64(uint64(v), true)
                         }
                         p.buf.WriteByte(')')
                         break
                 }
                 if v == 0 {
                         p.buf.Write(nilAngleBytes)
                         break
                 }
                 p.fmt0x64(uint64(v), true)
-        case uintptrGetter:
+        case *reflect.ChanValue, *reflect.FuncValue, *reflect.UnsafePointerValue:
                 p.fmtPointer(field, value, verb, goSyntax)
         default:
                 p.unknownType(f)
         }
         return false
 }
 
 // intFromArg gets the fieldnumth element of a. On return, isInt reports whether the argument has type int.
 func intFromArg(a []interface{}, end, i, fieldnum int) (num int, isInt bool, newi, newfieldnum int) {
         newi, newfieldnum = end, fieldnum
@@ skipping 114 matching lines @@
                         if addspace || !isString && !prevString {
                                 p.buf.WriteByte(' ')
                         }
                 }
                 prevString = p.printField(field, 'v', false, false, 0)
         }
         if addnewline {
                 p.buf.WriteByte('\n')
         }
 }