Remove WithStringer and enhance anonymous key debugging

BREAKING CHANGES:
- Remove WithStringer option and StringerFunc type

The WithStringer option was redundant since named keys already provide
clear identification, and anonymous keys now include call site info.

Enhancements:
- Anonymous keys now include file path and line number in their name
  (e.g., "anonymous(/path/to/file.go:42)@0x...")
- Add runtime.Caller integration with depth tracking for accurate
  call site resolution across New, NewBool, NewNamed, NewNamedBool

Other changes:
- Extract anonymous key tests to anonymous_test.go for stable line numbers
- Update doc comments and README with new anonymous key format

Author: mpyw

.golangci.yaml

@@ -14,6 +14,8 @@ linters:
     - interfacebloat
     # Disable depguard since this is a simple package without external dependencies
     - depguard
+    # Allow if err := ...; err != nil {} blocks
+    - noinlineerr
   settings:
     cyclop:
       max-complexity: 30

README.md

@@ -261,8 +261,13 @@ var (
 ```go
 // Named keys make debugging easier
 var MyFeature = feature.NewNamedBool("my-feature")
-fmt.Println(MyFeature.String())
+fmt.Println(MyFeature)
 // Output: my-feature
+
+// Anonymous keys automatically include call site information for debugging
+var AnonFeature = feature.NewBool()
+fmt.Println(AnonFeature)
+// Output: anonymous(/path/to/file.go:42)@0x14000010098
 ```
 
 ### 3. Use Type-Safe Value Keys

anonymous_test.go

@@ -0,0 +1,107 @@
+package feature_test
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/mpyw/feature"
+)
+
+// TestAnonymousKeyCallSite tests that anonymous keys capture the correct call site information.
+func TestAnonymousKeyCallSite(t *testing.T) {
+	t.Parallel()
+
+	t.Run("New without name returns call site info", func(t *testing.T) {
+		t.Parallel()
+
+		key := feature.New[int]()
+		assertAnonymousKeyFormat(t, key.String(), "anonymous_test.go", 19)
+	})
+
+	t.Run("NewBool returns call site info", func(t *testing.T) {
+		t.Parallel()
+
+		key := feature.NewBool()
+		assertAnonymousKeyFormat(t, key.String(), "anonymous_test.go", 26)
+	})
+
+	t.Run("NewNamed with empty name returns call site info", func(t *testing.T) {
+		t.Parallel()
+
+		key := feature.NewNamed[int]("")
+		assertAnonymousKeyFormat(t, key.String(), "anonymous_test.go", 33)
+	})
+
+	t.Run("NewNamedBool with empty name returns call site info", func(t *testing.T) {
+		t.Parallel()
+
+		key := feature.NewNamedBool("")
+		assertAnonymousKeyFormat(t, key.String(), "anonymous_test.go", 40)
+	})
+}
+
+// assertAnonymousKeyFormat verifies that an anonymous key string has the correct format
+// with the expected filename and line number.
+//
+//nolint:unparam // explicitly keeping wantFile and wantLine for clarity
+func assertAnonymousKeyFormat(t *testing.T, str, wantFile string, wantLine int) {
+	t.Helper()
+
+	// Should have format "anonymous(/full/path/to/file.go:line)@0x..."
+	if !strings.HasPrefix(str, "anonymous(") {
+		t.Errorf("String() = %q, want prefix %q", str, "anonymous(")
+
+		return
+	}
+
+	if !strings.Contains(str, "@0x") {
+		t.Errorf("String() = %q, want to contain %q", str, "@0x")
+
+		return
+	}
+
+	// Extract the file path and line number from the string
+	// Format: anonymous(/path/to/feature_test.go:123)@0xaddress
+	start := strings.Index(str, "(")
+
+	end := strings.LastIndex(str, ")")
+
+	if start == -1 || end == -1 || start >= end {
+		t.Errorf("String() = %q, could not extract file:line info", str)
+
+		return
+	}
+
+	fileLineInfo := str[start+1 : end]
+
+	lastColon := strings.LastIndex(fileLineInfo, ":")
+
+	if lastColon == -1 {
+		t.Errorf("String() = %q, could not find colon in file:line info %q", str, fileLineInfo)
+
+		return
+	}
+
+	filePath := fileLineInfo[:lastColon]
+	lineStr := fileLineInfo[lastColon+1:]
+
+	// Verify filename
+	baseName := filepath.Base(filePath)
+	if baseName != wantFile {
+		t.Errorf("filepath.Base(filePath) = %q, want %q (full path: %q)", baseName, wantFile, filePath)
+	}
+
+	// Verify line number
+	var gotLine int
+	if _, err := fmt.Sscanf(lineStr, "%d", &gotLine); err != nil {
+		t.Errorf("could not parse line number from %q: %v", lineStr, err)
+
+		return
+	}
+
+	if gotLine != wantLine {
+		t.Errorf("line number = %d, want %d (full string: %q)", gotLine, wantLine, str)
+	}
+}

