kleverr/stack.go at main · klev-dev/kleverr · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package kleverr

import (
	"errors"
	"fmt"
	"runtime"
	"strings"
)

type StackError struct {
	cause  error
	frames []StackFrame
}

type StackFrame struct {
	Func string
	File string
	Line int
}

func newStackError(err error, diff int) error {
	if err == nil {
		return nil
	}

	serr := &StackError{cause: err}

	var pcs = make([]uintptr, 32)
	if n := runtime.Callers(3+diff, pcs); n > 0 {
		frames := runtime.CallersFrames(pcs[:n])

		for {
			frame, more := frames.Next()

			serr.frames = append(serr.frames, StackFrame{
				Func: frame.Function,
				File: frame.File,
				Line: frame.Line,
			})

			if !more {
				break
			}
		}
	}

	return serr
}

func (e *StackError) Error() string {
	return e.cause.Error()
}

func (e *StackError) Unwrap() error {
	return e.cause
}

func (e *StackError) Print() string {
	var b = new(strings.Builder)
	fmt.Fprintf(b, "%s", e.cause.Error())
	for _, frame := range e.frames {
		fmt.Fprintf(b, "\n%s\n  %s:%d", frame.Func, frame.File, frame.Line)
	}

	if serr := Get(e.cause); serr != nil {
		fmt.Fprintln(b)
		fmt.Fprintln(b, serr.Print())
	}

	return b.String()
}

func Get(err error) *StackError {
	var e *StackError
	if errors.As(err, &e) {
		return e
	}
	return nil
}

func Ret(err error) error {
	return newStackError(err, 0)
}

func New(m string) error {
	return newStackError(errors.New(m), 0)
}

func Newf(m string, args ...any) error {
	return newStackError(fmt.Errorf(m, args...), 0)
}

func Ret1[X any](err error) (x X, serr error) {
	return x, newStackError(err, 0)
}

func New1[X any](m string) (x X, serr error) {
	return x, newStackError(errors.New(m), 0)
}

func New1f[X any](m string, args ...any) (x X, serr error) {
	return x, newStackError(fmt.Errorf(m, args...), 0)
}

func Ret2[X any, Y any](err error) (x X, y Y, serr error) {
	return x, y, newStackError(err, 0)
}

func New2[X any, Y any](m string) (x X, y Y, serr error) {
	return x, y, newStackError(errors.New(m), 0)
}

func New2f[X any, Y any](m string, args ...any) (x X, y Y, serr error) {
	return x, y, newStackError(fmt.Errorf(m, args...), 0)
}

func Ret3[X any, Y any, Z any](err error) (x X, y Y, z Z, serr error) {
	return x, y, z, newStackError(err, 0)
}

func New3[X any, Y any, Z any](m string) (x X, y Y, z Z, serr error) {
	return x, y, z, newStackError(errors.New(m), 0)
}

func New3f[X any, Y any, Z any](m string, args ...any) (x X, y Y, z Z, serr error) {
	return x, y, z, newStackError(fmt.Errorf(m, args...), 0)
}