| // Copyright 2026 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 ptrtoerror defines an analyzer that detects inconsistent |
| // conversions of concrete error types to the error interface. |
| // |
| // # Analyzer ptrtoerror |
| // |
| // ptrtoerror: detect inconsistent conversions of concrete types to error |
| // |
| // The ptrtoerror analyzer detects when a concrete type E is converted |
| // to the error interface inconsistently, both as a value of type E |
| // and as a pointer of type *E. Such inconsistency defeats attempts by |
| // client code to test for specific error types using type assertions |
| // or library functions such as [errors.As] and [errors.Is]. |
| // |
| // The analyzer also detects when both E and *E implement error but |
| // neither of those types is converted to error within the defining |
| // package, leaving the intended error form (E or *E) ambiguous. This |
| // diagnostic offers two alternative fixes to add declarations that |
| // make the intent explicit. |
| // |
| // # Examples |
| // |
| // In this example, both MyError and *MyError implement error, and |
| // both types are used as errors: |
| // |
| // type MyError struct{ Msg string } // error: type MyError is converted to error both as a value and as a pointer |
| // |
| // func (MyError) Error() string { return "error" } |
| // |
| // func foo() error { return MyError{"foo"} } // "conversion of MyError (value) to error" here |
| // func bar() error { return &MyError{"bar"} } // "conversion of *MyError (pointer) to error" here |
| // |
| // To fix the issue, adopt a single conversion form consistently: |
| // |
| // func foo() error { return &MyError{"foo"} } // pointer conversion (*E) |
| // func bar() error { return &MyError{"bar"} } // pointer conversion (*E) |
| // |
| // In this example, again both CustomError and *CustomError implement |
| // error, but neither type is used as an error: |
| // |
| // type CustomError struct{ error } // "both CustomError and *CustomError implement the error interface, making the intent ambiguous" |
| // |
| // func (e *CustomError) Unwrap() error ( return e.error } |
| // |
| // To resolve the ambiguity, apply one of the two suggested fixes to |
| // add a declaration that makes the intent explicit: |
| // |
| // var _ error = *new(CustomError) // (declares that CustomError is the intended form) |
| // |
| // or: |
| // |
| // var _ error = (*CustomError)(nil) // (declares that *CustomError is the intended form) |
| // |
| // In this example, the presence of the Unwrap method is a clue that |
| // *CustomError is the preferred form. An alternative fix would be to |
| // declare an explicit Error method so that CustomError is no longer |
| // assignable to error: |
| // |
| // func (err *CustomError) Error() string ( return err.error.Error() } |
| package ptrtoerror |
