refactor: consolidate duplicate FuncSpec and ExtractFunc implementations

- Create internal/funcspec package with shared Spec, Parse, Matches, ExtractFunc
- Update deriver to use funcspec.Spec and funcspec.ExtractFunc
- Update spawner to use funcspec.Spec and delegate GetFuncFromCall to funcspec.ExtractFunc
- Update context.CheckContext.ExtractCallFunc to use funcspec.ExtractFunc
- Update ssa.Tracer to use funcspec.Spec.Matches, remove duplicate matchesSpec/matchesMethod

🤖 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

@@ -9,6 +9,7 @@ import (
 	"golang.org/x/tools/go/analysis"
 
 	"github.com/mpyw/goroutinectx/internal/directives/carrier"
+	"github.com/mpyw/goroutinectx/internal/funcspec"
 	internalssa "github.com/mpyw/goroutinectx/internal/ssa"
 	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
@@ -84,26 +85,7 @@ func (c *CheckContext) FuncLitUsesContext(lit *ast.FuncLit) bool {
 
 // ExtractCallFunc extracts the types.Func from a call expression.
 func (c *CheckContext) ExtractCallFunc(call *ast.CallExpr) *types.Func {
-	switch fun := call.Fun.(type) {
-	case *ast.Ident:
-		if f, ok := c.Pass.TypesInfo.ObjectOf(fun).(*types.Func); ok {
-			return f
-		}
-
-	case *ast.SelectorExpr:
-		sel := c.Pass.TypesInfo.Selections[fun]
-		if sel != nil {
-			if f, ok := sel.Obj().(*types.Func); ok {
-				return f
-			}
-		} else {
-			if f, ok := c.Pass.TypesInfo.ObjectOf(fun.Sel).(*types.Func); ok {
-				return f
-			}
-		}
-	}
-
-	return nil
+	return funcspec.ExtractFunc(c.Pass, call)
 }
 
 // ArgUsesContext checks if an expression references a context variable.

internal/directives/deriver/directive.go

@@ -7,20 +7,15 @@ import (
 	"strings"
 
 	"golang.org/x/tools/go/analysis"
-)
 
-// FuncSpec holds parsed components of a derive function specification.
-type FuncSpec struct {
-	PkgPath  string
-	TypeName string // empty for package-level functions
-	FuncName string
-}
+	"github.com/mpyw/goroutinectx/internal/funcspec"
+)
 
 // Matcher provides OR/AND matching for derive function specifications.
 // The check passes if ANY group is fully satisfied (OR semantics).
 // A group is satisfied if ALL functions in that group are called (AND semantics).
 type Matcher struct {
-	OrGroups [][]FuncSpec
+	OrGroups [][]funcspec.Spec
 	Original string
 }
 
@@ -40,15 +35,15 @@ func NewMatcher(deriveFuncsStr string) *Matcher {
 		}
 
 		// Split by plus (AND within group)
-		var andGroup []FuncSpec
+		var andGroup []funcspec.Spec
 
 		for andPart := range strings.SplitSeq(orPart, "+") {
 			andPart = strings.TrimSpace(andPart)
 			if andPart == "" {
 				continue
 			}
 
-			spec := parseFunc(andPart)
+			spec := funcspec.Parse(andPart)
 			andGroup = append(andGroup, spec)
 		}
 
@@ -60,41 +55,6 @@ func NewMatcher(deriveFuncsStr string) *Matcher {
 	return m
 }
 
-// parseFunc parses a single derive function string into components.
-// Format: "pkg/path.Func" or "pkg/path.Type.Method".
-func parseFunc(s string) FuncSpec {
-	spec := FuncSpec{}
-
-	lastDot := strings.LastIndex(s, ".")
-	if lastDot == -1 {
-		spec.FuncName = s
-
-		return spec
-	}
-
-	spec.FuncName = s[lastDot+1:]
-	prefix := s[:lastDot]
-
-	// Check if there's another dot (indicating Type.Method)
-	// Type names start with uppercase in Go.
-	secondLastDot := strings.LastIndex(prefix, ".")
-	if secondLastDot != -1 {
-		potentialTypeName := prefix[secondLastDot+1:]
-		if len(potentialTypeName) > 0 && potentialTypeName[0] >= 'A' && potentialTypeName[0] <= 'Z' {
-			spec.PkgPath = prefix[:secondLastDot]
-			spec.TypeName = potentialTypeName
-		} else {
-			spec.PkgPath = prefix
-			spec.TypeName = ""
-		}
-	} else {
-		spec.PkgPath = prefix
-		spec.TypeName = ""
-	}
-
-	return spec
-}
-
 // SatisfiesAnyGroup checks if the AST node satisfies ANY of the OR groups.
 func (m *Matcher) SatisfiesAnyGroup(pass *analysis.Pass, node ast.Node) bool {
 	calledFuncs := collectCalledFuncs(pass, node)
@@ -118,7 +78,7 @@ func (m *Matcher) IsEmpty() bool {
 func (m *Matcher) MatchesFunc(fn *types.Func) bool {
 	for _, andGroup := range m.OrGroups {
 		for _, spec := range andGroup {
-			if matchesSpec(fn, spec) {
+			if spec.Matches(fn) {
 				return true
 			}
 		}
@@ -142,7 +102,7 @@ func collectCalledFuncs(pass *analysis.Pass, node ast.Node) []*types.Func {
 			return true
 		}
 
-		if fn := extractFunc(pass, call); fn != nil {
+		if fn := funcspec.ExtractFunc(pass, call); fn != nil {
 			funcs = append(funcs, fn)
 		}
 
@@ -152,34 +112,8 @@ func collectCalledFuncs(pass *analysis.Pass, node ast.Node) []*types.Func {
 	return funcs
 }
 
-// extractFunc extracts the types.Func from a call expression.
-func extractFunc(pass *analysis.Pass, call *ast.CallExpr) *types.Func {
-	switch fun := call.Fun.(type) {
-	case *ast.Ident:
-		obj := pass.TypesInfo.ObjectOf(fun)
-		if f, ok := obj.(*types.Func); ok {
-			return f
-		}
-
-	case *ast.SelectorExpr:
-		sel := pass.TypesInfo.Selections[fun]
-		if sel != nil {
-			if f, ok := sel.Obj().(*types.Func); ok {
-				return f
-			}
-		} else {
-			obj := pass.TypesInfo.ObjectOf(fun.Sel)
-			if f, ok := obj.(*types.Func); ok {
-				return f
-			}
-		}
-	}
-
-	return nil
-}
-
 // groupSatisfied checks if ALL specs in the AND group are satisfied.
-func groupSatisfied(calledFuncs []*types.Func, andGroup []FuncSpec) bool {
+func groupSatisfied(calledFuncs []*types.Func, andGroup []funcspec.Spec) bool {
 	for _, spec := range andGroup {
 		if !specSatisfied(calledFuncs, spec) {
 			return false
@@ -190,54 +124,12 @@ func groupSatisfied(calledFuncs []*types.Func, andGroup []FuncSpec) bool {
 }
 
 // specSatisfied checks if the spec is satisfied by any of the called functions.
-func specSatisfied(calledFuncs []*types.Func, spec FuncSpec) bool {
+func specSatisfied(calledFuncs []*types.Func, spec funcspec.Spec) bool {
 	for _, fn := range calledFuncs {
-		if matchesSpec(fn, spec) {
+		if spec.Matches(fn) {
 			return true
 		}
 	}
 
 	return false
 }
-
-// matchesSpec checks if a types.Func matches the given derive function spec.
-func matchesSpec(fn *types.Func, spec FuncSpec) bool {
-	if fn.Name() != spec.FuncName {
-		return false
-	}
-
-	if fn.Pkg() == nil || fn.Pkg().Path() != spec.PkgPath {
-		return false
-	}
-
-	if spec.TypeName != "" {
-		return matchesMethod(fn, spec.TypeName)
-	}
-
-	return true
-}
-
-// matchesMethod checks if a types.Func is a method on the expected type.
-func matchesMethod(fn *types.Func, typeName string) bool {
-	sig, ok := fn.Type().(*types.Signature)
-	if !ok {
-		return false
-	}
-
-	recv := sig.Recv()
-	if recv == nil {
-		return false
-	}
-
-	recvType := recv.Type()
-	if ptr, ok := recvType.(*types.Pointer); ok {
-		recvType = ptr.Elem()
-	}
-
-	named, ok := recvType.(*types.Named)
-	if !ok {
-		return false
-	}
-
-	return named.Obj().Name() == typeName
-}