refactor(patterns): consolidate duplicate utilities across packages

- Remove duplicate isContextType implementations (patterns, ssa)
  → Use single typeutil.IsContextType everywhere
- Unify funcTypeHasContextParam for FuncLit and FuncDecl
  → Base function accepts *ast.FuncType
- Consolidate findFuncLitAssignment variants
  → Single function with optional beforePos parameter
- Unify factory returns context check logic
  → blockReturnsContextUsingFunc as common base

Result: -95 lines of duplicated code

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

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

Author: mpyw

internal/patterns/callback_receives_ctx.go

@@ -3,6 +3,8 @@ package patterns
 import (
 	"fmt"
 	"go/ast"
+
+	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
 
 // CallbackReceivesCtx checks APIs where the callback receives context as its first parameter.
@@ -39,23 +41,23 @@ func (*CallbackReceivesCtx) contextArgUsesVar(cctx *CheckContext, ctxArg ast.Exp
 	// For simple identifier, check if it's a context type from scope
 	if ident, ok := ctxArg.(*ast.Ident); ok {
 		obj := cctx.Pass.TypesInfo.ObjectOf(ident)
-		if obj != nil && isContextType(obj.Type()) {
+		if obj != nil && typeutil.IsContextType(obj.Type()) {
 			return true
 		}
 	}
 
 	// For call expressions (e.g., context.WithCancel(ctx)), check the result type
 	if callExpr, ok := ctxArg.(*ast.CallExpr); ok {
 		typ := cctx.Pass.TypesInfo.TypeOf(callExpr)
-		if typ != nil && isContextType(typ) {
+		if typ != nil && typeutil.IsContextType(typ) {
 			return true
 		}
 	}
 
 	// For selector expressions (e.g., req.Context())
 	if sel, ok := ctxArg.(*ast.SelectorExpr); ok {
 		typ := cctx.Pass.TypesInfo.TypeOf(sel)
-		if typ != nil && isContextType(typ) {
+		if typ != nil && typeutil.IsContextType(typ) {
 			return true
 		}
 	}

internal/patterns/closure_captures_ctx.go

@@ -83,7 +83,7 @@ func closureCheckFromAST(cctx *CheckContext, callbackArg ast.Expr) bool {
 		if !ok {
 			return false // Can't trace
 		}
-		funcLit := findFuncLitAssignment(cctx, v)
+		funcLit := findFuncLitAssignment(cctx, v, token.NoPos)
 		if funcLit == nil {
 			return false // Can't trace (channel receive, type assertion, etc.)
 		}
@@ -337,7 +337,7 @@ func closureCheckFactoryCall(cctx *CheckContext, call *ast.CallExpr) bool {
 		if !ok {
 			return false
 		}
-		funcLit := findFuncLitAssignment(cctx, v)
+		funcLit := findFuncLitAssignment(cctx, v, token.NoPos)
 		if funcLit == nil {
 			return false
 		}

internal/patterns/gostmt.go

@@ -2,6 +2,7 @@ package patterns
 
 import (
 	"go/ast"
+	"go/token"
 	"go/types"
 
 	"github.com/mpyw/goroutinectx/internal/directives/deriver"
@@ -161,7 +162,7 @@ func goStmtCheckIdentFactory(cctx *CheckContext, ident *ast.Ident) bool {
 
 	// Handle local variable pointing to a func literal
 	if v, ok := obj.(*types.Var); ok {
-		funcLit := findFuncLitAssignment(cctx, v)
+		funcLit := findFuncLitAssignment(cctx, v, token.NoPos)
 		if funcLit == nil {
 			return true // Can't trace
 		}
@@ -210,63 +211,12 @@ func goStmtFindFuncDecl(cctx *CheckContext, fn *types.Func) *ast.FuncDecl {
 
 // goStmtFuncDeclHasContextParam checks if a function declaration has a context.Context parameter.
 func goStmtFuncDeclHasContextParam(cctx *CheckContext, decl *ast.FuncDecl) bool {
-	if decl.Type == nil || decl.Type.Params == nil {
-		return false
-	}
-	for _, field := range decl.Type.Params.List {
-		typ := cctx.Pass.TypesInfo.TypeOf(field.Type)
-		if typ == nil {
-			continue
-		}
-		if isContextType(typ) {
-			return true
-		}
-	}
-	return false
+	return funcTypeHasContextParam(cctx, decl.Type)
 }
 
 // goStmtFactoryDeclReturnsCtxFunc checks if a function declaration returns funcs that use context.
-// For nested factories, this recursively checks if any deeply nested function uses context.
 func goStmtFactoryDeclReturnsCtxFunc(cctx *CheckContext, decl *ast.FuncDecl) bool {
-	if decl.Body == nil {
-		return true // No body to check
-	}
-
-	usesContext := false
-	ast.Inspect(decl.Body, func(n ast.Node) bool {
-		if usesContext {
-			return false
-		}
-		// For nested func literals, check both direct usage and returned values
-		if fl, ok := n.(*ast.FuncLit); ok {
-			// Check if this nested func lit uses context directly
-			if funcLitUsesContext(cctx, fl) {
-				usesContext = true
-				return false
-			}
-			// Recursively check if it returns functions that use context
-			if factoryReturnsContextUsingFunc(cctx, fl) {
-				usesContext = true
-				return false
-			}
-			return false // Don't descend into nested func literals (we handle them recursively)
-		}
-
-		ret, ok := n.(*ast.ReturnStmt)
-		if !ok {
-			return true
-		}
-
-		for _, result := range ret.Results {
-			if returnedValueUsesContext(cctx, result) {
-				usesContext = true
-				return false
-			}
-		}
-		return true
-	})
-
-	return usesContext
+	return blockReturnsContextUsingFunc(cctx, decl.Body, nil)
 }
 
 // GoStmtCallsDeriver checks that a go statement's closure calls a deriver function.
@@ -352,7 +302,7 @@ func (p *GoStmtCallsDeriver) checkIdentDeriver(cctx *CheckContext, ident *ast.Id
 		return true // Not a variable
 	}
 
-	funcLit := findFuncLitAssignment(cctx, v)
+	funcLit := findFuncLitAssignment(cctx, v, token.NoPos)
 	if funcLit == nil {
 		return true // Can't trace
 	}
@@ -388,7 +338,7 @@ func (p *GoStmtCallsDeriver) checkHigherOrderDeriver(cctx *CheckContext, innerCa
 		if !ok {
 			return true // Not a variable (could be a function)
 		}
-		funcLit := findFuncLitAssignment(cctx, v)
+		funcLit := findFuncLitAssignment(cctx, v, token.NoPos)
 		if funcLit == nil {
 			return true // Can't trace
 		}
@@ -462,7 +412,7 @@ func (p *GoStmtCallsDeriver) returnedValueCallsDeriver(cctx *CheckContext, resul
 		return false
 	}
 
-	innerFuncLit := findFuncLitAssignment(cctx, v)
+	innerFuncLit := findFuncLitAssignment(cctx, v, token.NoPos)
 	if innerFuncLit == nil {
 		return false
 	}

internal/patterns/pattern.go

@@ -4,7 +4,6 @@ package patterns
 import (
 	"go/ast"
 	"go/token"
-	"go/types"
 
 	"golang.org/x/tools/go/analysis"
 
@@ -29,16 +28,6 @@ func (c *CheckContext) Report(pos token.Pos, msg string) {
 	c.Pass.Reportf(pos, "%s", msg)
 }
 
-// isContextType checks if a type is context.Context.
-func isContextType(t types.Type) bool {
-	named, ok := t.(*types.Named)
-	if !ok {
-		return false
-	}
-	obj := named.Obj()
-	return obj.Pkg() != nil && obj.Pkg().Path() == "context" && obj.Name() == "Context"
-}
-
 // Pattern defines the interface for context propagation patterns.
 type Pattern interface {
 	// Name returns a human-readable name for the pattern.

internal/patterns/should_call_deriver.go

@@ -64,7 +64,7 @@ func (p *ShouldCallDeriver) identCallsDeriver(cctx *CheckContext, ident *ast.Ide
 	}
 
 	// Try to find a FuncLit assignment
-	funcLit := deriverFindFuncLitAssignmentBefore(cctx, v, ident.Pos())
+	funcLit := findFuncLitAssignment(cctx, v, ident.Pos())
 	if funcLit != nil {
 		return p.Matcher.SatisfiesAnyGroup(cctx.Pass, funcLit.Body)
 	}
@@ -146,7 +146,7 @@ func (p *ShouldCallDeriver) factoryReturnCallsDeriver(cctx *CheckContext, call *
 		return false
 	}
 
-	funcLit := deriverFindFuncLitAssignmentBefore(cctx, v, call.Pos())
+	funcLit := findFuncLitAssignment(cctx, v, call.Pos())
 	if funcLit == nil {
 		return false
 	}
@@ -210,48 +210,6 @@ func (p *ShouldCallDeriver) Message(apiName string, _ string) string {
 	return apiName + "() callback should call goroutine deriver"
 }
 
-// deriverFindFuncLitAssignmentBefore finds the last FuncLit assigned to variable before pos.
-func deriverFindFuncLitAssignmentBefore(cctx *CheckContext, v *types.Var, beforePos token.Pos) *ast.FuncLit {
-	var result *ast.FuncLit
-	declPos := v.Pos()
-
-	for _, f := range cctx.Pass.Files {
-		if f.Pos() > declPos || declPos >= f.End() {
-			continue
-		}
-
-		ast.Inspect(f, func(n ast.Node) bool {
-			assign, ok := n.(*ast.AssignStmt)
-			if !ok {
-				return true
-			}
-			if beforePos != token.NoPos && assign.Pos() >= beforePos {
-				return true
-			}
-
-			for i, lhs := range assign.Lhs {
-				ident, ok := lhs.(*ast.Ident)
-				if !ok {
-					continue
-				}
-				if cctx.Pass.TypesInfo.ObjectOf(ident) != v {
-					continue
-				}
-				if i >= len(assign.Rhs) {
-					continue
-				}
-				if fl, ok := assign.Rhs[i].(*ast.FuncLit); ok {
-					result = fl
-				}
-			}
-			return true
-		})
-		break
-	}
-
-	return result
-}
-
 // deriverFindCallExprAssignmentBefore finds the last CallExpr assigned to variable before pos.
 func deriverFindCallExprAssignmentBefore(cctx *CheckContext, v *types.Var, beforePos token.Pos) *ast.CallExpr {
 	var result *ast.CallExpr

internal/patterns/util.go

@@ -2,30 +2,36 @@ package patterns
 
 import (
 	"go/ast"
+	"go/token"
 	"go/types"
 
 	"golang.org/x/tools/go/analysis"
 
 	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
 
-// funcLitHasContextParam checks if a function literal has a context.Context parameter.
-func funcLitHasContextParam(cctx *CheckContext, lit *ast.FuncLit) bool {
-	if lit.Type == nil || lit.Type.Params == nil {
+// funcTypeHasContextParam checks if a function type has a context.Context parameter.
+func funcTypeHasContextParam(cctx *CheckContext, fnType *ast.FuncType) bool {
+	if fnType == nil || fnType.Params == nil {
 		return false
 	}
-	for _, field := range lit.Type.Params.List {
+	for _, field := range fnType.Params.List {
 		typ := cctx.Pass.TypesInfo.TypeOf(field.Type)
 		if typ == nil {
 			continue
 		}
-		if isContextType(typ) {
+		if typeutil.IsContextType(typ) {
 			return true
 		}
 	}
 	return false
 }
 
+// funcLitHasContextParam checks if a function literal has a context.Context parameter.
+func funcLitHasContextParam(cctx *CheckContext, lit *ast.FuncLit) bool {
+	return funcTypeHasContextParam(cctx, lit.Type)
+}
+
 // funcLitUsesContext checks if a function literal references any context variable.
 // It does NOT descend into nested func literals - they have their own scope and
 // will be checked separately.
@@ -105,8 +111,9 @@ func argUsesContext(cctx *CheckContext, expr ast.Expr) bool {
 }
 
 // findFuncLitAssignment searches for the func literal assigned to the variable.
-// Returns the LAST assignment found (for cases where variables are reassigned).
-func findFuncLitAssignment(cctx *CheckContext, v *types.Var) *ast.FuncLit {
+// If beforePos is token.NoPos, returns the LAST assignment found.
+// If beforePos is set, returns the last assignment BEFORE that position.
+func findFuncLitAssignment(cctx *CheckContext, v *types.Var, beforePos token.Pos) *ast.FuncLit {
 	var result *ast.FuncLit
 	declPos := v.Pos()
 
@@ -120,6 +127,10 @@ func findFuncLitAssignment(cctx *CheckContext, v *types.Var) *ast.FuncLit {
 			if !ok {
 				return true
 			}
+			// Skip assignments at or after beforePos
+			if beforePos != token.NoPos && assign.Pos() >= beforePos {
+				return true
+			}
 			if fl := findFuncLitInAssignment(cctx, assign, v); fl != nil {
 				result = fl // Keep updating - we want the LAST assignment
 			}
@@ -151,24 +162,29 @@ func findFuncLitInAssignment(cctx *CheckContext, assign *ast.AssignStmt, v *type
 	return nil
 }
 
-// factoryReturnsContextUsingFunc checks if a factory function's return statements
+// blockReturnsContextUsingFunc checks if a block's return statements
 // return functions that use context. Recursively checks nested func literals.
-func factoryReturnsContextUsingFunc(cctx *CheckContext, factory *ast.FuncLit) bool {
+// excludeFuncLit can be set to exclude a specific FuncLit from being counted (e.g., the parent).
+func blockReturnsContextUsingFunc(cctx *CheckContext, body *ast.BlockStmt, excludeFuncLit *ast.FuncLit) bool {
+	if body == nil {
+		return true // No body to check
+	}
+
 	usesContext := false
 
-	ast.Inspect(factory.Body, func(n ast.Node) bool {
+	ast.Inspect(body, func(n ast.Node) bool {
 		if usesContext {
 			return false
 		}
 		// For nested func literals, check both direct usage and returned values
-		if fl, ok := n.(*ast.FuncLit); ok && fl != factory {
+		if fl, ok := n.(*ast.FuncLit); ok && fl != excludeFuncLit {
 			// Check if this nested func lit uses context directly
 			if funcLitUsesContext(cctx, fl) {
 				usesContext = true
 				return false
 			}
 			// Recursively check if it returns functions that use context
-			if factoryReturnsContextUsingFunc(cctx, fl) {
+			if blockReturnsContextUsingFunc(cctx, fl.Body, fl) {
 				usesContext = true
 				return false
 			}
@@ -192,6 +208,12 @@ func factoryReturnsContextUsingFunc(cctx *CheckContext, factory *ast.FuncLit) bo
 	return usesContext
 }
 
+// factoryReturnsContextUsingFunc checks if a factory FuncLit's return statements
+// return functions that use context.
+func factoryReturnsContextUsingFunc(cctx *CheckContext, factory *ast.FuncLit) bool {
+	return blockReturnsContextUsingFunc(cctx, factory.Body, factory)
+}
+
 // returnedValueUsesContext checks if a returned value is a func that uses context.
 func returnedValueUsesContext(cctx *CheckContext, result ast.Expr) bool {
 	// If it's a func literal, check directly
@@ -215,7 +237,7 @@ func returnedValueUsesContext(cctx *CheckContext, result ast.Expr) bool {
 		return false
 	}
 
-	innerFuncLit := findFuncLitAssignment(cctx, v)
+	innerFuncLit := findFuncLitAssignment(cctx, v, token.NoPos)
 	if innerFuncLit == nil {
 		return false
 	}