refactor: consolidate assignment finding and pointer unwrapping

- Add CheckContext.FindCallExprAssignment (mirrors FindFuncLitAssignment)
- Remove duplicate deriverFindCallExprAssignmentBefore from should_call_deriver
- Export typeutil.UnwrapPointer for reuse
- Update funcspec, registry, spawnerlabel to use typeutil.UnwrapPointer

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

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

Author: mpyw

internal/context/context.go

@@ -164,6 +164,58 @@ func (c *CheckContext) findFuncLitInAssignment(assign *ast.AssignStmt, v *types.
 	return nil
 }
 
+// FindCallExprAssignment searches for the call expression assigned to the variable.
+// If beforePos is token.NoPos, returns the LAST assignment found.
+// If beforePos is set, returns the last assignment BEFORE that position.
+func (c *CheckContext) FindCallExprAssignment(v *types.Var, beforePos token.Pos) *ast.CallExpr {
+	var result *ast.CallExpr
+	declPos := v.Pos()
+
+	for _, f := range c.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
+			}
+			// Skip assignments at or after beforePos
+			if beforePos != token.NoPos && assign.Pos() >= beforePos {
+				return true
+			}
+			if call := c.findCallExprInAssignment(assign, v); call != nil {
+				result = call // Keep updating - we want the LAST assignment
+			}
+			return true
+		})
+		break
+	}
+
+	return result
+}
+
+// findCallExprInAssignment checks if the assignment assigns a call expression to v.
+func (c *CheckContext) findCallExprInAssignment(assign *ast.AssignStmt, v *types.Var) *ast.CallExpr {
+	for i, lhs := range assign.Lhs {
+		ident, ok := lhs.(*ast.Ident)
+		if !ok {
+			continue
+		}
+		if c.Pass.TypesInfo.ObjectOf(ident) != v {
+			continue
+		}
+		if i >= len(assign.Rhs) {
+			continue
+		}
+		if call, ok := assign.Rhs[i].(*ast.CallExpr); ok {
+			return call
+		}
+	}
+	return nil
+}
+
 // BlockReturnsContextUsingFunc checks if a block's return statements
 // return functions that use context. Recursively checks nested func literals.
 // excludeFuncLit can be set to exclude a specific FuncLit from being counted (e.g., the parent).

internal/funcspec/funcspec.go

@@ -8,6 +8,8 @@ import (
 	"unicode"
 
 	"golang.org/x/tools/go/analysis"
+
+	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
 
 // Spec holds parsed components of a function specification.
@@ -76,11 +78,7 @@ func (s Spec) Matches(fn *types.Func) bool {
 		return false
 	}
 
-	recvType := recv.Type()
-	// Handle pointer receivers
-	if ptr, ok := recvType.(*types.Pointer); ok {
-		recvType = ptr.Elem()
-	}
+	recvType := typeutil.UnwrapPointer(recv.Type())
 
 	named, ok := recvType.(*types.Named)
 	if !ok {

internal/patterns/should_call_deriver.go

@@ -2,7 +2,6 @@ package patterns
 
 import (
 	"go/ast"
-	"go/token"
 	"go/types"
 	"strings"
 
@@ -71,7 +70,7 @@ func (p *ShouldCallDeriver) identCallsDeriver(cctx *context.CheckContext, ident
 	}
 
 	// Try to find a CallExpr assignment (e.g., task := NewTask(fn))
-	callExpr := deriverFindCallExprAssignmentBefore(cctx, v, ident.Pos())
+	callExpr := cctx.FindCallExprAssignment(v, ident.Pos())
 	if callExpr != nil {
 		return p.callExprCallsDeriver(cctx, callExpr)
 	}
@@ -210,45 +209,3 @@ func (p *ShouldCallDeriver) funcLitReturnCallsDeriver(cctx *context.CheckContext
 func (p *ShouldCallDeriver) Message(apiName string, _ string) string {
 	return apiName + "() callback should call goroutine deriver"
 }
-
-// deriverFindCallExprAssignmentBefore finds the last CallExpr assigned to variable before pos.
-func deriverFindCallExprAssignmentBefore(cctx *context.CheckContext, v *types.Var, beforePos token.Pos) *ast.CallExpr {
-	var result *ast.CallExpr
-	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 call, ok := assign.Rhs[i].(*ast.CallExpr); ok {
-					result = call
-				}
-			}
-			return true
-		})
-		break
-	}
-
-	return result
-}

internal/registry/registry.go

@@ -8,6 +8,7 @@ import (
 	"golang.org/x/tools/go/analysis"
 
 	"github.com/mpyw/goroutinectx/internal/patterns"
+	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
 
 // Entry represents a registered API with its pattern.
@@ -88,10 +89,7 @@ func (r *Registry) isMethodCall(pass *analysis.Pass, sel *ast.SelectorExpr, api
 		return false
 	}
 
-	// Unwrap pointer
-	if ptr, ok := typ.(*types.Pointer); ok {
-		typ = ptr.Elem()
-	}
+	typ = typeutil.UnwrapPointer(typ)
 
 	named, ok := typ.(*types.Named)
 	if !ok {

internal/spawnerlabel/detector.go

@@ -169,9 +169,7 @@ func isGotaskTaskType(pass *analysis.Pass, expr ast.Expr) bool {
 		return false
 	}
 
-	if ptr, ok := typ.(*types.Pointer); ok {
-		typ = ptr.Elem()
-	}
+	typ = typeutil.UnwrapPointer(typ)
 
 	named, ok := typ.(*types.Named)
 	if !ok {

internal/typeutil/typeutil.go

@@ -24,7 +24,7 @@ func IsNamedType(pass *analysis.Pass, expr ast.Expr, pkgPath, typeName string) b
 
 // isNamedTypeFromType checks if the type matches the given package path and type name.
 func isNamedTypeFromType(t types.Type, pkgPath, typeName string) bool {
-	t = unwrapPointer(t)
+	t = UnwrapPointer(t)
 
 	named, ok := t.(*types.Named)
 	if !ok {
@@ -39,8 +39,8 @@ func isNamedTypeFromType(t types.Type, pkgPath, typeName string) bool {
 	return obj.Pkg().Path() == pkgPath && obj.Name() == typeName
 }
 
-// unwrapPointer returns the element type if t is a pointer, otherwise returns t.
-func unwrapPointer(t types.Type) types.Type {
+// UnwrapPointer returns the element type if t is a pointer, otherwise returns t.
+func UnwrapPointer(t types.Type) types.Type {
 	if ptr, ok := t.(*types.Pointer); ok {
 		return ptr.Elem()
 	}