support `default impl` for specialization

[nikomatsakis]

View all comments

Update 2026-08-06

Some tests were added in #160520, but this issue needs review for completeness.

---

rust-lang/rfcs#1210 included support for default impl, which declared a set of defaults that other impls can inherit (if they correspond to a subset of the default impl's types). This was intended as a replacement/improvement of the existing default methods that appear in trait bodies (it was also originally called partial impl). Unfortunately, this feature is not yet implemented!

Some things to be sure of:

• a default impl need not include all items from the trait
• a default impl alone does not mean that a type implements the trait
• all items in a default impl are (implicitly) default and hence specializable

cc #31844

[nikomatsakis]

cc @giannicic @aturon

[giannicic]

@nikomatsakis
the PR addressing the 3rd task list item has been merged.
Now i'm working on the first two points.

[nikomatsakis]

@giannicic awesome!

[Phlosioneer]

Any progress on this?

[giannicic]

@Phlosioneer
Yes, the first point is done. Currently I'm working on the second one.
I've looked at the trait resolution and identified where to place the default impl trait implementation check, now I'm figuring out how to properly implement this check because i need to differentiate it based on the cause of the obligation.
For example, if i have a default impl that doesn't implement all the methods of the trait Foo, like the following

trait Foo {
    fn foo_one(&self) -> &'static str;
    fn foo_two(&self) -> &'static str;
}

default impl<T> Foo for T {
    fn foo_one(&self) -> &'static str {
        "generic"
    }
}

struct MyStruct;

a call like MyStruct.foo_one() should pass the trait resolution because of the first point.
Instead if i call foo(MyStruct) with foo like fn foo<T: Foo>(x: T) -> &'static str the trait resolution should fail because of the second point.
It could pass if the default impl implements all the methods of the Trait

[petrochenkov]

Can inherent impls be default?

This currently compiles successfully, but the compiler has zero tests for it, so it's probably unintended.

#![feature(specialization)]

struct S;

default impl S {}

fn main() {}

The general idea is reasonable though, e.g.

struct S<T>(T);

default impl<T> S<T> { fn f() { println!("Hello world!") } }
impl S<u8> { fn f() { println!("Goodbye world!") } } // This currently errors

[petrochenkov]

Can auto trait impls (including negative ones) be default?

This is currently accepted:

struct S;
struct Z;
default unsafe impl Send for S {}
default impl !Send for Z {}

[petrochenkov]

#46455 conservatively makes both #37653 (comment) and #37653 (comment) errors.

[Restioson]

Really excited for full support of specialization (esp. point 2)! +1