Pool the dual parser in flavor.Detect; inline onlyAccept

Self-review found two issues from the plan-185 changes:

1. Detect built a fresh goldmark parser per call via NewPooledParser,
   running the full Extend hook chain on every Check. The previous
   singleton in internal/rules/markdownflavor avoided this; the move
   to a stateless public Detect regressed it. Add a sync.Pool inside
   the flavor package that hands each Detect goroutine its own
   parser-with-reset pair, mirroring internal/schema's
   contentParserPool. The pool resets the link-reference transformer
   before Put so idle slots do not pin document bytes.

2. fix.go used a one-line onlyAccept helper that was only ever called
   from one site. Inline the closure literal at the call site and
   drop the helper.

A new BenchmarkDetectReusesPool exercises the dual-parser code path
repeatedly; coverage in pkg/markdown/flavor stays at 100%.

https://claude.ai/code/session_0144ZKUS2Zrg7xBft54qyoti

Author: claude

internal/rules/markdownflavor/fix.go

@@ -44,7 +44,10 @@ func (r *Rule) fixByteRangeFeatures(f *lint.File) []byte {
 
 	if !flavor.Supports(r.Flavor, flavor.FeatureBareURLAutolinks) {
 		doc := &markdown.Document{Body: f.Source, AST: f.AST}
-		for _, fin := range flavor.Detect(doc, onlyAccept(flavor.FeatureBareURLAutolinks)) {
+		acceptBareURLs := func(feat flavor.Feature) bool {
+			return feat == flavor.FeatureBareURLAutolinks
+		}
+		for _, fin := range flavor.Detect(doc, acceptBareURLs) {
 			edits = append(edits, wrapBareURL(f.Source, fin))
 		}
 	}
@@ -55,12 +58,6 @@ func (r *Rule) fixByteRangeFeatures(f *lint.File) []byte {
 	return applyEdits(f.Source, edits)
 }
 
-// onlyAccept returns an accept predicate that admits only feat. Used
-// by Fix when re-running detection for a single feature.
-func onlyAccept(feat flavor.Feature) func(flavor.Feature) bool {
-	return func(f flavor.Feature) bool { return f == feat }
-}
-
 // needsAnyDualFix reports whether any dual-parser fixable feature is
 // unsupported by the configured flavor. Skips the dual re-parse for
 // flavors that accept every dual feature (e.g. flavor.FlavorAny,

pkg/markdown/flavor/bench_test.go

@@ -0,0 +1,24 @@
+package flavor
+
+import (
+	"testing"
+
+	"github.com/jeduden/mdsmith/pkg/markdown"
+)
+
+// BenchmarkDetectReusesPool exercises the dual-parser code path
+// repeatedly to confirm the sync.Pool inside Detect avoids
+// rebuilding the goldmark parser per call. Each iteration parses a
+// small document that triggers the dual pass.
+func BenchmarkDetectReusesPool(b *testing.B) {
+	src := []byte("# Title {#top}\n\n" +
+		"- [ ] task\n\n" +
+		"| a | b |\n| - | - |\n| 1 | 2 |\n\n" +
+		"~~old~~ text\n")
+	doc := markdown.Parse(src)
+	b.ResetTimer()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		_ = Detect(doc, nil)
+	}
+}

pkg/markdown/flavor/detect.go

@@ -4,9 +4,11 @@ import (
 	"bytes"
 	"regexp"
 	"sort"
+	"sync"
 
 	"github.com/yuin/goldmark/ast"
 	extast "github.com/yuin/goldmark/extension/ast"
+	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/text"
 
 	"github.com/jeduden/mdsmith/pkg/markdown"
@@ -66,6 +68,26 @@ var bareURLPattern = regexp.MustCompile(
 		"`" + `]*)?`,
 )
 
+// detectParserPool reuses dual-parser instances across Detect calls.
+// Building one parser fans out goldmark.New plus every extension's
+// Extend hook; over a 600-file workspace check that cost shows up as
+// a measurable fraction of CPU and allocations. parser.Parser is
+// only safe to reuse sequentially within a single goroutine, so the
+// pool hands each Detect goroutine its own instance and clears the
+// link-reference transformer's pinned document bytes via the paired
+// reset closure before Put. Mirrors the schema content-parser pool.
+type pooledDetectParser struct {
+	parser parser.Parser
+	reset  func()
+}
+
+var detectParserPool = sync.Pool{
+	New: func() any {
+		p, reset := NewPooledParser()
+		return &pooledDetectParser{parser: p, reset: reset}
+	},
+}
+
 // Detect runs every feature detector against doc and returns findings
 // in document-body order. accept is an optional predicate: when
 // non-nil, only features for which accept(feat) returns true are
@@ -88,14 +110,7 @@ func Detect(doc *markdown.Document, accept func(Feature) bool) []Finding {
 	var out []Finding
 
 	if anyDualFeatureAccepted(keep) {
-		dualParser, reset := NewPooledParser()
-		defer reset()
-		dualDoc := dualParser.Parse(text.NewReader(source))
-		for _, fin := range detectFromDual(source, dualDoc) {
-			if keep(fin.Feature) {
-				out = append(out, fin)
-			}
-		}
+		out = append(out, dualFindings(source, keep)...)
 	}
 
 	if keep(FeatureBareURLAutolinks) {
@@ -112,6 +127,28 @@ func Detect(doc *markdown.Document, accept func(Feature) bool) []Finding {
 	return out
 }
 
+// dualFindings runs the dual parser via the pooled parser instance,
+// walks the resulting AST, and returns the keep-filtered findings.
+// Borrows a parser for the duration of the parse-plus-walk only, so
+// the parser's link-ref transformer cannot pin source bytes between
+// calls.
+func dualFindings(source []byte, keep func(Feature) bool) []Finding {
+	pp := detectParserPool.Get().(*pooledDetectParser)
+	defer func() {
+		pp.reset()
+		detectParserPool.Put(pp)
+	}()
+	dualDoc := pp.parser.Parse(text.NewReader(source))
+	all := detectFromDual(source, dualDoc)
+	out := make([]Finding, 0, len(all))
+	for _, fin := range all {
+		if keep(fin.Feature) {
+			out = append(out, fin)
+		}
+	}
+	return out
+}
+
 // anyDualFeatureAccepted reports whether any feature detected by the
 // dual-parser pass is wanted. Lets Detect skip the goldmark re-parse
 // when every feature it would detect is already supported by the