Pointer implementation for Rc and Arc should print the address of pointed value

[malbarbo]

Consider this example:

#![feature(shared, unique)]

use std::ptr::{Shared, Unique};
use std::rc::Rc;
use std::sync::Arc;

fn main() {
    let x = Box::new(10);
    assert_eq!(format!("{:p}", &*x), format!("{:p}", x));

    let a = &mut 10 as *mut _;
    let x = Shared::new(a).unwrap();
    assert_eq!(format!("{:p}", a), format!("{:p}", x));

    let a = &mut 10 as *mut _;
    let x = Unique::new(a).unwrap();
    assert_eq!(format!("{:p}", a), format!("{:p}", x));

    let x = Rc::new(10);
    println!("rc {:p} {:p}", &*x, x);

    let x = Arc::new(10);
    println!("arc {:p} {:p}", &*x, x);
}

the code runs fine but the printed values are different:

rc 0x7f1eefa1e070 0x7f1eefa1e060
arc 0x7f1eefa1e0d0 0x7f1eefa1e0c0

The Pointer implementation for Rc and Arc prints the address of the inner data (RcBox and ArcInner) instead of the address of the stored value. This seems to be inconsistent with the Pointer implementation for Box, Shared and Unique.

If this is a real issue, I can write a patch to fix it.

[apasel422]

It's sort of inconsistent, but also sort of consistent. {Box, Shared, Unique} don't have inner data, so the only thing they could point to is the value.

[cyplo]

The example code from OP does not seem to compile now with rustc 1.22.0-nightly (692b94a 2017-10-09) (anymore?). Would that be something that is expected ?

The error:

error[E0277]: the trait bound `std::option::Option<std::ptr::Shared<_>>: std::fmt::Pointer` is not satisfied
  --> main.rs:13:52
   |
13 |     assert_eq!(format!("{:p}", a), format!("{:p}", x));
   |                                                    ^ the trait `std::fmt::Pointer` is not implemented for `std::option::Option<std::ptr::Shared<_>>`
   |
   = note: required by `std::fmt::Pointer::fmt`

[sinkuu]

@cyplo Yes, #42959

[dtolnay]

I would like a PR to fix this. Whether the strong and weak counts are stored before or after T in memory seems like an implementation detail, and the address of T seems to me a more intuitive behavior for {:p}.