feat(gotask): migrate gotask checker to unified registry pattern

- Add ArgIsDeriverCall pattern for DoAsync ctx argument checking
- Register DoAll/DoAllSettled/DoRace with ShouldCallDeriver (trace through NewTask)
- Register DoAllFns/DoAllFnsSettled/DoRaceFns as variadic APIs
- Register Task.DoAsync/CancelableTask.DoAsync with ArgIsDeriverCall
- Add Variadic flag to registry.API for variable callback arguments
- Add MatchesFunc() to deriver.Matcher for direct function matching
- Enhance ShouldCallDeriver with NewTask tracing and slice detection
- Add variadic expansion detection (tasks...) with "variadic argument" message
- Add ordinal formatting (2nd, 3rd) for argument position messages
- Fix report position for method chains using selector position
- Remove legacy checkers: errgroup, waitgroup, goroutine, goroutinederive, gotask
- Add defer-only test cases for goroutinederive

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mpyw

analyzer.go

@@ -13,7 +13,6 @@ import (
 	"golang.org/x/tools/go/ast/inspector"
 
 	"github.com/mpyw/goroutinectx/internal/checker"
-	"github.com/mpyw/goroutinectx/internal/checkers/gotask"
 	"github.com/mpyw/goroutinectx/internal/checkers/spawner"
 	"github.com/mpyw/goroutinectx/internal/checkers/spawnerlabel"
 	"github.com/mpyw/goroutinectx/internal/context"
@@ -156,6 +155,14 @@ func runASTChecks(
 	// Register errgroup/waitgroup/conc APIs with ClosureCapturesCtx pattern
 	checker.RegisterDefaultAPIs(reg, enableErrgroup, enableWaitgroup)
 
+	// Register gotask APIs with ShouldCallDeriver and ArgIsDeriverCall patterns
+	if goroutineDeriver != "" && enableGotask {
+		matcher := deriver.NewMatcher(goroutineDeriver)
+		deriverPattern := &patterns.ShouldCallDeriver{Matcher: matcher}
+		doAsyncPattern := &patterns.ArgIsDeriverCall{Matcher: matcher}
+		checker.RegisterGotaskAPIs(reg, deriverPattern, doAsyncPattern)
+	}
+
 	// Build GoStmt patterns
 	var goPatterns []patterns.GoStmtPattern
 
@@ -173,6 +180,8 @@ func runASTChecks(
 		"GoStmtCapturesCtx":  ignore.Goroutine,
 		"GoStmtCallsDeriver": ignore.GoroutineDerive,
 		"ClosureCapturesCtx": ignore.Errgroup, // errgroup/waitgroup use this
+		"ShouldCallDeriver":  ignore.Gotask,   // gotask uses this
+		"ArgIsDeriverCall":   ignore.Gotask,   // gotask DoAsync uses this
 	}
 
 	// Create and run unified checker
@@ -187,7 +196,7 @@ func runASTChecks(
 	)
 	unifiedChecker.Run(pass, insp)
 
-	// Run remaining checkers that aren't migrated yet (spawner, gotask)
+	// Run remaining checkers that aren't migrated yet (spawner only)
 	runLegacyCheckers(pass, insp, ignoreMaps, carriers, spawners, skipFiles)
 }
 
@@ -200,10 +209,8 @@ func runLegacyCheckers(
 	spawners *spawnerdir.Map,
 	skipFiles map[string]bool,
 ) {
-	// Only spawner and gotask need the legacy path
-	spawnerEnabled := enableSpawner && spawners.Len() > 0
-	gotaskEnabled := goroutineDeriver != "" && enableGotask
-	if !spawnerEnabled && !gotaskEnabled {
+	// Only spawner needs the legacy path
+	if !enableSpawner || spawners.Len() == 0 {
 		return
 	}
 
@@ -241,14 +248,7 @@ func runLegacyCheckers(
 		}
 
 		if call, ok := n.(*ast.CallExpr); ok {
-			// Spawner checker
-			if enableSpawner && spawners.Len() > 0 {
-				spawner.New(spawners).CheckCall(cctx, call)
-			}
-			// Gotask checker
-			if goroutineDeriver != "" && enableGotask {
-				gotask.New(goroutineDeriver).CheckCall(cctx, call)
-			}
+			spawner.New(spawners).CheckCall(cctx, call)
 		}
 
 		return true

internal/checker/apis.go

@@ -113,62 +113,80 @@ func RegisterDefaultAPIs(reg *registry.Registry, enableErrgroup, enableWaitgroup
 }
 
 // RegisterGotaskAPIs registers gotask APIs with deriver pattern.
-func RegisterGotaskAPIs(reg *registry.Registry, deriverPattern *patterns.ShouldCallDeriver) {
-	// gotask Do* functions - task callbacks should call deriver
+func RegisterGotaskAPIs(reg *registry.Registry, deriverPattern *patterns.ShouldCallDeriver, doAsyncPattern *patterns.ArgIsDeriverCall) {
+	// DoAll, DoAllSettled, DoRace - variadic Task arguments
+	// Each Task arg is traced through NewTask to check the callback body
 	reg.Register(deriverPattern,
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "",
-			Name:           "Do",
+			Name:           "DoAll",
 			Kind:           registry.KindFunc,
-			CallbackArgIdx: 1, // tasks start at index 1
+			CallbackArgIdx: 1, // Tasks start at index 1 (after ctx)
+			Variadic:       true,
 		},
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "",
-			Name:           "DoAll",
+			Name:           "DoAllSettled",
 			Kind:           registry.KindFunc,
 			CallbackArgIdx: 1,
+			Variadic:       true,
 		},
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "",
-			Name:           "DoAllSettled",
+			Name:           "DoRace",
 			Kind:           registry.KindFunc,
 			CallbackArgIdx: 1,
+			Variadic:       true,
 		},
-		// DoAllFns, DoAllFnsSettled - callback receives ctx
+	)
+
+	// DoAllFns, DoAllFnsSettled, DoRaceFns - variadic functions
+	// Each fn argument should call deriver in its body
+	reg.Register(deriverPattern,
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "",
 			Name:           "DoAllFns",
 			Kind:           registry.KindFunc,
-			CallbackArgIdx: 1,
+			CallbackArgIdx: 1, // fns start at index 1
+			Variadic:       true,
 		},
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "",
 			Name:           "DoAllFnsSettled",
 			Kind:           registry.KindFunc,
 			CallbackArgIdx: 1,
+			Variadic:       true,
+		},
+		registry.API{
+			Pkg:            "github.com/siketyan/gotask",
+			Type:           "",
+			Name:           "DoRaceFns",
+			Kind:           registry.KindFunc,
+			CallbackArgIdx: 1,
+			Variadic:       true,
 		},
 	)
 
