Currently, the default implementations of methods in crate_interface traits cause some inconsistencies. They:

• Can be called by other default implementations.
• Can be called by the type implementing crate_interface traits.
• Can be ignored when implementing crate_interface traits.
• Can NOT be called by call_interface!.

It's frustrating in at least two ways: ignoring methods with default implementations in #[impl_interface] causes no compiler error, while calling them with call_interface! causes link-time errors (instead of calling the default implementations). It violates the principle of least surprise. Take the following snippet as an example:

#[def_interface]
pub trait If {
    fn a() -> i32 { 42 }
    fn b() -> i32 { Self::a() + 1 } // <- If::a can be used here
    fn c() -> i32;
}

pub struct Impl;

#[impl_interface]
impl If for Impl {
    // <- If::a can be ignored here without any compiler error
    fn b() -> i32 { 998244353 }
    fn c() -> i32 { Self::a() + 2 } // <- If::a can be used here
}

#[test]
fn caller() {
    assert_eq!(<Impl as If>::a(), 42); // <- If::a can be used directly via the implementor type
    assert_eq!(<Impl as If>::b(), 998244353);
    assert_eq!(<Impl as If>::c(), 44);

    assert_eq!(call_interface!(If::a), 42); // <- If::a CAN NOT be used here, link-time error
    assert_eq!(call_interface!(If::b), 998244353);
    assert_eq!(call_interface!(If::c), 44);
}

Also, providing default implementations for some crate_interface methods is extremely useful, especially when designing and implementing BSPs.

It's possible to use weak symbols as a solution: the default implementations are wrapped and exported in functions with same signature as the expected implementor and marked as #[linkage = "weak"], allowing the use of them with call_interface!, while implementations in #[impl_interface] blocks can safely override them. For backward compatibility, this feature is gated by the "weak_default" feature.

Possible drawbacks:

• Required nightly rust and manual enablement of linkage , until Tracking issue for the linkage feature rust-lang/rust#29603 is stabilized.
• Weak symbols cannot co-exist with strong symbols under the same name in the same Rust crate. As a result, it's impossible to override the default implementation when implementing the crate_interface trait in the same crate where it's defined. It seems OK for real-world scenarios, but makes tests a little bit more complex.

Possible improvements and fixes that can be shipped with this PR:

• Use sub-attributes to explicitly mark which default implementations should be exported.
• Disable all self-like receivers in all crate_interface methods.