Introduce a render.Error returned from the render panic.

This can be used to wrap underlying errors to convey more detail
about what errored, in particular this is used to wrap the error
returned in a panic, so that panic handling middleware can test for
this error and decide to supress the error or not.

render/json.go

@@ -55,7 +55,7 @@ var (
 // Render (JSON) writes data with custom ContentType.
 func (r JSON) Render(w http.ResponseWriter) (err error) {
 	if err = WriteJSON(w, r.Data); err != nil {
-		panic(err)
+		panic(Error{err: err})
 	}
 	return
 }

render/render.go

@@ -14,6 +14,19 @@ type Render interface {
 	WriteContentType(w http.ResponseWriter)
 }
 
+// Error is used to specifically wrap errors related to rendering
+type Error struct {
+	err error
+}
+
+func (e Error) Error() string {
+	return fmt.Sprintf("render: %v", e.err)
+}
+
+func (e Error) Unwrap() error {
+	return e.err
+}
+
 var (
 	_ Render     = JSON{}
 	_ Render     = IndentedJSON{}

render/render_test.go

@@ -13,7 +13,7 @@ import (
 	"strconv"
 	"strings"
 	"testing"
-
+	
 	testdata "github.com/gin-gonic/gin/testdata/protoexample"
 	"github.com/stretchr/testify/assert"
 	"google.golang.org/protobuf/proto"
@@ -43,8 +43,29 @@ func TestRenderJSONPanics(t *testing.T) {
 	w := httptest.NewRecorder()
 	data := make(chan int)
 
-	// json: unsupported type: chan int
-	assert.Panics(t, func() { assert.NoError(t, (JSON{data}).Render(w)) })
+	t.Run("panic", func(t *testing.T) {
+		// json: unsupported type: chan int
+		assert.Panics(t, func() { assert.NoError(t, (JSON{data}).Render(w)) })
+	})
+
+	t.Run("panic returns error", func(t *testing.T) {
+		func() {
+			defer func() {
+				p := recover()
+
+				err, ok := p.(error)
+				assert.True(t, ok)
+
+				e := Error{}
+				assert.True(t, errors.As(err, &e))
+
+				assert.ErrorContains(t, e.Unwrap(), "unsupported type")
+			}()
+
+			// Will panic
+			(JSON{data}).Render(w)
+		}()
+	})
 }
 
 func TestRenderIndentedJSON(t *testing.T) {