feature.go

@@ -22,13 +22,18 @@
 //
 //	ctx = MyFeature.WithEnabled(ctx)
 //
-// # WithName Keys for Debugging
+// # Named Keys for Debugging
 //
 // You can create named keys to help with debugging:
 //
 //	var MyFeature = feature.NewNamedBool("my-feature")
 //	fmt.Println(MyFeature) // Output: my-feature
 //
+// Anonymous keys (without a name) automatically include call site information:
+//
+//	var AnonFeature = feature.NewBool()
+//	fmt.Println(AnonFeature) // Output: anonymous(/path/to/file.go:42)@0x14000010098
+//
 // # Value-Based Feature Flags
 //
 // You can also use feature flags with arbitrary types:
@@ -48,6 +53,7 @@ package feature
 import (
 	"context"
 	"fmt"
+	"runtime"
 )
 
 // Key is a type-safe accessor for feature flags stored in context.Context.
@@ -127,19 +133,15 @@ type BoolKey interface {
 	WithDisabled(ctx context.Context) context.Context
 }
 
-// StringerFunc is a function that formats a key name as a string.
-// It receives a resolved key name (never empty - anonymous keys are already
-// formatted as "anonymous@<address>") and returns the final string representation.
-// The default implementation returns the name as-is.
-type StringerFunc func(name string) string
-
 // Option is a function that configures the behavior of a feature flag key.
 type Option func(*options)
 
 // options configures the behavior of a feature flag key.
 type options struct {
-	name     string
-	stringer StringerFunc
+	name string
+
+	// internal use only - tracks the caller depth for name fallback
+	depth int
 }
 
 // WithName returns an option that sets a debug name for the key.
@@ -155,35 +157,19 @@ func WithName(name string) Option {
 	}
 }
 
