feat(unroll): point not-unrolled warnings at the #[unroll] attribute

[midagedev]

What this adds

A not-unrolled warning now says where the request was. The #[kernel], #[device] and #[cuda_module] macros give the hidden __unroll_config marker the span of the #[unroll] attribute instead of the span of the outer macro, and the unroll pass prints the position the importer attached to that marker as a second line in rustc's --> form. A kernel with several annotated loops shows which one was left alone.

before:
warning: #[unroll] requested but the loop was not unrolled: no recognized induction variable (loop counter)

after:
warning: #[unroll] requested but the loop was not unrolled: no recognized induction variable (loop counter)
  --> src/main.rs:504:9

#[kernel]
fn k(n: u32) {
    let mut other = 0u32;
    #[unroll]                 // the warning points here
    for i in 0..=4u32 {       // inclusive range: not a recognized counter
        other += i;
    }
}

What we fixed

• The marker took Span::call_site(), the whole #[kernel] attribute, so neither the pass nor rustc had a useful position for anything about the loop.
• rustc's own const-eval note for a bad factor, #[unroll(Invalid::UNROLL)], pointed at #[kernel] with a macro-backtrace hint; it now points at the attribute.
• The five copies of the hint-unlink loop in the pass collapsed into one helper that also returns the position.
• Layered on while landing: the pliron 0.20 port (main moved in chore(cuda-oxide): upgrade Pliron to 0.20.0 #1533 after the branch was cut), and the const argument's braces kept on the macro's own span, because on the attribute span every literal #[unroll(N)] tripped rustc's unused_braces lint and failed the per-example clippy lane on four examples.

Warning contract

• The first line is unchanged: warning: #[unroll] requested but the loop was not unrolled: <reason>, or #[unroll(N)] for a partial request.
• The second line is --> file:line:column of the #[unroll] attribute, 1-based, with the path as rustc prints it for the crate.
• When the hint carries no single file position the second line is omitted.

Implementation

• cuda-macros: take_unroll_factor returns the factor together with attr.span(); marker_stmt builds the call with parse_quote_spanned! at that span and interpolates the braced factor with the macro's span. One visitor serves all three entry points.
• mir-importer: untouched. It already sets the hint op's Location from the call terminator's span, so the position is available without debug info.
• mir-transforms: hint_location reads Location::SrcPos { Source::File, pos } and returns None for every other variant; take_loop_hints unlinks a loop's hints and returns the first located one; not_unrolled_warning is the single text source for the seven emission sites.
• Tests: a span test over while, for and loop at different indents, two unit tests for a located and an unlocated hint, the updated trybuild snapshot, and a trybuild pass case under #![deny(unused_braces)] with literal factors.

Verification

Checked at fdcb34315 (nightly-2026-10-11, RTX 5090):

• ✅ cargo test -p cuda-macros --all-targets: the unit tests and every trybuild case pass, including the new span test, the new deny(unused_braces) pass case and the policy_config_invalid_unroll snapshot at the attribute (15:5).
• ✅ cargo test -p mir-transforms --all-targets: 35 unit tests, two of them new, plus the integration suites pass.
• ✅ cargo oxide run unroll_smoke on sm_120a: PASS; the four deliberate negatives print positions 249:13, 273:13, 504:9 and 508:9; zero unused_braces warnings; memcheck 0 errors.
• ✅ PTX against main: 22 of 22 kernel bodies identical; --lineinfo line tables identical.
• ✅ The per-example clippy gate is green on unroll_smoke, unroll_bounds_check, gemm_sol and gemm_sol_final; fmt, clippy and rustdoc with warnings as errors on both crates, the 18 guards, the lock check and the book build are clean.

Caveats

• The warning still reaches stderr from the pass rather than rustc's diagnostics: cargo does not replay it and -D warnings does not see it. Routing it like the launch-bounds spill warning is a follow-up.
• With --device-debug the goto that replaces the marker carries the attribute's line instead of the #[kernel] line; --lineinfo tables and PTX are unchanged. Follow-up.
• An annotated non-loop construct inside an annotated loop reports the outer attribute only, as before.

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[nihalpasham]

/ok to test fdcb343

[nihalpasham]

Thanks, the attribute is the right anchor and the pass only reads the location the importer already attaches. Three things on top before merging:

• Ported the location lookup to pliron 0.20, since main moved in chore(cuda-oxide): upgrade Pliron to 0.20.0 #1533 after this branch was cut.
• Kept the const argument's braces on the macro's own span. On the attribute span, rustc's unused_braces lint fired on every literal #[unroll(N)] and the per-example clippy lane failed on four examples. The call still carries the attribute span, so the warning position and the const-eval note are unchanged; a trybuild case under #![deny(unused_braces)] guards it.
• One sentence in the book: each warning names its attribute as file:line:column.

At fdcb34315, unroll_smoke passes on the 5090 with its four warnings at 249:13, 273:13, 504:9 and 508:9, all 22 kernels match main's PTX, memcheck is clean, and all CI checks passed. Two follow-ups, not part of this change: under --device-debug the goto that replaces the marker should take the artificial location the other markers use, and these warnings belong in rustc's diagnostics so cargo replays them.