funcr: Handle nil Stringer, Marshaler, error

Produce a useful error rather thn panic.

funcr/funcr.go

@@ -341,6 +341,17 @@ const (
 	flagRawStruct = 0x1 // do not print braces on structs
 )
 
+func isNil(i interface{}) bool {
+	if i == nil {
+		return true
+	}
+	switch reflect.TypeOf(i).Kind() {
+	case reflect.Ptr, reflect.Map, reflect.Array, reflect.Chan, reflect.Slice:
+		return reflect.ValueOf(i).IsNil()
+	}
+	return false
+}
+
 // TODO: This is not fast. Most of the overhead goes here.
 func (f Formatter) prettyWithFlags(value interface{}, flags uint32, depth int) string {
 	if depth > f.opts.MaxLogDepth {
@@ -349,17 +360,29 @@ func (f Formatter) prettyWithFlags(value interface{}, flags uint32, depth int) s
 
 	// Handle types that take full control of logging.
 	if v, ok := value.(logr.Marshaler); ok {
-		// Replace the value with what the type wants to get logged.
-		// That then gets handled below via reflection.
-		value = v.MarshalLog()
+		if isNil(v) {
+			value = "<nil-logr-marshaler>"
+		} else {
+			// Replace the value with what the type wants to get logged.
+			// That then gets handled below via reflection.
+			value = v.MarshalLog()
+		}
 	}
 
 	// Handle types that want to format themselves.
 	switch v := value.(type) {
 	case fmt.Stringer:
-		value = v.String()
+		if isNil(v) {
+			value = "<nil-fmt-stringer>"
+		} else {
+			value = v.String()
+		}
 	case error:
-		value = v.Error()
+		if isNil(v) {
+			value = "<nil-error>"
+		} else {
+			value = v.Error()
+		}
 	}
 
 	// Handling the most common types without reflect is a small perf win.

funcr/funcr_test.go

@@ -52,7 +52,7 @@ func (p pointErr) MarshalText() ([]byte, error) {
 }
 
 // Logging this should result in the MarshalLog() value.
-type Tmarshaler string
+type Tmarshaler struct{ val string }
 
 func (t Tmarshaler) MarshalLog() interface{} {
 	return struct{ Inner string }{"I am a logr.Marshaler"}
@@ -67,7 +67,7 @@ func (t Tmarshaler) Error() string {
 }
 
 // Logging this should result in the String() value.
-type Tstringer string
+type Tstringer struct{ val string }
 
 func (t Tstringer) String() string {
 	return "I am a fmt.Stringer"
@@ -77,6 +77,13 @@ func (t Tstringer) Error() string {
 	return "Error(): you should not see this"
 }
 
+// Logging this should result in the Error() value.
+type Terror struct{ val string }
+
+func (t Terror) Error() string {
+	return "I am an error"
+}
+
 type TjsontagsString struct {
 	String1 string `json:"string1"`           // renamed
 	String2 string `json:"-"`                 // ignored
@@ -351,16 +358,40 @@ func TestPretty(t *testing.T) {
 			},
 		},
 		{
-			val: Tmarshaler("foobar"),
+			val: Tmarshaler{"foobar"},
 			exp: `{"Inner":"I am a logr.Marshaler"}`,
 		},
 		{
-			val: Tstringer("foobar"),
+			val: &Tmarshaler{"foobar"},
+			exp: `{"Inner":"I am a logr.Marshaler"}`,
+		},
+		{
+			val: (*Tmarshaler)(nil),
+			exp: `"<nil-logr-marshaler>"`,
+		},
+		{
+			val: Tstringer{"foobar"},
 			exp: `"I am a fmt.Stringer"`,
 		},
 		{
-			val: fmt.Errorf("error"),
-			exp: `"error"`,
+			val: &Tstringer{"foobar"},
+			exp: `"I am a fmt.Stringer"`,
+		},
+		{
+			val: (*Tstringer)(nil),
+			exp: `"<nil-fmt-stringer>"`,
+		},
+		{
+			val: Terror{"foobar"},
+			exp: `"I am an error"`,
+		},
+		{
+			val: &Terror{"foobar"},
+			exp: `"I am an error"`,
+		},
+		{
+			val: (*Terror)(nil),
+			exp: `"<nil-error>"`,
 		},
 		{
 			val: TjsontagsString{