fix(noreferencestyle): keep nil return on zero footnote matches

make([]footnoteOccurrence, 0, len(matches)) is non-nil even when
len(matches) == 0 (Go's make does not special-case a zero-capacity
slice back to nil), so the earlier pre-sizing commit silently broke
the "return nil, not []T{}" convention this same PR applies to
headingincrement and tableformat for the common zero-match case.
Return nil directly before the pre-sized make when there are no
matches. Caught by code review round 2.

Also corrects the extractHeadings doc/test comments in
requiredstructure: checkSingleFileSchemaFromData (single-source) and
checkComposedSources's per-source loop (N>=2 extends sources) are
mutually exclusive within one Check, so the walk count saved is N,
not "N+" as the round-1 correction still implied.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01BTLNzEVChZtqSc7m7ph5Ah

Author: claude

internal/rules/noreferencestyle/alloc_test.go

@@ -95,3 +95,25 @@ func TestScanFootnoteDefinitions_PresizedAllocs(t *testing.T) {
 	assert.LessOrEqualf(t, allocs, 43.0,
 		"scanFootnoteDefinitions allocs regressed: got %v, want <= 43", allocs)
 }
+
+// TestScanFootnoteReferences_NoMatches_ReturnsNil and
+// TestScanFootnoteDefinitions_NoMatches_ReturnsNil pin
+// docs/development/high-performance-go.md's "return nil, not []T{}"
+// convention for the zero-match case: make([]footnoteOccurrence, 0,
+// len(matches)) with len(matches) == 0 still returns a non-nil empty
+// slice in Go, so the pre-sizing fix must special-case the no-match
+// return to stay nil, matching the convention this same PR applies to
+// headingincrement and tableformat.
+func TestScanFootnoteReferences_NoMatches_ReturnsNil(t *testing.T) {
+	f, err := lint.NewFile("clean.md", []byte("No footnotes here.\n"))
+	require.NoError(t, err)
+	out := scanFootnoteReferences(f, map[int]struct{}{}, nil)
+	assert.Nil(t, out, "scanFootnoteReferences must return nil when there are no matches")
+}
+
+func TestScanFootnoteDefinitions_NoMatches_ReturnsNil(t *testing.T) {
+	f, err := lint.NewFile("clean.md", []byte("No footnotes here.\n"))
+	require.NoError(t, err)
+	out := scanFootnoteDefinitions(f, map[int]struct{}{})
+	assert.Nil(t, out, "scanFootnoteDefinitions must return nil when there are no matches")
+}

internal/rules/noreferencestyle/rule.go

@@ -373,6 +373,9 @@ func scanFootnoteReferences(
 ) []footnoteOccurrence {
 	source := f.Source
 	matches := footnoteRefRE.FindAllSubmatchIndex(source, -1)
+	if len(matches) == 0 {
+		return nil
+	}
 	out := make([]footnoteOccurrence, 0, len(matches))
 	for _, m := range matches {
 		start := m[0]
@@ -403,6 +406,9 @@ func scanFootnoteDefinitions(
 ) []footnoteOccurrence {
 	source := f.Source
 	matches := footnoteDefRE.FindAllSubmatchIndex(source, -1)
+	if len(matches) == 0 {
+		return nil
+	}
 	out := make([]footnoteOccurrence, 0, len(matches))
 	for _, m := range matches {
 		start := m[0]

internal/rules/requiredstructure/rule.go

@@ -1874,12 +1874,15 @@ type docHeading struct {
 }
 
 // extractHeadings walks the AST and collects all headings. Memoized
-// per File via lint.File.MemoFile: on the document File, this is
-// called from checkSingleFileSchemaFromData, the per-source loop in
-// checkComposedSources (via bodySyncDiagnostics), and fixBodySyncIn,
-// so a document validated against a composed schema with N extends
-// sources would otherwise re-walk the same AST N+ times per Check.
-// parseSchemaWithRootFS also calls this, but on a throwaway
+// per File via lint.File.MemoFile: within one Check, the document
+// File sees this called once, from checkSingleFileSchemaFromData,
+// when the rule has a single schema source, or once per source from
+// checkComposedSources's bodySyncDiagnostics loop when the rule
+// composes N>=2 extends sources — Check's dispatch on len(sources)
+// makes the two paths mutually exclusive, so a document composing N
+// extends sources would otherwise re-walk the same AST N times per
+// Check. fixBodySyncIn (the Fix path, single-source only) calls this
+// too. parseSchemaWithRootFS also calls this, but on a throwaway
 // schema-content File built fresh per call, so the memo there is a
 // no-op rather than a shared cache.
 func extractHeadings(f *lint.File) []docHeading {

internal/rules/requiredstructure/rule_test.go

@@ -2004,10 +2004,10 @@ func TestHeadingText_WithLink(t *testing.T) {
 }
 
 // TestExtractHeadings_Memoized pins that repeated calls on the same
-// File share the same backing slice: a composed schema with N extends
-// sources calls extractHeadings once per source (bodySyncDiagnostics)
-// plus once from checkSingleFileSchemaFromData/fixBodySyncIn, so an
-// unmemoized walk re-scans the same AST N+ times per Check.
+// File share the same backing slice: a schema composing N>=2 extends
+// sources calls extractHeadings once per source from
+// checkComposedSources's bodySyncDiagnostics loop, so an unmemoized
+// walk would re-scan the same AST N times within one Check.
 func TestExtractHeadings_Memoized(t *testing.T) {
 	f := newTestFile(t, "doc.md", "# H1\n\n## H2\n\n### H3\n")
 	h1 := extractHeadings(f)