---

yaml
---
r: 195571
b: refs/heads/master
c: 4b6248a
h: refs/heads/master
i:
  195569: e3a0107
  195567: 739d953
v: v3

Author: frewsxcv

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 2159bbf6506c04e06b73f0e45dcf4e92f1ffa1ac
+refs/heads/master: 4b6248a80658ec2e3b1552441f57ebc4b1f06448
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b3317d68910900f135f9f38e43a7a699bc736b4a
 refs/heads/try: 961e0358e1a5c0faaef606e31e9965742c1643bf

trunk/src/liballoc/arc.rs

@@ -242,38 +242,6 @@ pub fn weak_count<T>(this: &Arc<T>) -> usize { this.inner().weak.load(SeqCst) -
 #[unstable(feature = "alloc")]
 pub fn strong_count<T>(this: &Arc<T>) -> usize { this.inner().strong.load(SeqCst) }
 
-
-/// Try accessing a mutable reference to the contents behind an unique `Arc<T>`.
-///
-/// The access is granted only if this is the only reference to the object.
-/// Otherwise, `None` is returned.
-///
-/// # Examples
-///
-/// ```
-/// # #![feature(alloc)]
-/// use std::alloc::arc;
-///
-/// let mut four = arc::Arc::new(4);
-///
-/// arc::unique(&mut four).map(|num| *num = 5);
-/// ```
-#[inline]
-#[unstable(feature = "alloc")]
-pub fn unique<T>(this: &mut Arc<T>) -> Option<&mut T> {
-    if strong_count(this) == 1 && weak_count(this) == 0 {
-        // This unsafety is ok because we're guaranteed that the pointer
-        // returned is the *only* pointer that will ever be returned to T. Our
-        // reference count is guaranteed to be 1 at this point, and we required
-        // the Arc itself to be `mut`, so we're returning the only possible
-        // reference to the inner data.
-        let inner = unsafe { &mut **this._ptr };
-        Some(&mut inner.data)
-    }else {
-        None
-    }
-}
-
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> Clone for Arc<T> {
     /// Makes a clone of the `Arc<T>`.
@@ -344,8 +312,11 @@ impl<T: Send + Sync + Clone> Arc<T> {
            self.inner().weak.load(SeqCst) != 1 {
             *self = Arc::new((**self).clone())
         }
-        // As with `unique()`, the unsafety is ok because our reference was
-        // either unique to begin with, or became one upon cloning the contents.
+        // This unsafety is ok because we're guaranteed that the pointer
+        // returned is the *only* pointer that will ever be returned to T. Our
+        // reference count is guaranteed to be 1 at this point, and we required
+        // the Arc itself to be `mut`, so we're returning the only possible
+        // reference to the inner data.
         let inner = unsafe { &mut **self._ptr };
         &mut inner.data
     }
@@ -688,7 +659,7 @@ mod tests {
     use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use std::thread;
     use std::vec::Vec;
-    use super::{Arc, Weak, weak_count, strong_count, unique};
+    use super::{Arc, Weak, weak_count, strong_count};
     use std::sync::Mutex;
 
     struct Canary(*mut atomic::AtomicUsize);
@@ -724,21 +695,6 @@ mod tests {
         assert_eq!((*arc_v)[4], 5);
     }
 
-    #[test]
-    fn test_arc_unique() {
-        let mut x = Arc::new(10);
-        assert!(unique(&mut x).is_some());
-        {
-            let y = x.clone();
-            assert!(unique(&mut x).is_none());
-        }
-        {
-            let z = x.downgrade();
-            assert!(unique(&mut x).is_none());
-        }
-        assert!(unique(&mut x).is_some());
-    }
-
     #[test]
     fn test_cowarc_clone_make_unique() {
         let mut cow0 = Arc::new(75);

trunk/src/liballoc/boxed.rs

@@ -86,7 +86,6 @@ pub static HEAP: () = ();
 /// See the [module-level documentation](../../std/boxed/index.html) for more.
 #[lang = "owned_box"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[fundamental]
 pub struct Box<T>(Unique<T>);
 
 impl<T> Box<T> {
@@ -278,6 +277,13 @@ impl<T: fmt::Debug + ?Sized> fmt::Debug for Box<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl fmt::Debug for Box<Any> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.pad("Box<Any>")
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: ?Sized> Deref for Box<T> {
     type Target = T;

trunk/src/liballoc/boxed_test.rs

@@ -55,17 +55,17 @@ fn test_show() {
     let b = Box::new(Test) as Box<Any>;
     let a_str = format!("{:?}", a);
     let b_str = format!("{:?}", b);
-    assert_eq!(a_str, "Any");
-    assert_eq!(b_str, "Any");
+    assert_eq!(a_str, "Box<Any>");
+    assert_eq!(b_str, "Box<Any>");
 
     static EIGHT: usize = 8;
     static TEST: Test = Test;
     let a = &EIGHT as &Any;
     let b = &TEST as &Any;
     let s = format!("{:?}", a);
-    assert_eq!(s, "Any");
+    assert_eq!(s, "&Any");
     let s = format!("{:?}", b);
-    assert_eq!(s, "Any");
+    assert_eq!(s, "&Any");
 }
 
 #[test]

trunk/src/liballoc/lib.rs

@@ -71,8 +71,6 @@
 #![feature(no_std)]
 #![no_std]
 #![feature(allocator)]
-#![feature(custom_attribute)]
-#![feature(fundamental)]
 #![feature(lang_items, unsafe_destructor)]
 #![feature(box_syntax)]
 #![feature(optin_builtin_traits)]

trunk/src/libcore/any.rs

@@ -71,7 +71,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use fmt;
 use marker::Send;
 use mem::transmute;
 use option::Option::{self, Some, None};
@@ -106,13 +105,6 @@ impl<T> Any for T
 // Extension methods for Any trait objects.
 ///////////////////////////////////////////////////////////////////////////////
 
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for Any {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("Any")
-    }
-}
-
 impl Any {
     /// Returns true if the boxed type is the same as `T`
     #[stable(feature = "rust1", since = "1.0.0")]

trunk/src/libcore/fmt/mod.rs

@@ -12,6 +12,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use any;
 use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
 use char::CharExt;
 use iter::Iterator;
@@ -996,6 +997,11 @@ macro_rules! tuple {
 
 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<'a> Debug for &'a (any::Any+'a) {
+    fn fmt(&self, f: &mut Formatter) -> Result { f.pad("&Any") }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Debug> Debug for [T] {
     fn fmt(&self, f: &mut Formatter) -> Result {

trunk/src/libcore/iter.rs

@@ -45,10 +45,8 @@
 //! let mut it = values.into_iter();
 //! loop {
 //!     match it.next() {
-//!         Some(x) => {
-//!             println!("{}", x);
-//!         }
-//!         None => { break }
+//!         Some(x) => println!("{}", x),
+//!         None => break,
 //!     }
 //! }
 //! ```

trunk/src/libcore/lib.rs

@@ -70,10 +70,8 @@
 #![feature(unboxed_closures)]
 #![feature(rustc_attrs)]
 #![feature(optin_builtin_traits)]
-#![feature(fundamental)]
 #![feature(concat_idents)]
 #![feature(reflect)]
-#![feature(custom_attribute)]
 
 #[macro_use]
 mod macros;

trunk/src/libcore/marker.rs

@@ -49,7 +49,6 @@ impl !Send for Managed { }
 #[stable(feature = "rust1", since = "1.0.0")]
 #[lang="sized"]
 #[rustc_on_unimplemented = "`{Self}` does not have a constant size known at compile-time"]
-#[fundamental] // for Default, for example, which requires that `[T]: !Default` be evaluatable
 pub trait Sized : MarkerTrait {
     // Empty.
 }
@@ -347,16 +346,17 @@ impl<T:?Sized> MarkerTrait for T { }
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PhantomFn<A:?Sized,R:?Sized=()> { }
 
-/// `PhantomData<T>` allows you to describe that a type acts as if it stores a value of type `T`,
-/// even though it does not. This allows you to inform the compiler about certain safety properties
-/// of your code.
-///
-/// Though they both have scary names, `PhantomData<T>` and "phantom types" are unrelated. 👻👻👻
+/// `PhantomData` is a way to tell the compiler about fake fields.
+/// Phantom data is required whenever type parameters are not used.
+/// The idea is that if the compiler encounters a `PhantomData<T>`
+/// instance, it will behave *as if* an instance of the type `T` were
+/// present for the purpose of various automatic analyses.
 ///
 /// # Examples
 ///
 /// When handling external resources over a foreign function interface, `PhantomData<T>` can
-/// prevent mismatches by enforcing types in the method implementations:
+/// prevent mismatches by enforcing types in the method implementations, although the struct
+/// doesn't actually contain values of the resource type.
 ///
 /// ```
 /// # trait ResType { fn foo(&self); };
@@ -397,6 +397,11 @@ pub trait PhantomFn<A:?Sized,R:?Sized=()> { }
 /// commonly necessary if the structure is using an unsafe pointer
 /// like `*mut T` whose referent may be dropped when the type is
 /// dropped, as a `*mut T` is otherwise not treated as owned.
+///
+/// FIXME. Better documentation and examples of common patterns needed
+/// here! For now, please see [RFC 738][738] for more information.
+///
+/// [738]: https://github.com/rust-lang/rfcs/blob/master/text/0738-variance.md
 #[lang="phantom_data"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct PhantomData<T:?Sized>;

trunk/src/libcore/ops.rs

@@ -1117,7 +1117,6 @@ impl<'a, T: ?Sized> DerefMut for &'a mut T {
 #[lang="fn"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_paren_sugar]
-#[fundamental] // so that regex can rely that `&str: !FnMut`
 pub trait Fn<Args> : FnMut<Args> {
     /// This is called when the call operator is used.
     extern "rust-call" fn call(&self, args: Args) -> Self::Output;
@@ -1127,7 +1126,6 @@ pub trait Fn<Args> : FnMut<Args> {
 #[lang="fn_mut"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_paren_sugar]
-#[fundamental] // so that regex can rely that `&str: !FnMut`
 pub trait FnMut<Args> : FnOnce<Args> {
     /// This is called when the call operator is used.
     extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
@@ -1137,60 +1135,10 @@ pub trait FnMut<Args> : FnOnce<Args> {
 #[lang="fn_once"]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_paren_sugar]
-#[fundamental] // so that regex can rely that `&str: !FnMut`
 pub trait FnOnce<Args> {
     /// The returned type after the call operator is used.
     type Output;
 
     /// This is called when the call operator is used.
     extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
 }
-
-#[cfg(not(stage0))]
-mod impls {
-    use marker::Sized;
-    use super::{Fn, FnMut, FnOnce};
-
-    impl<'a,A,F:?Sized> Fn<A> for &'a F
-        where F : Fn<A>
-    {
-        extern "rust-call" fn call(&self, args: A) -> F::Output {
-            (**self).call(args)
-        }
-    }
-
-    impl<'a,A,F:?Sized> FnMut<A> for &'a F
-        where F : Fn<A>
-    {
-        extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
-            (**self).call(args)
-        }
-    }
-
-    impl<'a,A,F:?Sized> FnOnce<A> for &'a F
-        where F : Fn<A>
-    {
-        type Output = F::Output;
-
-        extern "rust-call" fn call_once(self, args: A) -> F::Output {
-            (*self).call(args)
-        }
-    }
-
-    impl<'a,A,F:?Sized> FnMut<A> for &'a mut F
-        where F : FnMut<A>
-    {
-        extern "rust-call" fn call_mut(&mut self, args: A) -> F::Output {
-            (*self).call_mut(args)
-        }
-    }
-
-    impl<'a,A,F:?Sized> FnOnce<A> for &'a mut F
-        where F : FnMut<A>
-    {
-        type Output = F::Output;
-        extern "rust-call" fn call_once(mut self, args: A) -> F::Output {
-            (*self).call_mut(args)
-        }
-    }
-}

trunk/src/librustc/lib.rs

@@ -120,8 +120,6 @@ pub mod middle {
     pub mod traits;
     pub mod ty;
     pub mod ty_fold;
-    pub mod ty_match;
-    pub mod ty_relate;
     pub mod ty_walk;
     pub mod weak_lang_items;
 }

trunk/src/librustc/metadata/encoder.rs

@@ -34,7 +34,8 @@ use std::io::prelude::*;
 use std::io::{Cursor, SeekFrom};
 use syntax::abi;
 use syntax::ast::{self, DefId, NodeId};
-use syntax::ast_map::{self, LinkedPath, PathElem, PathElems};
+use syntax::ast_map::{PathElem, PathElems};
+use syntax::ast_map;
 use syntax::ast_util::*;
 use syntax::ast_util;
 use syntax::attr;
@@ -1512,7 +1513,7 @@ fn encode_info_for_items(ecx: &EncodeContext,
                         &krate.module,
                         &[],
                         ast::CRATE_NODE_ID,
-                        [].iter().cloned().chain(LinkedPath::empty()),
+                        [].iter().cloned().chain(None),
                         syntax::parse::token::special_idents::invalid,
                         ast::Public);
 
@@ -1873,7 +1874,7 @@ fn encode_misc_info(ecx: &EncodeContext,
     }
 
     // Encode reexports for the root module.
-    encode_reexports(ecx, rbml_w, 0, [].iter().cloned().chain(LinkedPath::empty()));
+    encode_reexports(ecx, rbml_w, 0, [].iter().cloned().chain(None));
 
     rbml_w.end_tag();
     rbml_w.end_tag();

trunk/src/librustc/middle/dataflow.rs

@@ -108,7 +108,7 @@ impl<'a, 'tcx, O:DataFlowOperator> pprust::PpAnn for DataFlowContext<'a, 'tcx, O
             pprust::NodeIdent(_) | pprust::NodeName(_) => 0,
             pprust::NodeExpr(expr) => expr.id,
             pprust::NodeBlock(blk) => blk.id,
-            pprust::NodeItem(_) | pprust::NodeSubItem(_) => 0,
+            pprust::NodeItem(_) => 0,
             pprust::NodePat(pat) => pat.id
         };