Refactor error handling in marker scope validation by introducing custom error types for invalid schema types, type constraints, and element constraints. Update validation functions to return these new error types for improved clarity and maintainability.

Signed-off-by: nayuta-ai <nayuta723@gmail.com>

Author: nayuta723

pkg/analysis/markerscope/analyzer.go

@@ -36,7 +36,6 @@ const (
 	name = "markerscope"
 )
 
-// TODO: SuggestFix.
 func init() {
 	// Register all markers we want to validate scope for
 	defaults := DefaultMarkerRules()
@@ -285,7 +284,7 @@ func (a *analyzer) validateFieldTypeConstraint(pass *analysis.Pass, field *ast.F
 	if rule.StrictTypeConstraint && rule.Scope == AnyScope {
 		namedType, ok := tv.Type.(*types.Named)
 		if ok {
-			return fmt.Errorf("%w of %s instead of the field", errMarkerShouldBeOnTypeDefinition, namedType.Obj().Name())
+			return &MarkerShouldBeOnTypeDefinitionError{TypeName: namedType.Obj().Name()}
 		}
 	}
 
@@ -317,7 +316,7 @@ func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint, allowDanger
 	if !allowDangerousTypes && schemaType == SchemaTypeNumber {
 		// Get the underlying type for better error messages
 		underlyingType := getUnderlyingType(t)
-		return fmt.Errorf("type %s is dangerous and not allowed (set allowDangerousTypes to true to permit)", underlyingType.String())
+		return &DengerousTypeError{Type: underlyingType.String()}
 	}
 
 	if tc == nil {
@@ -327,7 +326,7 @@ func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint, allowDanger
 	// Check if the schema type is allowed
 	if len(tc.AllowedSchemaTypes) > 0 {
 		if !slices.Contains(tc.AllowedSchemaTypes, schemaType) {
-			return fmt.Errorf("type %s is not allowed (expected one of: %v)", schemaType, tc.AllowedSchemaTypes)
+			return &TypeNotAllowedError{Type: schemaType, AllowedTypes: tc.AllowedSchemaTypes}
 		}
 	}
 
@@ -336,7 +335,7 @@ func validateTypeAgainstConstraint(t types.Type, tc *TypeConstraint, allowDanger
 		elemType := getElementType(t)
 		if elemType != nil {
 			if err := validateTypeAgainstConstraint(elemType, tc.ElementConstraint, allowDangerousTypes); err != nil {
-				return fmt.Errorf("array element: %w", err)
+				return &InvalidElementConstraintError{Err: err}
 			}
 		}
 	}

pkg/analysis/markerscope/errors.go

@@ -15,11 +15,67 @@ limitations under the License.
 */
 package markerscope
 
-import "errors"
+import (
+	"errors"
+	"fmt"
+)
 
 var (
-	errScopeNonZero                   = errors.New("scope must be non-zero")
-	errInvalidScopeBits               = errors.New("invalid scope bits")
-	errInvalidSchemaType              = errors.New("invalid schema type")
-	errMarkerShouldBeOnTypeDefinition = errors.New("marker should be declared on the type definition")
+	errScopeNonZero     = errors.New("scope must be non-zero")
+	errInvalidScopeBits = errors.New("invalid scope bits")
 )
+
+// InvalidSchemaTypeError represents an error when a schema type is invalid.
+type InvalidSchemaTypeError struct {
+	SchemaType string
+}
+
+func (e *InvalidSchemaTypeError) Error() string {
+	return fmt.Sprintf("invalid schema type: %q", e.SchemaType)
+}
+
+// InvalidTypeConstraintError represents an error when a type constraint is invalid.
+type InvalidTypeConstraintError struct {
+	Err error
+}
+
+func (e *InvalidTypeConstraintError) Error() string {
+	return fmt.Sprintf("invalid type constraint: %v", e.Err)
+}
+
+// InvalidElementConstraintError represents an error when an element constraint is invalid.
+type InvalidElementConstraintError struct {
+	Err error
+}
+
+func (e *InvalidElementConstraintError) Error() string {
+	return fmt.Sprintf("array element: %v", e.Err)
+}
+
+// MarkerShouldBeOnTypeDefinitionError represents an error when a marker should be declared on the type definition.
+type MarkerShouldBeOnTypeDefinitionError struct {
+	TypeName string
+}
+
+func (e *MarkerShouldBeOnTypeDefinitionError) Error() string {
+	return fmt.Sprintf("marker should be declared on the type definition of %s instead of the field", e.TypeName)
+}
+
+// DengerousTypeError represents an error when a dangerous type is used.
+type DengerousTypeError struct {
+	Type string
+}
+
+func (e *DengerousTypeError) Error() string {
+	return fmt.Sprintf("type %s is dangerous and not allowed (set allowDangerousTypes to true to permit)", e.Type)
+}
+
+// TypeNotAllowedError represents an error when a type is not allowed.
+type TypeNotAllowedError struct {
+	Type         SchemaType
+	AllowedTypes []SchemaType
+}
+
+func (e *TypeNotAllowedError) Error() string {
+	return fmt.Sprintf("type %s is not allowed (expected one of: %v)", e.Type, e.AllowedTypes)
+}

pkg/analysis/markerscope/initializer.go

@@ -82,7 +82,9 @@ func validateMarkerRule(rule MarkerScopeRule) error {
 	// Validate type constraint if present
 	if rule.TypeConstraint != nil {
 		if err := validateTypeConstraint(rule.TypeConstraint); err != nil {
-			return fmt.Errorf("invalid type constraint: %w", err)
+			return &InvalidTypeConstraintError{
+				Err: err,
+			}
 		}
 	}
 
@@ -97,7 +99,7 @@ func validateTypeConstraint(tc *TypeConstraint) error {
 	// Validate schema types if specified
 	for _, st := range tc.AllowedSchemaTypes {
 		if !isValidSchemaType(st) {
-			return fmt.Errorf("%w: %q", errInvalidSchemaType, st)
+			return &InvalidSchemaTypeError{SchemaType: string(st)}
 		}
 	}