-	// Task/CancelableTask.DoAsync - ctx should be derived
-	reg.Register(deriverPattern,
+	// Task.DoAsync, CancelableTask.DoAsync - ctx arg should BE a deriver call
+	reg.Register(doAsyncPattern,
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "Task",
 			Name:           "DoAsync",
 			Kind:           registry.KindMethod,
-			CallbackArgIdx: -1, // ctx is in call args, not callback
+			CallbackArgIdx: 0, // ctx is first argument
 		},
 		registry.API{
 			Pkg:            "github.com/siketyan/gotask",
 			Type:           "CancelableTask",
 			Name:           "DoAsync",
 			Kind:           registry.KindMethod,
-			CallbackArgIdx: -1,
+			CallbackArgIdx: 0,
 		},
 	)
 }

internal/checker/checker.go

@@ -2,6 +2,7 @@
 package checker
 
 import (
+	"fmt"
 	"go/ast"
 	"go/token"
 
@@ -137,10 +138,86 @@ func (c *Checker) checkCallExpr(cctx *patterns.CheckContext, call *ast.CallExpr,
 		return
 	}
 
+	// Handle variadic APIs (e.g., DoAllFns(ctx, fn1, fn2, ...))
+	if entry.API.Variadic {
+		c.checkVariadicCallExpr(cctx, call, entry, scope)
+		return
+	}
+
 	if !entry.Pattern.Check(cctx, call, callbackArg) {
 		msg := entry.Pattern.Message(entry.API.FullName(), scope.ctxName())
-		cctx.Pass.Reportf(call.Pos(), "%s", msg)
+		// Report at method selector position for chained calls
+		reportPos := getCallReportPos(call)
+		cctx.Pass.Reportf(reportPos, "%s", msg)
+	}
+}
+
+// getCallReportPos returns the best position to report for a call expression.
+// For method calls, this is the selector (method name) position.
+// For other calls, this is the call position.
+func getCallReportPos(call *ast.CallExpr) token.Pos {
+	if sel, ok := call.Fun.(*ast.SelectorExpr); ok {
+		return sel.Sel.Pos()
+	}
+	return call.Pos()
+}
+
+// checkVariadicCallExpr checks each callback argument in a variadic API call.
+func (c *Checker) checkVariadicCallExpr(
+	cctx *patterns.CheckContext,
+	call *ast.CallExpr,
+	entry *registry.Entry,
+	scope *contextScope,
+) {
+	startIdx := entry.API.CallbackArgIdx
+	if startIdx < 0 || startIdx >= len(call.Args) {
+		return
+	}
+
+	// Check if this is a variadic expansion (e.g., DoAllFns(ctx, slice...))
+	isVariadicExpansion := call.Ellipsis.IsValid()
+
+	for i := startIdx; i < len(call.Args); i++ {
+		arg := call.Args[i]
+		if !entry.Pattern.Check(cctx, call, arg) {
+			var msg string
+			if isVariadicExpansion {
+				// For variadic expansion, we can't determine the position
+				msg = entry.API.FullName() + "() variadic argument should call goroutine deriver"
+			} else {
+				// Create message with argument position (1-based for human readability)
+				argNum := i + 1
+				msg = formatVariadicMessage(entry.API.FullName(), argNum)
+			}
+			// Report at the call position (where the // want comment is)
+			cctx.Pass.Reportf(call.Pos(), "%s", msg)
+		}
+	}
+}
+
+// formatVariadicMessage formats a diagnostic message with argument position.
+func formatVariadicMessage(apiName string, argNum int) string {
+	return apiName + "() " + ordinal(argNum) + " argument should call goroutine deriver"
+}
+
+// ordinal returns the ordinal form of a number (1st, 2nd, 3rd, 4th, etc.)
+func ordinal(n int) string {
+	suffix := "th"
+	switch n % 10 {
+	case 1:
+		if n%100 != 11 {
+			suffix = "st"
+		}
+	case 2:
+		if n%100 != 12 {
+			suffix = "nd"
+		}
+	case 3:
+		if n%100 != 13 {
+			suffix = "rd"
+		}
 	}
+	return fmt.Sprintf("%d%s", n, suffix)
 }
 
 // shouldIgnore checks if the position should be ignored for the given checker.