rustc: strange failure with lifetime bounds forcing explicit re-borrowing

[aturon]

Now that DST has landed, I've been working on refactoring various library code to take advantage of it. I tried to remove some of the extension traits currently used in core::any, but ran into a strange error for downcase_mut that was solved by explicitly reborrowing the receiver:

/// The `Any` trait is implemented by all `'static` types, and can be used for
/// dynamic typing
///
/// Every type with no non-`'static` references implements `Any`, so `Any` can
/// be used as a trait object to emulate the effects dynamic typing.
#[stable]
pub trait Any: AnyPrivate {
    /// Returns true if the boxed type is the same as `T`
    #[inline]
    #[stable]
    fn is<T: 'static>(&self) -> bool {
        // Get TypeId of the type this function is instantiated with
        let t = TypeId::of::<T>();

        // Get TypeId of the type in the trait object
        let boxed = self.get_type_id();

        // Compare both TypeIds on equality
        t == boxed
    }

    /// Returns some reference to the boxed value if it is of type `T`, or
    /// `None` if it isn't.
    #[inline]
    #[unstable = "naming conventions around acquiring references may change"]
    fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        if self.is::<T>() {
            unsafe {
                // Get the raw representation of the trait object
                let to: TraitObject = transmute_copy(&self);

                // Extract the data pointer
                Some(transmute(to.data))
            }
        } else {
            None
        }
    }

    /// Returns some mutable reference to the boxed value if it is of type `T`, or
    /// `None` if it isn't.
    #[inline]
    #[unstable = "naming conventions around acquiring references may change"]
    fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T> {
        // The following fails with: 
        //    error: instantiating a type parameter with an incompatible type `&mut Self`, 
        //    which does not fulfill `'static`
        // if self.is::<T>() {

        // Explicitly reborrowing seems to work:
        if (&*self).is::<T>() {
            unsafe {
                // Get the raw representation of the trait object
                let to: TraitObject = transmute_copy(&self);

                // Extract the data pointer
                Some(transmute(to.data))
            }
        } else {
            None
        }
    }

    /// Returns some reference to the boxed value if it is of type `T`, or
    /// `None` if it isn't.
    #[deprecated = "this function has been renamed to `downcast_ref`"]
    fn as_ref<T: 'static>(&self) -> Option<&T> {
        self.downcast_ref::<T>()
    }

    /// Returns some mutable reference to the boxed value if it is of type `T`, or
    /// `None` if it isn't.
    #[deprecated = "this function has been renamed to `downcast_mut`"]
    fn as_mut<T: 'static>(&mut self) -> Option<&mut T> {
        self.downcast_mut::<T>()
    }
}

/// An inner trait to ensure that only this module can call `get_type_id()`.
trait AnyPrivate {
    /// Get the `TypeId` of `self`
    fn get_type_id(&self) -> TypeId;
}

impl<T: 'static> AnyPrivate for T {
    fn get_type_id(&self) -> TypeId { TypeId::of::<T>() }
}

impl<T: 'static + AnyPrivate> Any for T {}

cc @nikomatsakis

[aturon]

FWIW, I've since realized that the extension traits are needed anyway; our analysis during library stabilization that they could go away with DST was incorrect. But this still seems like a buggy interaction between re-borrowing and lifetime bounds.

[nikomatsakis]

On Fri, Aug 29, 2014 at 03:16:15PM -0700, Aaron Turon wrote:

Now that DST has landed, I've been working on refactoring various library code to take advantage of it. I tried to remove some of the extension traits currently used in core::any, but ran into a strange error for downcase_mut that was solved by explicitly reborrowing the receiver:

If I had to guess, I would think that you are being bitten by the
usual problems that plague any trait implemented for all types. That
is, we prefer to auto-ref once than to auto-deref once. I still want
to investigate a move to auto-ref only at the end. Thanks for
reminding me.

[steveklabnik]

Another old ticket that's too in-the-weeds for me to properly evaluate it. @nikomatsakis @aturon how do you feel about this today?

[Mark-Simulacrum]

The original test case still reproduces. I've attempted to minify. It looks like @nikomatsakis thought this might just be a symptom of auto-ref being preferred to auto-deref; is this a bug in and of itself?

pub trait Any {
    fn a(&self) {}

    fn b(&mut self) {
        // Fails
        self.a();

        // Works
        (*self).a();
    }
}

impl<T: 'static> Any for T {}

fn main() {}

error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
 --> test.rs:6:14
  |
6 |         self.a();
  |              ^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the body at 4:20...
 --> test.rs:4:21
  |
4 |       fn b(&mut self) {
  |  _____________________^
5 | |         // Fails
6 | |         self.a();
7 | |
8 | |         // Works
9 | |         (*self).a();
10| |     }
  | |_____^
note: ...so that types are compatible (expected &&mut Self, found &&mut Self)
 --> test.rs:6:14
  |
6 |         self.a();
  |              ^
  = note: but, the lifetime must be valid for the static lifetime...
note: ...so that the type `&mut Self` will meet its required lifetime bounds
 --> test.rs:6:14
  |
6 |         self.a();
  |              ^

error: aborting due to previous error

[nikomatsakis]

@Mark-Simulacrum yeah seems like we should just close. We're not changing this behavior now.