rustdoc-json: show leaked auto-trait definition for RPIT and async-fn

[aDotInTheVoid]

Currently, these two functions have the same type signature in rustdoc-json:

pub fn foo() -> impl Debug {
    0i32
}

pub fn bar() -> impl Debug {
    Cell::new(10)
}

 {
  "inputs": [],
  "is_c_variadic": false,
  "output": {
    "impl_trait": [
      {
        "trait_bound": {
          "generic_params": [],
          "modifier": "none",
          "trait": {"args": null, "id": 1, "path": "Debug"}
        }
      }
    ]
  }
}

However, in practice, they are different types:

pub fn foo() -> impl Debug {
    0i32
}

pub fn bar() -> impl Debug {
    Cell::new(10)
}

pub fn check_sync<T: Sync>(_: T) {}

fn main() {
    check_sync(foo()); // Ok
    check_sync(bar()); // Errors
}

playground

This is because impl-trait's in return position implement the auto-traits of the underling type:

The type would not be known to implement any other trait, with the exception of OIBITS (aka “auto traits”) and default traits like Sized.

-- RFC 1522: conservative_impl_trait

A similar behavior occurs for the auto-traits of the opaque Future type returned by async fn's:

pub async fn foo() -> i32 {
    0
}

pub async fn bar() -> i32 {
    let x = Cell::new(10);
    foo().await;
    x.get()
}

pub fn check_sync<T: Sync>(_: T) {}

fn main() {
    check_sync(foo()); // Ok
    check_sync(bar()); // Errors
}

playground

Again, there's information about the type of this function that rustdoc-json doesn't currently capture.

---

It'd be nice to capture this in rustdoc-json. The motivating use case comes from cargo-semver-checks, which would like to be able to warn users if their RPIT's (or async-fn futures) are no longer Send/Sync when they used to be.

---

I think doing this is going to be difficult to implement, as it requires being able to run the typechecker, which rustdoc currently doesn't do: https://hackmd.io/@fhcjVaPtST635ujGv6RF4w/SkulRNn93. Maybe we could seperatly land that for JSON before HTML, as JSON isn't stable.

[aDotInTheVoid]

Difficult case here

async fn foo() -> impl Debug {
    Cell::new(10)
}

async fn checking() {
    // // Ok, the `impl Future` in an async fn is `impl Future + Sync` here.
    check_sync(foo());
    
    // Err, the `impl Debug` isn't `impl Debug + Sync`.
    check_sync(foo().await);
}

[fmease]

You might already be fully aware of this but just to have it written down somewhere, regarding the concrete representation, it wouldn't be as simple as adding a list of leaked auto traits in the relevant places (like ["Sync"] for your first example which contains the -> impl Debug).

E.g., given the following

fn make<T>(x: T) -> impl Sized { x }

it would obviously neither be -> impl Sized + Send nor (pseudo) "-> impl Sized + ?Send". It would be (pseudo):

unsafe impl<T: Send> Send for make::<T>::{opaque#0} {}

Or for this more complex case

fn produce<T>(x: T) -> impl Sized { Wrap(x) }

struct Wrap<T>(T);

it would be (pseudo)

unsafe impl<T> Send for produce::<T>::{opaque#0}
where
    Wrap<T>: Send
{}

Note: Wrap<T>: Send isn't equivalent to T: Send. Consider the full code:

fn produce<T>(x: T) -> impl Sized { Wrap(x) }

struct Wrap<T>(T);
unsafe impl<T: Copy> Send for Wrap<T> {} // XXX

fn check(_: impl Send) {}

fn main() {
     // `Wrap<*const ()>` impls `Send` even though `*const ()` is `!Send`
     // because `*const ()` is `Copy`, so the impl I've marked XXX applies.
     let local = ();
     check(produce(&raw const local)); // OK
}

[fmease]

So to reiterate, the representation of "leaked auto traits" can't be a simple list of bounds it needs to be isomorphic to / as general as the pseudo impls I gave above.

These pseudo auto impls are basically just synthetic auto trait impls that we already have today except that they'd be for opaque types not for ADTs.