Nightly support for function overloading in FFI bindings

[tomassedovic]

Metadata
Point of contact	@teor2345
Team(s)	compiler, lang, libs-api, types
Goal document	2026/overloading-for-ffi

Summary

Design and implement a function overloading system that is suitable for FFI with languages that have overloading. In particular, we aim to make Rust more compatible with C++, so that Rust callers do not place a maintenance burden on C++ library owners due to overloading.

Tasks and status

[tomassedovic]

This issue is intended for status updates only.

For general questions or comments, please contact the owner(s) directly.

[teor2345]

Key developments: What has happened since the last time.

I've picked up the point of contact on this goal, because I'm actively working on it (along with an Outreachy intern and various reviewers).

Since March, here's what's happened for FFI overloading:

• identified overloading as a high priority missing feature in the interop problem space mapping project goal
• significant design discussions on Zulip and the Rust internals forums
• started work on the "splat" Rust language experiment, which can be used to implement overloading via tuple traits
  • we have a working implementation of basic function argument splatting, which passes an "overloading at home" UI test
  • I'm splitting that PR up into smaller chunks, to make reviews and rebases easier, we're currently at roughly 4/8 chunks merged
  • our Outreachy intern Ajay has already found and fixed a bug, and added some tests for overloading
• I talked a little bit about overloading in my talk at RustWeek, an interop workshop at the All Hands, and an interview with the Rust content team

Blockers: List any Rust teams you are waiting on and what you are waiting for.

None right now, just working through the standard PR review process and timeline (including rebases)

Help wanted: Are there places where you are looking for contribution or feedback from the broader community?

Next steps are:

1. continuing to get the initial overloading lang experiment PR merged
   • including tests, bug fixes, and filling in missing functionality
2. implement a macro that turns a set of overloaded functions into the splat-based trait set supported by the experimental feature
3. talking to interop tools to see if they want to experiment with overloading support
4. experimenting with splat to see if it supports typical C++ overloads (or other languages if people are interested!)

There might be some steps missing here, discovering them is part of the experiment. For example, the current feature PR might be missing necessary functionality for the macro, for interop tools, or for typical overload sets.

[teor2345]

Key developments: What has happened since the last time.

In the last few weeks, here's what's happened for FFI overloading:

• finished the initial implementation of the "splat" Rust language experiment, which can be used to implement overloading via tuple traits
  • our Outreachy intern Ajay has added multiple tests for overloading
  • I fixed a perf issue by limiting splatting to the first 255 arguments
    • the splatted argument index can be moved to a side-table later, or the feature might be redesigned to avoid it entirely
  • Oli reviewed and approved the PR, so we're just waiting for the merge queue before it is available in nightly
• the feature is still incomplete! Expect bugs, poor diagnostics, and missing support for some language constructs

Blockers: List any Rust teams you are waiting on and what you are waiting for.

None right now, just waiting for the merge queue.
I expect that the PR before it will conflict with its rollup, and I'll have to merge some changes manually.

Help wanted: Are there places where you are looking for contribution or feedback from the broader community?

Next steps are:

1. filling in missing compiler splat functionality and diagnostics
2. implement a macro that turns a set of overloaded functions into the splat-based trait set supported by the experimental feature
   • Ajay is currently looking into this
3. talking to interop tools to see if they want to experiment with overloading support
4. experimenting with splat to see if it supports typical C++ overloads (or other languages if people are interested!)

There might be some steps missing here, discovering them is part of the experiment. For example, the current feature PR might be missing necessary functionality for the macro, for interop tools, or for typical overload sets.

[teor2345]

Splat is now available on the Rust playground on nightly:

#![feature(splat, tuple_trait)]
#![expect(incomplete_features)]

use std::marker::Tuple;

struct Foo;

trait MethodArgs: Tuple {
    fn call_method(self, this: &Foo);
}

impl Foo {
    fn method(&self, #[splat] args: impl MethodArgs) { args.call_method(self) }
}

impl MethodArgs for (i32, String) {
    fn call_method(self, _this: &Foo) { dbg!(self.1, self.0); }
}

impl MethodArgs for (f64,) {
    fn call_method(self, _this: &Foo) { dbg!(self.0); }
}

fn main() {
    let foo = Foo;
    foo.method(42, "hello splat".to_string());
    foo.method(3.141);
}

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=0e41d1955b6bd53528a660fa38e42afa

Output:

[src/main.rs:17:41] self.1 = "hello splat"
[src/main.rs:17:41] self.0 = 42
[src/main.rs:21:41] self.0 = 3.141