Merge branch 'alloc_no_trace'

Author: funny-falcon

builder.go

@@ -12,21 +12,20 @@ type ErrorBuilder struct {
 	errorType     *Type
 	message       string
 	cause         error
-	underlying    []error
 	mode          callStackBuildMode
 	isTransparent bool
 }
 
 // NewErrorBuilder creates error builder from an existing error type.
-func NewErrorBuilder(t *Type) *ErrorBuilder {
+func NewErrorBuilder(t *Type) ErrorBuilder {
 	getMode := func() callStackBuildMode {
 		if !t.modifiers.CollectStackTrace() {
 			return stackTraceOmit
 		}
 		return stackTraceCollect
 	}
 
-	return &ErrorBuilder{
+	return ErrorBuilder{
 		errorType:     t,
 		mode:          getMode(),
 		isTransparent: t.modifiers.Transparent(),
@@ -37,7 +36,7 @@ func NewErrorBuilder(t *Type) *ErrorBuilder {
 // For non-errorx errors, a stack trace is collected.
 // Otherwise, it is inherited by default, as error wrapping is typically performed 'en passe'.
 // Note that even if an original error explicitly omitted the stack trace, it could be added on wrap.
-func (eb *ErrorBuilder) WithCause(err error) *ErrorBuilder {
+func (eb ErrorBuilder) WithCause(err error) ErrorBuilder {
 	eb.cause = err
 	if Cast(err) != nil {
 		eb.mode = stackTraceBorrow
@@ -50,7 +49,7 @@ func (eb *ErrorBuilder) WithCause(err error) *ErrorBuilder {
 // Transparent wrap hides the current error type from the type checks and exposes the error type of the cause instead.
 // The same holds true for traits, and the dynamic properties are visible from both cause and transparent wrapper.
 // Note that if the cause error is non-errorx, transparency will still hold, type check against wrapper will still fail.
-func (eb *ErrorBuilder) Transparent() *ErrorBuilder {
+func (eb ErrorBuilder) Transparent() ErrorBuilder {
 	if eb.cause == nil {
 		panic("wrong builder usage: wrap modifier without non-nil cause")
 	}
@@ -64,7 +63,7 @@ func (eb *ErrorBuilder) Transparent() *ErrorBuilder {
 // This is typically a way to handle an error received from another goroutine - say, a worker pool.
 // When stack traces overlap, formatting makes a conservative attempt not to repeat itself,
 // preserving the *original* stack trace in its entirety.
-func (eb *ErrorBuilder) EnhanceStackTrace() *ErrorBuilder {
+func (eb ErrorBuilder) EnhanceStackTrace() ErrorBuilder {
 	if eb.cause == nil {
 		panic("wrong builder usage: wrap modifier without non-nil cause")
 	}
@@ -81,7 +80,7 @@ func (eb *ErrorBuilder) EnhanceStackTrace() *ErrorBuilder {
 // WithConditionallyFormattedMessage provides a message for an error in flexible format, to simplify its usages.
 // Without args, leaves the original message intact, so a message may be generated or provided externally.
 // With args, a formatting is performed, and it is therefore expected a format string to be constant.
-func (eb *ErrorBuilder) WithConditionallyFormattedMessage(message string, args ...interface{}) *ErrorBuilder {
+func (eb ErrorBuilder) WithConditionallyFormattedMessage(message string, args ...interface{}) ErrorBuilder {
 	if len(args) == 0 {
 		eb.message = message
 	} else {
@@ -92,15 +91,15 @@ func (eb *ErrorBuilder) WithConditionallyFormattedMessage(message string, args .
 }
 
 // Create returns an error with specified params.
-func (eb *ErrorBuilder) Create() *Error {
-	return &Error{
+func (eb ErrorBuilder) Create() *Error {
+	err := &Error{
 		errorType:   eb.errorType,
 		message:     eb.message,
 		cause:       eb.cause,
-		underlying:  eb.underlying,
 		transparent: eb.isTransparent,
 		stackTrace:  eb.assembleStackTrace(),
 	}
+	return err
 }
 
 type callStackBuildMode int
@@ -112,7 +111,7 @@ const (
 	stackTraceOmit    callStackBuildMode = 4
 )
 
-func (eb *ErrorBuilder) assembleStackTrace() *stackTrace {
+func (eb ErrorBuilder) assembleStackTrace() *stackTrace {
 	switch eb.mode {
 	case stackTraceCollect:
 		return eb.collectOriginalStackTrace()
@@ -127,19 +126,19 @@ func (eb *ErrorBuilder) assembleStackTrace() *stackTrace {
 	}
 }
 
-func (eb *ErrorBuilder) collectOriginalStackTrace() *stackTrace {
+func (eb ErrorBuilder) collectOriginalStackTrace() *stackTrace {
 	return collectStackTrace()
 }
 
-func (eb *ErrorBuilder) borrowStackTraceFromCause() *stackTrace {
+func (eb ErrorBuilder) borrowStackTraceFromCause() *stackTrace {
 	originalStackTrace := eb.extractStackTraceFromCause(eb.cause)
 	if originalStackTrace != nil {
 		return originalStackTrace
 	}
 	return collectStackTrace()
 }
 
-func (eb *ErrorBuilder) combineStackTraceWithCause() *stackTrace {
+func (eb ErrorBuilder) combineStackTraceWithCause() *stackTrace {
 	currentStackTrace := collectStackTrace()
 
 	originalStackTrace := eb.extractStackTraceFromCause(eb.cause)
@@ -150,7 +149,7 @@ func (eb *ErrorBuilder) combineStackTraceWithCause() *stackTrace {
 	return currentStackTrace
 }
 
-func (eb *ErrorBuilder) extractStackTraceFromCause(cause error) *stackTrace {
+func (eb ErrorBuilder) extractStackTraceFromCause(cause error) *stackTrace {
 	if typedCause := Cast(cause); typedCause != nil {
 		return typedCause.stackTrace
 	}

error.go

@@ -10,13 +10,15 @@ import (
 // At the moment of creation, Error collects information based on context, creation modifiers and type it belongs to.
 // Error is mostly immutable, and distinct errors composition is achieved through wrap.
 type Error struct {
-	message     string
-	errorType   *Type
-	cause       error
-	underlying  []error
-	stackTrace  *stackTrace
-	transparent bool
-	properties  map[Property]interface{}
+	message    string
+	errorType  *Type
+	cause      error
+	stackTrace *stackTrace
+	// properties are used both for public properties inherited through "transparent" wrapping
+	// and for some optional per-instance information like "underlying errors"
+	properties    *propertyMap
+	transparent   bool
+	hasUnderlying bool
 }
 
 var _ fmt.Formatter = (*Error)(nil)
@@ -25,41 +27,36 @@ var _ fmt.Formatter = (*Error)(nil)
 // If an error already contained another value for the same property, it is overwritten.
 // It is a caller's responsibility to accumulate and update a property, if needed.
 // Dynamic properties is a brittle mechanism and should therefore be used with care and in a simple and robust manner.
+// Currently, properties are implemented as a linked list, therefore it is not safe to have many dozens of them. But couple of dozen is just ok.
 func (e *Error) WithProperty(key Property, value interface{}) *Error {
 	errorCopy := *e
-
-	if errorCopy.properties == nil {
-		errorCopy.properties = make(map[Property]interface{}, 1)
-	} else {
-		errorCopy.properties = make(map[Property]interface{}, len(e.properties) + 1)
-		for k, v := range e.properties {
-			errorCopy.properties[k] = v
-		}
-	}
-
-	errorCopy.properties[key] = value
+	errorCopy.properties = errorCopy.properties.with(key, value)
 	return &errorCopy
 }
 
 // WithUnderlyingErrors adds multiple additional related (hidden, suppressed) errors to be used exclusively in error output.
 // Note that these errors make no other effect whatsoever: their traits, types, properties etc. are lost on the observer.
 // Consider using errorx.DecorateMany instead.
 func (e *Error) WithUnderlyingErrors(errs ...error) *Error {
-	errorCopy := *e
-
-	newUnderying := make([]error, 0, len(e.underlying) + len(errs))
-	newUnderying = append(newUnderying, e.underlying...)
+	underlying := e.underlying()
+	newUnderlying := underlying
 
 	for _, err := range errs {
 		if err == nil {
 			continue
 		}
 
-		newUnderying = append(newUnderying, err)
+		newUnderlying = append(newUnderlying, err)
 	}
 
-	errorCopy.underlying = newUnderying
-	return &errorCopy
+	if len(newUnderlying) == len(underlying) {
+		return e
+	}
+
+	l := len(newUnderlying) // note: l > 0, because non-increased 0 length is handled above
+	errorCopy := e.WithProperty(propertyUnderlying, newUnderlying[:l:l])
+	errorCopy.hasUnderlying = true
+	return errorCopy
 }
 
 // Property extracts a dynamic property value from an error.
@@ -69,7 +66,7 @@ func (e *Error) WithUnderlyingErrors(errs ...error) *Error {
 func (e *Error) Property(key Property) (interface{}, bool) {
 	cause := e
 	for cause != nil {
-		value, ok := cause.properties[key]
+		value, ok := cause.properties.get(key)
 		if ok {
 			return value, true
 		}
@@ -195,18 +192,29 @@ func (e *Error) messageWithUnderlyingInfo() string {
 }
 
 func (e *Error) underlyingInfo() string {
-	if len(e.underlying) == 0 {
+	if !e.hasUnderlying {
 		return ""
 	}
 
-	infos := make([]string, 0, len(e.underlying))
-	for _, err := range e.underlying {
+	underlying := e.underlying()
+	infos := make([]string, 0, len(underlying))
+	for _, err := range underlying {
 		infos = append(infos, err.Error())
 	}
 
 	return fmt.Sprintf("(hidden: %s)", joinStringsIfNonEmpty(", ", infos...))
 }
 
+func (e *Error) underlying() []error {
+	if !e.hasUnderlying {
+		return nil
+	}
+	// Note: properties are used as storage for optional "underlying errors".
+	// Chain of cause should not be traversed here.
+	u, _ := e.properties.get(propertyUnderlying)
+	return u.([]error)
+}
+
 func (e *Error) messageText() string {
 	if e.Cause() == nil {
 		return e.message

error_test.go

@@ -101,9 +101,9 @@ func TestImmutableError(t *testing.T) {
 		require.True(t, err.errorType.IsOfType(err2.errorType))
 		require.Equal(t, err.message, err2.message)
 
-		require.Len(t, err.underlying, 0)
-		require.Len(t, err1.underlying, 1)
-		require.Len(t, err2.underlying, 2)
+		require.Len(t, err.underlying(), 0)
+		require.Len(t, err1.underlying(), 1)
+		require.Len(t, err2.underlying(), 2)
 	})
 }
 

id.go

@@ -1,11 +1,13 @@
 package errorx
 
-import "sync/atomic"
+import (
+	"sync/atomic"
+)
 
-var internalID int64
+var internalID uint64
 
 // nextInternalID creates next unique id for errorx entities.
 // All equality comparison should take id into account, lest there be some false positive matches.
-func nextInternalID() int64 {
-	return atomic.AddInt64(&internalID, 1)
+func nextInternalID() uint64 {
+	return atomic.AddUint64(&internalID, 1)
 }

namespace.go

@@ -11,16 +11,15 @@ import "fmt"
 //
 type Namespace struct {
 	parent    *Namespace
-	id        int64
+	id        uint64
 	name      string
 	traits    []Trait
 	modifiers modifiers
 }
 
 // NamespaceKey is a comparable descriptor of a Namespace.
 type NamespaceKey struct {
-	id   int64
-	name string
+	id uint64
 }
 
 // NewNamespace defines a namespace with a name and, optionally, a number of inheritable traits.
@@ -51,8 +50,7 @@ func (n Namespace) NewType(typeName string, traits ...Trait) *Type {
 // Key returns a comparison key for namespace.
 func (n Namespace) Key() NamespaceKey {
 	return NamespaceKey{
-		id:   n.id,
-		name: n.name,
+		id: n.id,
 	}
 }
 

property.go

@@ -8,7 +8,10 @@ import (
 // Property value belongs to an error instance only, never inherited from a type.
 // Property visibility is hindered by Wrap, preserved by Decorate.
 type Property struct {
-	id    int64
+	*property // Property is compared by this pointer.
+}
+
+type property struct {
 	label string
 }
 
@@ -65,13 +68,39 @@ func ExtractProperty(err error, key Property) (interface{}, bool) {
 }
 
 var (
-	propertyContext = RegisterProperty("ctx")
-	propertyPayload = RegisterProperty("payload")
+	propertyContext    = RegisterProperty("ctx")
+	propertyPayload    = RegisterProperty("payload")
+	propertyUnderlying = RegisterProperty("underlying")
 )
 
 func newProperty(label string) Property {
-	return Property{
-		id:    nextInternalID(),
-		label: label,
+	p := Property{
+		&property{
+			label: label,
+		},
+	}
+	return p
+}
+
+// propertyMap represents map of properties.
+// Compared to builtin type, it uses less allocations and reallocations on copy.
+// It is implemented as a simple linked list.
+type propertyMap struct {
+	p     Property
+	value interface{}
+	next  *propertyMap
+}
+
+func (pm *propertyMap) with(p Property, value interface{}) *propertyMap {
+	return &propertyMap{p: p, value: value, next: pm}
+}
+
+func (pm *propertyMap) get(p Property) (value interface{}, ok bool) {
+	for pm != nil {
+		if pm.p == p {
+			return pm.value, true
+		}
+		pm = pm.next
 	}
+	return nil, false
 }