rust/src/test/ui/dropck/drop-on-non-struct.rs

impl<'a> Drop for &'a mut isize {
    //~^ ERROR the Drop trait may only be implemented on structures
    //~^^ ERROR E0117
    fn drop(&mut self) {
        println!("kaboom");
    }
}

fn main() {
}
Update compile fail tests to use isize. 2015-01-08 04:54:35 -06:00			`impl<'a> Drop for &'a mut isize {`
Update error messages in compile-fail tests 2014-09-12 09:45:39 -05:00			`//~^ ERROR the Drop trait may only be implemented on structures`
Implement new orphan rule that requires that impls of remote traits meet the following two criteria: - the self type includes some local type; and, - type parameters in the self type must be constrained by a local type. A type parameter is called constrained if it appears in some type-parameter of a local type. Here are some examples that are accepted. In all of these examples, I assume that `Foo` is a trait defined in another crate. If `Foo` were defined in the local crate, then all the examples would be legal. - `impl Foo for LocalType` - `impl<T> Foo<T> for LocalType` -- T does not appear in Self, so it is OK - `impl<T> Foo<T> for LocalType<T>` -- T here is constrained by LocalType - `impl<T> Foo<T> for (LocalType<T>, T)` -- T here is constrained by LocalType Here are some illegal examples (again, these examples assume that `Foo` is not local to the current crate): - `impl Foo for int` -- the Self type is not local - `impl<T> Foo for T` -- T appears in Self unconstrained by a local type - `impl<T> Foo for (LocalType, T)` -- T appears in Self unconstrained by a local type This is a [breaking-change]. For the time being, you can opt out of the new rules by placing `#[old_orphan_check]` on the trait (and enabling the feature gate where the trait is defined). Longer term, you should restructure your traits to avoid the problem. Usually this means changing the order of parameters so that the "central" type parameter is in the `Self` position. As an example of that refactoring, consider the `BorrowFrom` trait: ```rust pub trait BorrowFrom<Sized? Owned> for Sized? { fn borrow_from(owned: &Owned) -> &Self; } ``` As defined, this trait is commonly implemented for custom pointer types, such as `Arc`. Those impls follow the pattern: ```rust impl<T> BorrowFrom<Arc<T>> for T {...} ``` Unfortunately, this impl is illegal because the self type `T` is not local to the current crate. Therefore, we are going to change the order of the parameters, so that `BorrowFrom` becomes `Borrow`: ```rust pub trait Borrow<Sized? Borrowed> for Sized? { fn borrow_from(owned: &Self) -> &Borrowed; } ``` Now the `Arc` impl is written: ```rust impl<T> Borrow<T> for Arc<T> { ... } ``` This impl is legal because the self type (`Arc<T>`) is local. 2015-01-04 19:35:06 -06:00			`//~^^ ERROR E0117`
switch Drop to `&mut self` 2013-09-16 20:18:07 -05:00			`fn drop(&mut self) {`
Remove re-exports of std::io::stdio::{print, println} in the prelude. The `print!` and `println!` macros are now the preferred method of printing, and so there is no reason to export the `stdio` functions in the prelude. The functions have also been replaced by their macro counterparts in the tutorial and other documentation so that newcomers don't get confused about what they should be using. 2014-01-09 04:06:55 -06:00			`println!("kaboom");`
rustc: Implement the Drop trait. r=brson 2012-11-05 19:50:01 -06:00			`}`
			`}`

			`fn main() {`
			`}`