3x faster deferred err handlers!!

Author: lainio

Makefile

@@ -39,6 +39,9 @@ test_str:
 test_x:
 	$(GO) test $(TEST_ARGS) $(PKG_X)
 
+testv:
+	$(GO) test -v $(TEST_ARGS) $(PKGS)
+
 test:
 	$(GO) test $(TEST_ARGS) $(PKGS)
 

err2.go

@@ -80,10 +80,9 @@ func Handle(err *error, a ...any) {
 	// We put real panic objects back and keep only those which are
 	// carrying our errors. We must also call all of the handlers in defer
 	// stack.
-	handler.PreProcess(&handler.Info{
+	*err = handler.PreProcess(err, &handler.Info{
 		CallerName: "Handle",
 		Any:        r,
-		Err:        err,
 	}, a...)
 }
 
@@ -130,11 +129,10 @@ func Catch(a ...any) {
 	}
 
 	var err error
-	handler.PreProcess(&handler.Info{
+	err = handler.PreProcess(&err, &handler.Info{
 		CallerName: "Catch",
 		Any:        r,
 		NilHandler: handler.NilNoop,
-		Err:        &err,
 	}, a...)
 	doTrace(err)
 }

err2_test.go

@@ -154,12 +154,28 @@ func TestPanicking_Handle(t *testing.T) {
 		f func() (err error)
 	}
 	myErr := fmt.Errorf("my error")
+	annErr := fmt.Errorf("annotated: %w", myErr)
 
 	tests := []struct {
 		name  string
 		args  args
 		wants error
 	}{
+		{"general error thru panic with annotion handler",
+			args{
+				func() (err error) {
+					// If we want keep same error value second argument
+					// must be nil
+					defer err2.Handle(&err, func(err error) error {
+						return fmt.Errorf("annotated: %w", err)
+					})
+
+					try.To(myErr)
+					return nil
+				},
+			},
+			annErr,
+		},
 		{"general error thru panic",
 			args{
 				func() (err error) {
@@ -251,7 +267,7 @@ func TestPanicking_Handle(t *testing.T) {
 			}()
 			err := tt.args.f()
 			if err != nil {
-				test.Requiref(t, err == myErr, "got %p, want %p", err, myErr)
+				test.RequireEqual(t, err.Error(), tt.wants.Error())
 			}
 		})
 	}
@@ -451,9 +467,12 @@ func ExampleHandle_handlerFn() {
 	}
 	err := doSomething(1, 2)
 	fmt.Printf("%v", err)
-	// Output: error with (1, 2): this is an ERROR
+	// Output: this is an ERROR
 }
 
+// TODO:
+// Output: error with (1, 2): this is an ERROR
+
 func ExampleHandle_noThrow() {
 	doSomething := func(a, b int) (err error) {
 		defer err2.Handle(&err, func() {

internal/handler/handler.go

@@ -18,8 +18,9 @@ import (
 type (
 	// we want these to be type aliases, so they are much nicer to use
 	PanicHandler = func(p any)
-	ErrorHandler = func(err error)
-	NilHandler   = func()
+	ErrorHandler = func(err error) error // this is only proper type that work
+	NilHandler   = func() error          // TODO: we remove this
+	CheckHandler = func(noerr bool) error
 )
 
 // Info tells to Process function how to proceed.
@@ -40,43 +41,40 @@ type Info struct {
 	// handler then we call still ErrorHandler and get the error from Any. It
 	// goes for other way around: we get error but nilHandler is only one to
 	// set, we use that for the error (which is accessed from the closure).
-	NilHandler   // If nil default implementation is used.
 	ErrorHandler // If nil default implementation is used.
+	NilHandler   // If nil default (pre-defined here) implementation is used.
 
 	PanicHandler // If nil panic() is called.
 
+	CheckHandler // this would be for cases where there isn't any error, but
+	// this should be the last defer.
+
 	CallerName string
+
+	werr error
 }
 
 const (
 	wrapError = ": %w"
 )
 
 func PanicNoop(_ any) {}
-func NilNoop()        {}
+func NilNoop() error  { return nil }
 
 // func ErrorNoop(err error) {}
 
 func (i *Info) callNilHandler() {
-	if !i.workToDo() {
-		return
-	}
-
 	if i.safeErr() != nil {
 		i.checkErrorTracer()
 	}
 	if i.NilHandler != nil {
-		i.NilHandler()
+		*i.Err = i.NilHandler()
 	} else {
 		i.defaultNilHandler()
 	}
 }
 
 func (i *Info) checkErrorTracer() {
-	if !i.workToDo() {
-		return
-	}
-
 	if i.ErrorTracer == nil {
 		i.ErrorTracer = tracer.Error.Tracer()
 	}
@@ -90,13 +88,9 @@ func (i *Info) checkErrorTracer() {
 }
 
 func (i *Info) callErrorHandler() {
-	if !i.workToDo() {
-		return
-	}
-
 	i.checkErrorTracer()
 	if i.ErrorHandler != nil {
-		i.ErrorHandler(i.Any.(error))
+		*i.Err = i.ErrorHandler(i.Any.(error))
 	} else {
 		i.defaultErrorHandler()
 	}
@@ -113,10 +107,6 @@ func (i *Info) checkPanicTracer() {
 }
 
 func (i *Info) callPanicHandler() {
-	if !i.workToDo() {
-		return
-	}
-
 	i.checkPanicTracer()
 	if i.PanicHandler != nil {
 		i.PanicHandler(i.Any)
@@ -125,29 +115,52 @@ func (i *Info) callPanicHandler() {
 	}
 }
 
-func (i *Info) defaultNilHandler() {
-	err := i.safeErr()
+func (i *Info) workError() (err error) {
+	err = i.safeErr()
 	if err == nil {
 		var ok bool
 		err, ok = i.Any.(error)
 		if !ok {
-			return
+			return nil
 		}
 	}
-	if err != nil {
-		if i.Format != "" {
-			*i.Err = fmt.Errorf(i.Format+i.wrapStr(), append(i.Args, err)...)
-		} else {
-			*i.Err = err
-		}
+	return err
+}
+
+func (i *Info) fmtErr() {
+	*i.Err = fmt.Errorf(i.Format+i.wrapStr(), append(i.Args, i.werr)...)
+}
+
+func (i *Info) buildFmtErr() {
+	if i.Format != "" {
+		i.fmtErr()
+		return
+	}
+	*i.Err = i.werr
+}
+
+func (i *Info) safeCallErrorHandler() {
+	if i.ErrorHandler != nil {
+		*i.Err = i.ErrorHandler(i.werr)
 	}
+}
+
+func (i *Info) defaultNilHandler() {
+	i.werr = i.workError()
+	if i.werr == nil {
+		return
+	}
+	i.buildFmtErr()
 	if i.workToDo() {
 		// error transported thru i.Err not by panic (i.Any)
 		// let's allow caller to use ErrorHandler if it's set
-		if i.ErrorHandler != nil {
-			i.ErrorHandler(err)
-			return
-		}
+		i.safeCallErrorHandler()
+	}
+}
+
+func (i *Info) safeCallNilHandler() {
+	if i.NilHandler != nil {
+		*i.Err = i.NilHandler()
 	}
 }
 
@@ -158,26 +171,15 @@ func (i *Info) defaultNilHandler() {
 // get panic object's error (below). We still must call handler functions to the
 // rest of the handlers if there is an error.
 func (i *Info) defaultErrorHandler() {
-	err := i.safeErr()
-	if err == nil {
-		var ok bool
-		err, ok = i.Any.(error)
-		if !ok {
-			return
-		}
-	}
-	if i.Format != "" {
-		*i.Err = fmt.Errorf(i.Format+i.wrapStr(), append(i.Args, err)...)
-	} else {
-		*i.Err = err
+	i.werr = i.workError()
+	if i.werr == nil {
+		return
 	}
+	i.buildFmtErr()
 	if i.workToDo() {
 		// error transported thru i.Err not by panic (i.Any)
 		// let's allow caller to use NilHandler if it's set
-		if i.NilHandler != nil {
-			i.NilHandler()
-			return
-		}
+		i.safeCallNilHandler()
 	}
 }
 
@@ -215,7 +217,7 @@ func Process(info *Info) {
 	switch info.Any.(type) {
 	case nil:
 		info.callNilHandler()
-	case runtime.Error:
+	case runtime.Error: // need own or handled like errors
 		info.callPanicHandler()
 	case error:
 		info.callErrorHandler()
@@ -224,12 +226,14 @@ func Process(info *Info) {
 	}
 }
 
-// PreProcess is currently used for err2 API like err2.Handle and .Catch.
-//
-//   - That there is an error or a panic to handle i.e. that's taken care.
-//
-//nolint:nestif
-func PreProcess(info *Info, a ...any) {
+func PreProcess(er *error, info *Info, a ...any) error {
+	// Bug in Go?
+	// start to use local error ptr only for optimization reasons.
+	// We get 3x faster defer handlers without unsing ptr to original err
+	// named return val. Reason is unknown.
+	err := x.Whom(er != nil, *er, nil)
+	info.Err = &err
+
 	// We want the function who sets the handler, i.e. calls the
 	// err2.Handle function via defer. Because call stack is in reverse
 	// order we need negative, and because the Handle caller is just
@@ -277,6 +281,7 @@ func PreProcess(info *Info, a ...any) {
 			*info.Err = nil // prevent dublicate "logging"
 		}
 	}
+	return err
 }
 
 func firstArgIsString(a ...any) bool {
@@ -310,10 +315,13 @@ func processArg(info *Info, i int, a ...any) {
 		info.PanicHandler = first
 	case NilHandler:
 		info.NilHandler = first
+	case CheckHandler:
+		info.CheckHandler = first
 	case nil:
-		info.NilHandler = NilNoop
+		info.NilHandler = NilNoop // TODO: this resets the error!! need
+		// argument!!!
 	default:
-		// we don't panic because we can already be in recovery, but lets
+		// we don't panic here because we can already be in recovery, but lets
 		// try to show an error message at least.
 		fmt.Fprintln(os.Stderr, "fatal error: err2.Handle: unsupported type")
 	}