feat: add ErrorHandlingMutator for error return value mutations

Implement ErrorHandlingMutator that replaces error return values (err)
with nil. Targets return statements containing an identifier named "err".

Closes #8

Author: sivchari

internal/mutation/engine_test.go

@@ -74,8 +74,8 @@ func TestNew(t *testing.T) {
 		t.Fatal("Expected engine to be non-nil")
 	}
 
-	if len(engine.mutators) != 6 {
-		t.Errorf("Expected 6 mutators, got %d", len(engine.mutators))
+	if len(engine.mutators) != 7 {
+		t.Errorf("Expected 7 mutators, got %d", len(engine.mutators))
 	}
 
 	// Check mutator types
@@ -85,7 +85,7 @@ func TestNew(t *testing.T) {
 		mutatorNames[mutator.Name()] = true
 	}
 
-	expectedMutators := []string{"arithmetic", "branch", "conditional", "logical", "return"}
+	expectedMutators := []string{"arithmetic", "branch", "conditional", "error_handling", "logical", "return"}
 
 	for _, expected := range expectedMutators {
 		if !mutatorNames[expected] {
@@ -101,8 +101,8 @@ func TestNew_CustomMutators(t *testing.T) {
 		t.Fatalf("Failed to create mutation engine: %v", err)
 	}
 
-	if len(engine.mutators) != 6 {
-		t.Errorf("Expected 6 mutators (all types enabled by default), got %d", len(engine.mutators))
+	if len(engine.mutators) != 7 {
+		t.Errorf("Expected 7 mutators (all types enabled by default), got %d", len(engine.mutators))
 	}
 }
 
@@ -114,8 +114,8 @@ func TestNew_InvalidMutator(t *testing.T) {
 	}
 
 	// Should ignore invalid mutator
-	if len(engine.mutators) != 6 {
-		t.Errorf("Expected 6 mutators (all types enabled by default), got %d", len(engine.mutators))
+	if len(engine.mutators) != 7 {
+		t.Errorf("Expected 7 mutators (all types enabled by default), got %d", len(engine.mutators))
 	}
 }
 
@@ -737,6 +737,8 @@ func getExpectedMutatorName(mutantType string) string {
 		return "branch"
 	case strings.HasPrefix(mutantType, "conditional_"):
 		return "conditional"
+	case strings.HasPrefix(mutantType, "error_"):
+		return "error_handling"
 	case strings.HasPrefix(mutantType, "logical_"):
 		return "logical"
 	case strings.HasPrefix(mutantType, "bitwise_"):

internal/mutation/errorhandling.go

@@ -0,0 +1,103 @@
+package mutation
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+)
+
+const (
+	errorHandlingMutatorName = "error_handling"
+	errorNilifyType          = "error_nilify"
+)
+
+// ErrorHandlingMutator mutates error return values by replacing err with nil.
+type ErrorHandlingMutator struct {
+}
+
+// Name returns the name of the mutator.
+func (m *ErrorHandlingMutator) Name() string {
+	return errorHandlingMutatorName
+}
+
+// CanMutate returns true if the node is a return statement containing an err identifier.
+func (m *ErrorHandlingMutator) CanMutate(node ast.Node) bool {
+	stmt, ok := node.(*ast.ReturnStmt)
+	if !ok {
+		return false
+	}
+
+	for _, expr := range stmt.Results {
+		if isErrIdent(expr) {
+			return true
+		}
+	}
+
+	return false
+}
+
+// Mutate generates mutants for the given node.
+func (m *ErrorHandlingMutator) Mutate(node ast.Node, fset *token.FileSet) []Mutant {
+	stmt, ok := node.(*ast.ReturnStmt)
+	if !ok {
+		return nil
+	}
+
+	var mutants []Mutant
+
+	for _, expr := range stmt.Results {
+		ident, ok := expr.(*ast.Ident)
+		if !ok || ident.Name != "err" {
+			continue
+		}
+
+		pos := fset.Position(ident.Pos())
+
+		mutants = append(mutants, Mutant{
+			Line:        pos.Line,
+			Column:      pos.Column,
+			Type:        errorNilifyType,
+			Original:    ident.Name,
+			Mutated:     "nil",
+			Description: fmt.Sprintf("Replace return %s with return nil", ident.Name),
+		})
+	}
+
+	return mutants
+}
+
+// Apply applies the mutation to the given AST node.
+func (m *ErrorHandlingMutator) Apply(node ast.Node, mutant Mutant) bool {
+	stmt, ok := node.(*ast.ReturnStmt)
+	if !ok {
+		return false
+	}
+
+	if mutant.Type != errorNilifyType {
+		return false
+	}
+
+	for i, expr := range stmt.Results {
+		ident, ok := expr.(*ast.Ident)
+		if !ok {
+			continue
+		}
+
+		if ident.Name != mutant.Original {
+			continue
+		}
+
+		stmt.Results[i] = &ast.Ident{Name: "nil"}
+
+		return true
+	}
+
+	return false
+}
+
+// isErrIdent reports whether expr is an identifier named "err".
+func isErrIdent(expr ast.Expr) bool {
+	ident, ok := expr.(*ast.Ident)
+
+	return ok && ident.Name == "err"
+}

internal/mutation/errorhandling_test.go

@@ -0,0 +1,227 @@
+package mutation
+
+import (
+	"go/ast"
+	"go/parser"
+	"go/token"
+	"testing"
+)
+
+func TestErrorHandlingMutator_Name(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+
+	if mutator.Name() != errorHandlingMutatorName {
+		t.Errorf("Name() = %q, want %q", mutator.Name(), errorHandlingMutatorName)
+	}
+}
+
+func TestErrorHandlingMutator_CanMutate(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+
+	tests := []struct {
+		name     string
+		src      string
+		expected bool
+	}{
+		{
+			name:     "return with err and other value",
+			src:      "package main\nfunc f() (int, error) { err := error(nil); return 0, err }",
+			expected: true,
+		},
+		{
+			name:     "return nil only",
+			src:      "package main\nfunc f() error { return nil }",
+			expected: false,
+		},
+		{
+			name:     "return err alone",
+			src:      "package main\nfunc f() error { err := error(nil); return err }",
+			expected: true,
+		},
+		{
+			name:     "return x and y without err",
+			src:      "package main\nfunc f() (int, int) { x, y := 1, 2; return x, y }",
+			expected: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			fset := token.NewFileSet()
+
+			file, err := parser.ParseFile(fset, "test.go", tt.src, 0)
+			if err != nil {
+				t.Fatalf("Failed to parse file: %v", err)
+			}
+
+			var retStmt ast.Node
+
+			ast.Inspect(file, func(n ast.Node) bool {
+				if rs, ok := n.(*ast.ReturnStmt); ok {
+					retStmt = rs
+
+					return false
+				}
+
+				return true
+			})
+
+			if retStmt == nil {
+				t.Fatalf("ReturnStmt not found in: %s", tt.src)
+			}
+
+			if got := mutator.CanMutate(retStmt); got != tt.expected {
+				t.Errorf("CanMutate() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestErrorHandlingMutator_CanMutate_NonReturnNode(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+
+	expr, err := parser.ParseExpr("a && b")
+	if err != nil {
+		t.Fatalf("Failed to parse expression: %v", err)
+	}
+
+	if mutator.CanMutate(expr) {
+		t.Error("CanMutate() = true, want false for non-ReturnStmt node")
+	}
+}
+
+func TestErrorHandlingMutator_Mutate(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+	fset := token.NewFileSet()
+
+	src := "package main\nfunc f() (int, error) { err := error(nil); return 0, err }"
+
+	file, err := parser.ParseFile(fset, "test.go", src, 0)
+	if err != nil {
+		t.Fatalf("Failed to parse file: %v", err)
+	}
+
+	var retStmt ast.Node
+
+	ast.Inspect(file, func(n ast.Node) bool {
+		if rs, ok := n.(*ast.ReturnStmt); ok {
+			retStmt = rs
+
+			return false
+		}
+
+		return true
+	})
+
+	if retStmt == nil {
+		t.Fatal("ReturnStmt not found")
+	}
+
+	mutants := mutator.Mutate(retStmt, fset)
+
+	if len(mutants) != 1 {
+		t.Fatalf("Expected 1 mutant, got %d", len(mutants))
+	}
+
+	m := mutants[0]
+
+	if m.Type != errorNilifyType {
+		t.Errorf("Type = %q, want %q", m.Type, errorNilifyType)
+	}
+
+	if m.Original != "err" {
+		t.Errorf("Original = %q, want %q", m.Original, "err")
+	}
+
+	if m.Mutated != "nil" {
+		t.Errorf("Mutated = %q, want %q", m.Mutated, "nil")
+	}
+
+	if m.Line <= 0 {
+		t.Errorf("Expected positive line number, got %d", m.Line)
+	}
+
+	if m.Description == "" {
+		t.Error("Expected non-empty description")
+	}
+}
+
+func TestErrorHandlingMutator_Apply(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+	fset := token.NewFileSet()
+
+	src := "package main\nfunc f() (int, error) { err := error(nil); return 0, err }"
+
+	file, err := parser.ParseFile(fset, "test.go", src, 0)
+	if err != nil {
+		t.Fatalf("Failed to parse file: %v", err)
+	}
+
+	var retStmt *ast.ReturnStmt
+
+	ast.Inspect(file, func(n ast.Node) bool {
+		if rs, ok := n.(*ast.ReturnStmt); ok {
+			retStmt = rs
+
+			return false
+		}
+
+		return true
+	})
+
+	if retStmt == nil {
+		t.Fatal("ReturnStmt not found")
+	}
+
+	mutant := Mutant{
+		Type:     errorNilifyType,
+		Original: "err",
+		Mutated:  "nil",
+	}
+
+	if !mutator.Apply(retStmt, mutant) {
+		t.Error("Apply() = false, want true")
+	}
+
+	ident, ok := retStmt.Results[1].(*ast.Ident)
+	if !ok {
+		t.Fatal("Expected *ast.Ident in return results[1] after Apply")
+	}
+
+	if ident.Name != "nil" {
+		t.Errorf("ident.Name = %q, want %q", ident.Name, "nil")
+	}
+}
+
+func TestErrorHandlingMutator_Apply_NonReturnStmt(t *testing.T) {
+	t.Parallel()
+
+	mutator := &ErrorHandlingMutator{}
+
+	expr, err := parser.ParseExpr("a && b")
+	if err != nil {
+		t.Fatalf("Failed to parse expression: %v", err)
+	}
+
+	mutant := Mutant{
+		Type:     errorNilifyType,
+		Original: "err",
+		Mutated:  "nil",
+	}
+
+	if mutator.Apply(expr, mutant) {
+		t.Error("Apply() = true, want false for non-ReturnStmt node")
+	}
+}