perf(codegen): re-enter guarded specialization clones

[proggeramlug]

Summary

• let constructively numeric derived arguments satisfy Tier-B guarded call routing
• make recursive f(n - 1) edges re-enter the $spec_b clone directly instead of re-running the public parameter guard
• keep BigInt-capable arithmetic on the public guarded fallback, with positive and negative IR regression coverage

Fixes #8169.

Validation

• cargo test -p perry-codegen spec_self_recursion_tests --lib (5 passed)
• cargo test -p perry-codegen --lib --no-fail-fast (1,067 passed; the two existing Windows temporary-object-name byte-identity tests failed: split_native_construction_lowers_precise_roots_before_rs4gc, split_native_construction_propagates_shadow_backend_to_workers)
• cargo fmt -p perry-codegen -- --check
• python scripts/check_test_registration.py
• workspace architecture, public baseline freshness, local-binding proof, GC store-site, address-classification, and gap-snapshot quick gates
• git diff --check

No version bump. The required changelog fragment is included.

Summary by CodeRabbit

• Performance

  • Improved recursive numeric computations by enabling optimized execution when values are proven to be standard numbers.
  • Preserved safe fallback behavior for BigInt-capable or otherwise uncertain calculations.

• Bug Fixes

  • Improved handling of derived numeric arguments in guarded recursive calls, ensuring they use the appropriate optimized or fallback path.

[coderabbitai]

Caution

Review failed

The pull request is closed.

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro Plus

Run ID: d4a9f1a7-2f93-440a-8f24-fb8dc03212aa

📥 Commits

Reviewing files that changed from the base of the PR and between e9968e9 and 183b097.

📒 Files selected for processing (1)

• crates/perry-codegen/src/codegen/spec_self_recursion_tests.rs

---

📝 Walkthrough

Walkthrough

The change extends guarded-path type inference for proven numeric expressions. Recursive fixtures and tests verify direct Tier-B clone re-entry for Number values and guarded fallback for BigInt-capable arithmetic. A changelog entry documents the behavior.

Changes

Tier-B guarded self-recursion

Layer / File(s)	Summary
Numeric guarded-path proof crates/perry-codegen/src/lower_call/func_ref.rs	guarded_path_type classifies canonical raw f64 expressions as Number for specialized calls.
Recursive guarded-call validation crates/perry-codegen/src/codegen/spec_self_recursion_tests.rs, changelog.d/8290-tier-b-self-recursion.md	Recursive fixtures and tests verify direct $spec_b clone re-entry for numeric arguments and public guarded fallback for BigInt-capable arithmetic. The changelog records the behavior.

Estimated code review effort: 2 (Simple) | ~15 minutes

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title clearly identifies the main code-generation change: recursive calls re-enter guarded specialization clones.
Description check	✅ Passed	The description covers the change, linked issue, validation commands, test results, changelog, and version policy; some template headings are consolidated or omitted.
Linked Issues check	✅ Passed	The implementation addresses issue #8169 by recognizing proven numeric expressions, routing recursive calls to the Tier-B clone, and preserving BigInt fallback behavior.
Out of Scope Changes check	✅ Passed	The changed code, regression tests, and changelog fragment directly support the linked issue and stated objectives; no unrelated changes are evident.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/8169-tier-b-recursion

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[proggeramlug]

Merging. Fixes #8169 — the wrapper round-trip named as one of the two remaining routes in #8202.

Two of your own tests failed against current main, and it was not your bug. bigint_capable_recursive_argument_keeps_the_public_guard and derived_recursive_number_argument_re_enters_the_guarded_clone both went red once merged. The cause is #8203, which landed a few hours ago and gives recursion-participating clones LLVM's preserve_none convention. That word lands between define internal / call and the return type:

define internal preserve_nonecc double @…__f$spec_b(double %arg10)
call preserve_nonecc double @…__f$spec_b(

The matchers pinned a fixed prefix (starts_with("define internal double @…"), matches("call double @…").count()), so they stopped matching text that had only gained a calling convention. The subject was intact throughout — the clone existed, was specialized, and both recursive edges re-entered it. I widened the matchers to assert the parts that carry meaning (boxed clone with a double parameter; call lines naming the clone) and left the counts at 2 and 0.

Worth noting for the next IR-text test: a starts_with on an LLVM define line is fragile against any attribute or convention change, and the failure reads like a functional regression when it isn't. Matching the line and the symbol survives that.

Verified after the fix: spec_self_recursion_tests 5/5; perry-codegen --no-fail-fast 28 suites, 1537 passed, 9 failed — all nine baseline, zero new; perry-runtime --lib 2572/0/4; all 48 lint gates via scripts/run_lint_gates.sh.

Letting constructively numeric derived arguments satisfy Tier-B routing while keeping BigInt-capable arithmetic on the public guarded fallback is the right split — and having both a positive and a negative IR regression for it is what makes that split checkable rather than asserted.