Non-deterministic call ordering in downstream crates

Open
  • Is something wrong?
#4,149 3 comments 0 reactions 1 assignee View on GitHub

Maintainers usually reply within 1 day

@robjtede is already working on this.

Since Sep 25, 2026.

Assessment

Difficulty
4/5
Estimated time
3-5 days
Newbie friendliness
45/100
Issue type
Bug
Clarity
Mostly clear
Activity status
Active
Tech stack
rust
Domain
api, backend

Research direction

The issue is about non-deterministic call ordering in compiled output affecting downstream crates. Look at the guard methods (Get, Post) in actix_web::guard and how they are used in resource definitions. The diffoscope output shows swapped calls. Investigate the code generation or macro expansion that leads to this ordering. Reproducing requires building a downstream crate multiple times and comparing assembly. The fix likely involves ensuring deterministic ordering in macro or code generation.

Written by the indexing model from the issue text.

Description

A-web-codegen needs-investigation

https://github.com/actix/actix-web/pull/4090 was closed as slop. Unfortunately, it fixed a real issue in that crates using some actix-web methods, when compiled, can have a different call ordering in the output. Example diffoscope output:

│ │ ├── objdump --line-numbers --disassemble --demangle --reloc --no-show-raw-insn --section=.text {}
│ │ │ @@ -4507744,21 +4507744,21 @@
│ │ │   lea    0x158(%rsp),%rdi
│ │ │   lea    0x200(%rsp),%rsi
│ │ │   lea    -0x1d7c588(%rip),%rdx        
│ │ │   mov    $0x14,%ecx
│ │ │   call   1fbcf40 <<actix_web::resource::Resource>::name>
│ │ │   movb   $0x1,0x3b7(%rsp)
│ │ │   lea    0x2d8(%rsp),%rdi
│ │ │ + call   2021a20 <actix_web::guard::Get>
│ │ │ - call   2021a80 <actix_web::guard::Post>
│ │ │   lea    0x2c0(%rsp),%rdi
│ │ │   lea    0x2d8(%rsp),%rsi
│ │ │   call   109e510 <actix_web::guard::Any::<actix_web::guard::MethodGuard>>
│ │ │   movb   $0x1,0x3b6(%rsp)
│ │ │   lea    0x2f0(%rsp),%rdi
│ │ │ + call   2021a80 <actix_web::guard::Post>
│ │ │ - call   2021a20 <actix_web::guard::Get>
│ │ │   movb   $0x0,0x3b6(%rsp)
│ │ │   lea    0x2a8(%rsp),%rdi
│ │ │   lea    0x2c0(%rsp),%rsi
│ │ │   lea    0x2f0(%rsp),%rdx
│ │ │   call   f30190 <<actix_web::guard::AnyGuard>::or::<actix_web::guard::MethodGuard>>
│ │ │   movb   $0x0,0x3b6(%rsp)
│ │ │   movb   $0x0,0x3b7(%rsp)

Expected Behavior

Downstream crates should have deterministic call ordering.

Current Behavior

Downstream crates can have re-ordered calls between different builds.

Possible Solution

I'm not a rust developer, so I can't speak to the quality of the slop solution. However, some kind of deterministic ordering for these methods does appear to fix downstream build reproducibility problems. I will consult with an actual rust developer on our team to see if there's a better solution, and will propose a PR with a hand-written comment explaining the need.

Steps to Reproduce (for bugs)

The original reproducer in the slop PR seems to match what we're doing in our non-public code.

Context

Some distros are moving towards enforcing build reproducibility: https://lwn.net/Articles/1072314/

Your Environment

  • Rust Version (I.e, output of rustc -V): rustc 1.95.0 (59807616e 2026-04-14)
  • Actix Web Version: 4.9.0
Dominant language
Rust
Stars
24.9k
Forks
2k
Avg merge
19h 9m
Merged PRs (30d)
61

Getting set up

First steps

  1. Read the whole issue, then the project's contributing guide.
  2. Comment on the issue to say you are picking it up — it saves two people doing the same work.
  3. Fork the repository and make your change on a branch.
  4. Open a pull request that references the issue number.

More from actix/actix-web

All issues in actix/actix-web

Similar issues

More Rust issues

Get new issues in your inbox

A short digest of beginner-friendly GitHub issues.