Fix recursive pointer unwrapping in carrier type matching (#19)

* fix: recursively unwrap all pointer layers in carrier type matching

Fixes #18

## Problem

When SSA captures a pointer variable (*CarrierType) in a closure, it adds an
extra level of indirection, resulting in **CarrierType in FreeVars. The
previous single-layer unwrapPointer only handled one level:
  **CarrierType → *CarrierType (still doesn't match CarrierType)

This caused false positives when carrier types were used via field access.

## Solution

- Made typeutil.UnwrapPointer() recursive to handle arbitrary pointer depth
- Removed duplicate unwrapPointer definitions in carrier and funcspec packages
- All packages now use the centralized typeutil.UnwrapPointer()

## Changes

- internal/typeutil: Made UnwrapPointer recursive and exported it
- internal/directive/carrier: Use typeutil.UnwrapPointer, remove local version
- internal/funcspec: Use typeutil.UnwrapPointer, remove local version

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

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

* docs: update version reference to v0.7.3

---------

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: mpyw

README.md

@@ -40,7 +40,7 @@ go run github.com/mpyw/goroutinectx/cmd/goroutinectx@latest ./...
 ```
 
 > [!CAUTION]
-> To prevent supply chain attacks, pin to a specific version tag instead of `@latest` in CI/CD pipelines (e.g., `@v0.7.2`).
+> To prevent supply chain attacks, pin to a specific version tag instead of `@latest` in CI/CD pipelines (e.g., `@v0.7.3`).
 
 ### As a Library
 

internal/directive/carrier/carrier.go

@@ -4,6 +4,8 @@ package carrier
 import (
 	"go/types"
 	"strings"
+
+	"github.com/mpyw/goroutinectx/internal/typeutil"
 )
 
 // Carrier represents a type that can carry context.
@@ -15,7 +17,7 @@ type Carrier struct {
 
 // Matches checks if the given type matches this carrier.
 func (c Carrier) Matches(t types.Type) bool {
-	t = unwrapPointer(t)
+	t = typeutil.UnwrapPointer(t)
 
 	named, ok := t.(*types.Named)
 	if !ok {
@@ -30,14 +32,6 @@ func (c Carrier) Matches(t types.Type) bool {
 	return matchPkg(obj.Pkg().Path(), c.PkgPath) && obj.Name() == c.TypeName
 }
 
-// unwrapPointer returns the element type if t is a pointer.
-func unwrapPointer(t types.Type) types.Type {
-	if ptr, ok := t.(*types.Pointer); ok {
-		return ptr.Elem()
-	}
-	return t
-}
-
 // matchPkg checks if pkgPath matches targetPkg, allowing version suffixes.
 func matchPkg(pkgPath, targetPkg string) bool {
 	if pkgPath == targetPkg {

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.
@@ -80,7 +82,7 @@ func (s Spec) Matches(fn *types.Func) bool {
 		return false
 	}
 
-	recvType := unwrapPointer(recv.Type())
+	recvType := typeutil.UnwrapPointer(recv.Type())
 
 	named, ok := recvType.(*types.Named)
 	if !ok {
@@ -116,14 +118,6 @@ func ExtractFunc(pass *analysis.Pass, call *ast.CallExpr) *types.Func {
 	return nil
 }
 
-// unwrapPointer returns the element type if t is a pointer.
-func unwrapPointer(t types.Type) types.Type {
-	if ptr, ok := t.(*types.Pointer); ok {
-		return ptr.Elem()
-	}
-	return t
-}
-
 // shortPkgName returns the last component of a package path.
 func shortPkgName(pkgPath string) string {
 	if idx := strings.LastIndex(pkgPath, "/"); idx >= 0 {

internal/typeutil/typeutil.go

@@ -8,7 +8,7 @@ const contextPkgPath = "context"
 
 // IsContextType checks if the type is context.Context.
 func IsContextType(t types.Type) bool {
-	t = unwrapPointer(t)
+	t = UnwrapPointer(t)
 
 	named, ok := t.(*types.Named)
 	if !ok {
@@ -23,10 +23,26 @@ func IsContextType(t types.Type) bool {
 	return obj.Pkg().Path() == contextPkgPath && obj.Name() == "Context"
 }
 
-// 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()
+// UnwrapPointer recursively unwraps all pointer layers.
+//
+// This is critical for SSA-based carrier type matching. When a closure captures
+// a pointer variable, SSA represents it with an additional level of indirection:
+//
+//	func handler(ctx *CarrierType) {
+//	    go func() {
+//	        _ = ctx  // SSA FreeVars: **CarrierType (not *CarrierType)
+//	    }()
+//	}
+//
+// Therefore, we must unwrap ALL pointer layers to match against the registered
+// carrier type (CarrierType, no pointer). Single-layer unwrapping would leave
+// *CarrierType, which wouldn't match.
+func UnwrapPointer(t types.Type) types.Type {
+	for {
+		ptr, ok := t.(*types.Pointer)
+		if !ok {
+			return t
+		}
+		t = ptr.Elem()
 	}
-	return t
 }