[niklebedenko]

Closes #213.

Problem

translate_call special-cases closure trait calls because rust-call ABI passes arguments as a tuple while the closure body expects unpacked arguments. The old predicate looked for names containing call_once, call_mut, or ending in ::call, and then checked whether any generic substitution text contained Closure.

That is too broad. A normal wrapper method named call can have a closure as a generic parameter while still expecting its tuple argument as one ordinary method argument. On upstream/main with only the regression applied, ClosureWrapper<F>::call(&self, (u32,)) is misclassified and LLVM verification fails:

Function call has incorrect type:
expected llvm.func <builtin.integer i32(llvm.ptr (0), llvm.struct <{ builtin.integer i32 }>) variadic = false>,
got llvm.func <builtin.integer i32(llvm.ptr (0), builtin.integer i32) variadic = false>

Fix

Require the rust-call receiver to actually be a closure before using translate_closure_call.

The new receiver_is_closure helper inspects the first call operand, resolves its MIR local or constant type, unwraps references, and matches RigidTy::Closure. If the receiver is an ordinary ADT such as ClosureWrapper<F>, the call stays on the normal call-lowering path and keeps its tuple argument intact.

Diligence

I checked the sibling closure-call paths:

• translate_closure_call still handles the genuine closure trait ABI path, including by-value call_once and by-reference call / call_mut receivers.
• extract_closure_body_name already requires the receiver operand to be a closure or reference-to-closure before resolving a closure body.
• the collector has a name-based closure discovery heuristic, but it only adds closure bodies to the collection when a type argument is itself a closure; it does not rewrite call operands or unpack tuples.

The initial wrapper regression used #[inline(always)], which let rustc optimize the wrapper method away before import. The committed regression uses #[inline(never)] so the importer must classify the ordinary wrapper call.

Tests

Extended crates/rustc-codegen-cuda/examples/device_closures with:

• ClosureWrapper<F>, where F: Fn(u32) -> u32;
• an out-of-line ClosureWrapper::call(&self, (u32,)) -> u32;
• test_wrapper_method_named_call, which stores a captured closure in the wrapper and calls the wrapper method from a kernel.

The existing device closure tests still exercise genuine closure calls, including closure trait calls through FnOnce.

Validation

Verified the regression fails on upstream/main by applying only the example change and running:

CUDA_OXIDE_SHOW_RUSTC_MIR=1 cargo oxide run device_closures

Verified the patched branch with:

cargo fmt --all -- --check
cargo check -p mir-importer
cargo clippy -p mir-importer -- -D warnings
(cd crates/rustc-codegen-cuda/examples/device_closures && cargo fmt --all -- --check)
(cd crates/rustc-codegen-cuda/examples/device_closures && cargo clippy --all-targets -- -D warnings)
(cd crates/rustc-codegen-cuda && cargo fmt --all -- --check)
(cd crates/rustc-codegen-cuda && cargo clippy --all-targets -- -D warnings)
scripts/smoketest.sh --compile-only --no-color --only '^device_closures$'
cargo oxide run device_closures
scripts/smoketest.sh --no-color --only '^device_closures$'

[niklebedenko]

Hey @nihalpasham, sorry to land a whole batch on you at once today (#181–#214). Quick map to make triage easier:

• mir-importer lowering fixes:
  • fix(mir-importer): lower array constants #183
  • fix(mir-importer): lower copy_nonoverlapping to memcpy #196
  • fix(mir-importer): lower nested index assignments #199
  • mir-importer: support pointer distance intrinsics #206
  • mir-importer: preserve volatile load and store intrinsics #208
  • mir-importer: index slice data pointers by element #210
  • mir-importer: read closure upvars from generic suffix #212
  • mir-importer: require closure receiver for rust-call lowering #214
• cuda-core:
  • feat(cuda-core): derive DeviceCopy #193
  • cuda-core: add safe DeviceCopy parity impls #202
  • cuda-core: restore DeviceBuffer async methods #204
• pipeline:
  • fix(pipeline): create output_dir before emission #181
  • fix(pipeline): preserve inline always #189
• misc:
  • codegen fix(codegen): align export and call names #185
  • intrinsics fix(intrinsics): lower fast float ops #187
  • cuda-device, bf16x2 FMA feat(cuda-device): add bf16x2 FMA intrinsic #191

They should all be independent, merge or close in whatever order suits you, no rush on any. The mir-importer ones touch the same area, so if they conflict on the way in, ping me and I'll be happy to rebase (or ofc feel free to edit the branch yourself if that's easier). I'm hitting these bugs because I'm leaning on the compiler hard in real use on my own (fairly large) project, so I expect I'll keep finding fixes.

Really enjoying putting the compiler through its paces, and glad to shape how I contribute around whatever's easiest for you!

[nihalpasham]

Thanks for these. Just a heads-up. I'll need some time to review these as I am working through a couple of large ticket items.

[nihalpasham]

LGTM.

• Layered: a comment on why receiver_is_closure may ignore place.projection or peel one ref, plus projection-receiver and double-ref closure kernels (both still unpack the tuple).
• cargo oxide run device_closures --arch sm_90 → all tests pass, incl. the two new ones