Make be.ErrorAs type safe

This should be exactly as expressive in correct scenarios, but also
prevent a number of invalid inputs. It could theoretically be a breaking
change, but in practice I suspect it isn't.

Author: rliebz

be/errors.go

@@ -3,7 +3,6 @@ package be
 import (
 	"errors"
 	"fmt"
-	"reflect"
 	"strings"
 
 	"github.com/rliebz/ghost"
@@ -156,10 +155,8 @@ target: %v`,
 	}
 }
 
-var errorType = reflect.TypeOf((*error)(nil)).Elem()
-
 // ErrorAs asserts that an error matches another using [errors.As].
-func ErrorAs(err error, target any) ghost.Result {
+func ErrorAs[T error](err error, target *T) ghost.Result {
 	args := ghostlib.ArgsFromAST(err, target)
 	argErr, argTarget := args[0], args[1]
 
@@ -170,44 +167,23 @@ func ErrorAs(err error, target any) ghost.Result {
 		}
 	}
 
-	// These next few checks are for invalid usage, where errors.As will panic if
-	// a caller hits any of them. As an assertion library, it's probably more
-	// polite to never panic.
-
 	if target == nil {
 		return ghost.Result{
 			Ok:      false,
 			Message: fmt.Sprintf("target %v cannot be nil", argTarget),
 		}
 	}
 
-	val := reflect.ValueOf(target)
-	typ := val.Type()
-	if typ.Kind() != reflect.Ptr || val.IsNil() {
-		return ghost.Result{
-			Ok:      false,
-			Message: fmt.Sprintf("target %v must be a non-nil pointer", argTarget),
-		}
-	}
-	targetType := typ.Elem()
-
-	if targetType.Kind() != reflect.Interface && !targetType.Implements(errorType) {
-		return ghost.Result{
-			Ok:      false,
-			Message: fmt.Sprintf("*target %v must be interface or implement error", argTarget),
-		}
-	}
-
 	if errors.As(err, target) {
 		return ghost.Result{
 			Ok: true,
 			Message: fmt.Sprintf(`error %v set as target %v
 error:  %v
-target: %v`,
+target: %T`,
 				argErr,
 				argTarget,
 				err,
-				targetType,
+				*target,
 			),
 		}
 	}
@@ -216,11 +192,11 @@ target: %v`,
 		Ok: false,
 		Message: fmt.Sprintf(`error %v cannot be set as target %v
 error:  %v
-target: %v`,
+target: %T`,
 			argErr,
 			argTarget,
 			err,
-			targetType,
+			*target,
 		),
 	}
 }

be/errors_test.go

@@ -308,57 +308,27 @@ target: *strconv.NumError`,
 		var target error
 		var err error
 
-		result := be.ErrorAs(err, target)
+		result := be.ErrorAs(err, &target)
 		g.Should(be.False(result.Ok))
 		g.Should(be.Equal(result.Message, `error err was nil`))
 
-		result = be.ErrorAs(nil, nil)
+		result = be.ErrorAs(nil, new(error))
 		g.Should(be.False(result.Ok))
 		g.Should(be.Equal(result.Message, `error nil was nil`))
 	})
 
 	t.Run("nil target", func(t *testing.T) {
 		g := ghost.New(t)
 
-		var target error
+		var target *error
 		err := errors.New("oh no")
 
 		result := be.ErrorAs(err, target)
 		g.Should(be.False(result.Ok))
 		g.Should(be.Equal(result.Message, `target target cannot be nil`))
 
-		result = be.ErrorAs(errors.New("oh no"), nil)
-		g.Should(be.False(result.Ok))
-		g.Should(be.Equal(result.Message, `target nil cannot be nil`))
-	})
-
-	t.Run("non-pointer target", func(t *testing.T) {
-		g := ghost.New(t)
-
-		target := "Hello"
-		err := errors.New("oh no")
-
-		result := be.ErrorAs(err, target)
-		g.Should(be.False(result.Ok))
-		g.Should(be.Equal(result.Message, `target target must be a non-nil pointer`))
-
-		result = be.ErrorAs(errors.New("oh no"), "Hello")
-		g.Should(be.False(result.Ok))
-		g.Should(be.Equal(result.Message, `target "Hello" must be a non-nil pointer`))
-	})
-
-	t.Run("non-error target element", func(t *testing.T) {
-		g := ghost.New(t)
-
-		target := "Hello"
-		err := errors.New("oh no")
-
-		result := be.ErrorAs(err, &target)
-		g.Should(be.False(result.Ok))
-		g.Should(be.Equal(result.Message, `*target &target must be interface or implement error`))
-
-		result = be.ErrorAs(errors.New("oh no"), new(string))
+		result = be.ErrorAs[error](errors.New("oh no"), nil)
 		g.Should(be.False(result.Ok))
-		g.Should(be.Equal(result.Message, `*target new(string) must be interface or implement error`))
+		g.Should(be.Equal(result.Message, `target <nil> cannot be nil`))
 	})
 }