-// WithStringer returns an option that sets a custom string formatter for the key name.
-// The formatter function receives a resolved key name (never empty) and returns
-// the final string representation.
-//
-// If not provided, the default formatter returns the name as-is.
-//
-// Example:
-//
-//	customFormatter := func(name string) string {
-//	    return fmt.Sprintf("[%s]", name)
-//	}
-//	var MyKey = feature.New[int](feature.WithStringer(customFormatter))
-func WithStringer(f StringerFunc) Option {
-	return func(o *options) {
-		o.stringer = f
-	}
-}
-
-// defaultStringer is the default string formatter for keys.
-// It returns the name as-is (identity function).
-func defaultStringer(name string) string {
-	return name
+// appendCallerDepthIncr appends an option that increments the caller depth for name fallback.
+// This is used internally to ensure correct caller depth when deriving names from call sites.
+func appendCallerDepthIncr(opts []Option) []Option {
+	return append(opts, func(o *options) {
+		o.depth++
+	})
 }
 
 // defaultOptions returns a new options with default values.
 func defaultOptions() *options {
 	return &options{
-		name:     "",
-		stringer: defaultStringer,
+		name:  "",
+		depth: 0,
 	}
 }
 
@@ -197,6 +183,24 @@ func optionsFrom(opts []Option) *options {
 	return o
 }
 
+func computeKeyName(ident *opaque, name string, depth int) string {
+	// Resolve the base name (handle anonymous keys)
+	if name == "" {
+		// depth is the number of stack frames added by wrapper functions.
+		// Each exported function (New, NewBool, NewNamed, NewNamedBool) calls appendCallerDepthIncr.
+		// The call stack is: runtime.Caller -> computeKeyName -> New -> [wrappers...] -> user code
+		// Base offset is 1 (computeKeyName itself), plus depth for wrapper functions.
+		_, file, line, ok := runtime.Caller(1 + depth)
+		if ok {
+			name = fmt.Sprintf("anonymous(%s:%d)@%p", file, line, ident)
+		} else {
+			name = fmt.Sprintf("anonymous@%p", ident)
+		}
+	}
+
+	return name
+}
+
 // NewBool creates a new boolean feature flag key.
 //
 // Each call to NewBool creates a unique key based on pointer identity, preventing collisions.
@@ -212,6 +216,8 @@ func optionsFrom(opts []Option) *options {
 //	    }
 //	}
 func NewBool(options ...Option) BoolKey {
+	options = appendCallerDepthIncr(options)
+
 	return boolKey{key: New[bool](options...).downcast()}
 }
 
@@ -225,6 +231,8 @@ func NewBool(options ...Option) BoolKey {
 //	var EnableNewUI = feature.NewNamedBool("new-ui")
 //	fmt.Println(EnableNewUI) // Output: new-ui
 func NewNamedBool(name string, options ...Option) BoolKey {
+	options = appendCallerDepthIncr(options)
+
 	return NewBool(append([]Option{WithName(name)}, options...)...)
 }
 
@@ -239,12 +247,13 @@ func NewNamedBool(name string, options ...Option) BoolKey {
 //	ctx = MaxRetries.WithValue(ctx, 5)
 //	retries := MaxRetries.Get(ctx) // Returns 5
 func New[V any](options ...Option) Key[V] {
+	options = appendCallerDepthIncr(options)
 	opts := optionsFrom(options)
+	ident := new(opaque)
 
 	return key[V]{
-		name:     opts.name,
-		stringer: opts.stringer,
-		ident:    new(opaque),
+		name:  computeKeyName(ident, opts.name, opts.depth),
+		ident: ident,
 	}
 }
 
@@ -258,38 +267,25 @@ func New[V any](options ...Option) Key[V] {
 //	var MaxRetries = feature.NewNamed[int]("max-retries")
 //	fmt.Println(MaxRetries) // Output: max-retries
 func NewNamed[V any](name string, options ...Option) Key[V] {
+	options = appendCallerDepthIncr(options)
+
 	return New[V](append([]Option{WithName(name)}, options...)...)
 }
 
 // key is the internal implementation of Key[V].
 type key[V any] struct {
-	name     string
-	stringer StringerFunc
-	ident    *opaque
+	name  string
+	ident *opaque
 }
 
 // boolKey is the internal implementation of BoolKey.
 type boolKey struct {
 	key[bool]
 }
 
-// String returns a string representation of the key name.
-// The format can be customized via the WithStringer option.
-// By default, it returns the debug name if provided, or "anonymous@<address>" otherwise.
+// String returns the debug name of the key.
 func (k key[V]) String() string {
-	// Resolve the base name (handle anonymous keys)
-	name := k.name
-	if name == "" {
-		name = fmt.Sprintf("anonymous@%p", k.ident)
-	}
-
-	// Apply custom stringer if provided
-	stringer := k.stringer
-	if stringer == nil {
-		stringer = defaultStringer
-	}
-
-	return stringer(name)
+	return k.name
 }
 
 // DebugValue returns a string representation combining the key name and its value from the context.