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
128
129
130
131
132
133
134
135
136
// // Copyright 2018 The Go Authors. All rights reserved.
// // Use of this source code is governed by a BSD-style
// // license that can be found in the LICENSE file.
// package errors
// import (
// "internal/reflectlite"
// )
// // Unwrap returns the result of calling the Unwrap method on err, if err's
// // type contains an Unwrap method returning error.
// // Otherwise, Unwrap returns nil.
// //
// // Unwrap only calls a method of the form "Unwrap() error".
// // In particular Unwrap does not unwrap errors returned by [Join].
// func Unwrap(err error) error {
// u, ok := err.(interface {
// Unwrap() error
// })
// if !ok {
// return nil
// }
// return u.Unwrap()
// }
// // Is reports whether any error in err's tree matches target.
// //
// // The tree consists of err itself, followed by the errors obtained by repeatedly
// // calling Unwrap. When err wraps multiple errors, Is examines err followed by a
// // depth-first traversal of its children.
// //
// // An error is considered to match a target if it is equal to that target or if
// // it implements a method Is(error) bool such that Is(target) returns true.
// //
// // An error type might provide an Is method so it can be treated as equivalent
// // to an existing error. For example, if MyError defines
// //
// // func (m MyError) Is(target error) bool { return target == fs.ErrExist }
// //
// // then Is(MyError{}, fs.ErrExist) returns true. See [syscall.Errno.Is] for
// // an example in the standard library. An Is method should only shallowly
// // compare err and the target and not call Unwrap on either.
// func Is(err, target error) bool {
// if target == nil {
// return err == target
// }
// isComparable := reflectlite.TypeOf(target).Comparable()
// for {
// if isComparable && err == target {
// return true
// }
// if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
// return true
// }
// switch x := err.(type) {
// case interface{ Unwrap() error }:
// err = x.Unwrap()
// if err == nil {
// return false
// }
// case interface{ Unwrap() []error }:
// for _, err := range x.Unwrap() {
// if Is(err, target) {
// return true
// }
// }
// return false
// default:
// return false
// }
// }
// }
// // As finds the first error in err's tree that matches target, and if one is found, sets
// // target to that error value and returns true. Otherwise, it returns false.
// //
// // The tree consists of err itself, followed by the errors obtained by repeatedly
// // calling Unwrap. When err wraps multiple errors, As examines err followed by a
// // depth-first traversal of its children.
// //
// // An error matches target if the error's concrete value is assignable to the value
// // pointed to by target, or if the error has a method As(interface{}) bool such that
// // As(target) returns true. In the latter case, the As method is responsible for
// // setting target.
// //
// // An error type might provide an As method so it can be treated as if it were a
// // different error type.
// //
// // As panics if target is not a non-nil pointer to either a type that implements
// // error, or to any interface type.
// func As(err error, target any) bool {
// if err == nil {
// return false
// }
// if target == nil {
// panic("errors: target cannot be nil")
// }
// val := reflectlite.ValueOf(target)
// typ := val.Type()
// if typ.Kind() != reflectlite.Ptr || val.IsNil() {
// panic("errors: target must be a non-nil pointer")
// }
// targetType := typ.Elem()
// if targetType.Kind() != reflectlite.Interface && !targetType.Implements(errorType) {
// panic("errors: *target must be interface or implement error")
// }
// for {
// if reflectlite.TypeOf(err).AssignableTo(targetType) {
// val.Elem().Set(reflectlite.ValueOf(err))
// return true
// }
// if x, ok := err.(interface{ As(any) bool }); ok && x.As(target) {
// return true
// }
// switch x := err.(type) {
// case interface{ Unwrap() error }:
// err = x.Unwrap()
// if err == nil {
// return false
// }
// case interface{ Unwrap() []error }:
// for _, err := range x.Unwrap() {
// if As(err, target) {
// return true
// }
// }
// return false
// default:
// return false
// }
// }
// }
// var errorType = reflectlite.TypeOf((*error)(nil)).Elem()