---

yaml
---
r: 160070
b: refs/heads/try
c: 5416901
h: refs/heads/master
v: v3

Author: emberian

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: e09d98603e608c9e47d4c89f7b4dca87a4b56da3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 9c96a79a74f10bed18b031ce0ac4126c56d6cfb3
-refs/heads/try: c01c6e2cac7e75406f711c9c0344ab522421ce58
+refs/heads/try: 5416901ccad4550b6f7a6145de5dbbe94b98e309
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/doc/guide-pointers.md

@@ -133,11 +133,11 @@ pass-by-reference. Basically, languages can make two choices (this is made
 up syntax, it's not Rust):
 
 ```{notrust,ignore}
-func foo(x) {
+fn foo(x) {
     x = 5
 }
 
-func main() {
+fn main() {
     i = 1
     foo(i)
     // what is the value of i here?
@@ -153,11 +153,11 @@ So what do pointers have to do with this? Well, since pointers point to a
 location in memory...
 
 ```{notrust,ignore}
-func foo(&int x) {
+fn foo(&int x) {
     *x = 5
 }
 
-func main() {
+fn main() {
     i = 1
     foo(&i)
     // what is the value of i here?
@@ -192,13 +192,13 @@ When you combine pointers and functions, it's easy to accidentally invalidate
 the memory the pointer is pointing to. For example:
 
 ```{notrust,ignore}
-func make_pointer(): &int {
+fn make_pointer(): &int {
     x = 5;
 
     return &x;
 }
 
-func main() {
+fn main() {
     &int i = make_pointer();
     *i = 5; // uh oh!
 }
@@ -214,11 +214,11 @@ issue. Two pointers are said to alias when they point at the same location
 in memory. Like this:
 
 ```{notrust,ignore}
-func mutate(&int i, int j) {
+fn mutate(&int i, int j) {
     *i = j;
 }
 
-func main() {
+fn main() {
   x = 5;
   y = &x;
   z = &x; //y and z are aliased

branches/try/src/doc/po4a.conf

@@ -19,7 +19,7 @@
 [type: text] src/doc/guide-tasks.md $lang:doc/l10n/$lang/guide-tasks.md
 [type: text] src/doc/guide-testing.md $lang:doc/l10n/$lang/guide-testing.md
 [type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-unsafe.md
-[type: text] src/doc/guide-crates.md $lang:doc/l10n/$lang/guide-crates.md
+[type: text] src/doc/guide-unsafe.md $lang:doc/l10n/$lang/guide-crates.md
 [type: text] src/doc/guide.md $lang:doc/l10n/$lang/guide.md
 [type: text] src/doc/index.md $lang:doc/l10n/$lang/index.md
 [type: text] src/doc/intro.md $lang:doc/l10n/$lang/intro.md

branches/try/src/doc/reference.md

@@ -2653,10 +2653,9 @@ An expression may have two roles: it always produces a *value*, and it may have
 value, and has effects during *evaluation*. Many expressions contain
 sub-expressions (operands). The meaning of each kind of expression dictates
 several things:
-
-* Whether or not to evaluate the sub-expressions when evaluating the expression
-* The order in which to evaluate the sub-expressions
-* How to combine the sub-expressions' values to obtain the value of the expression
+  * Whether or not to evaluate the sub-expressions when evaluating the
+  * expression The order in which to evaluate the sub-expressions How to
+  * combine the sub-expressions' values to obtain the value of the expression.
 
 In this way, the structure of expressions dictates the structure of execution.
 Blocks are just another kind of expression, so blocks, statements, expressions,

branches/try/src/etc/snapshot.py

@@ -75,11 +75,7 @@ def full_snapshot_name(date, rev, platform, hsh):
 
 
 def get_kernel(triple):
-    t = triple.split('-')
-    if len(t) == 2:
-      os_name = t[1]
-    else:
-      os_name = t[2]
+    os_name = triple.split('-')[2]
     if os_name == "windows":
         return "winnt"
     if os_name == "darwin":

branches/try/src/libcollections/tree/set.rs

@@ -504,9 +504,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::TreeSet;
+    /// use std::collections::BTreeSet;
     ///
-    /// let mut set = TreeSet::new();
+    /// let mut set = BTreeSet::new();
     ///
     /// assert_eq!(set.insert(2i), true);
     /// assert_eq!(set.insert(2i), false);
@@ -522,9 +522,9 @@ impl<T: Ord> TreeSet<T> {
     /// # Example
     ///
     /// ```
-    /// use std::collections::TreeSet;
+    /// use std::collections::BTreeSet;
     ///
-    /// let mut set = TreeSet::new();
+    /// let mut set = BTreeSet::new();
     ///
     /// set.insert(2i);
     /// assert_eq!(set.remove(&2), true);

branches/try/src/libcore/cell.rs

@@ -157,7 +157,6 @@
 
 use clone::Clone;
 use cmp::PartialEq;
-use default::Default;
 use kinds::{marker, Copy};
 use ops::{Deref, DerefMut, Drop};
 use option::{None, Option, Some};
@@ -212,13 +211,6 @@ impl<T:Copy> Clone for Cell<T> {
     }
 }
 
-#[unstable]
-impl<T:Default + Copy> Default for Cell<T> {
-    fn default() -> Cell<T> {
-        Cell::new(Default::default())
-    }
-}
-
 #[unstable = "waiting for `PartialEq` trait to become stable"]
 impl<T:PartialEq + Copy> PartialEq for Cell<T> {
     fn eq(&self, other: &Cell<T>) -> bool {
@@ -345,13 +337,6 @@ impl<T: Clone> Clone for RefCell<T> {
     }
 }
 
-#[unstable]
-impl<T:Default> Default for RefCell<T> {
-    fn default() -> RefCell<T> {
-        RefCell::new(Default::default())
-    }
-}
-
 #[unstable = "waiting for `PartialEq` to become stable"]
 impl<T: PartialEq> PartialEq for RefCell<T> {
     fn eq(&self, other: &RefCell<T>) -> bool {

branches/try/src/libcore/result.rs

@@ -267,7 +267,7 @@
 //! a bug.
 //!
 //! A module that instead returns `Results` is alerting the caller
-//! that failure is possible, and providing precise control over how
+//! that panics are possible, and providing precise control over how
 //! it is handled.
 //!
 //! Furthermore, panics may not be recoverable at all, depending on

branches/try/src/libcoretest/cell.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use core::cell::*;
-use core::default::Default;
 use std::mem::drop;
 
 #[test]
@@ -147,15 +146,3 @@ fn as_unsafe_cell() {
     unsafe { *r2.as_unsafe_cell().get() = 1u; }
     assert_eq!(1u, *r2.borrow());
 }
-
-#[test]
-fn cell_default() {
-    let cell: Cell<u32> = Default::default();
-    assert_eq!(0, cell.get());
-}
-
-#[test]
-fn refcell_default() {
-    let cell: RefCell<u64> = Default::default();
-    assert_eq!(0, *cell.borrow());
-}

branches/try/src/librustc/metadata/decoder.rs

@@ -630,12 +630,12 @@ pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec<ast_map::PathElem> {
     item_path(lookup_item(id, cdata.data()))
 }
 
-pub type DecodeInlinedItem<'a> = for<'tcx> |cdata: Cmd,
-                                            tcx: &ty::ctxt<'tcx>,
-                                            path: Vec<ast_map::PathElem>,
-                                            par_doc: rbml::Doc|: 'a
-                                            -> Result<&'tcx ast::InlinedItem,
-                                                      Vec<ast_map::PathElem>>;
+pub type DecodeInlinedItem<'a> = <'tcx> |cdata: Cmd,
+                                         tcx: &ty::ctxt<'tcx>,
+                                         path: Vec<ast_map::PathElem>,
+                                         par_doc: rbml::Doc|: 'a
+                                         -> Result<&'tcx ast::InlinedItem,
+                                                   Vec<ast_map::PathElem>>;
 
 pub fn maybe_get_item_ast<'tcx>(cdata: Cmd, tcx: &ty::ctxt<'tcx>, id: ast::NodeId,
                                 decode_inlined_item: DecodeInlinedItem)

branches/try/src/librustc/middle/trans/base.rs

@@ -1787,8 +1787,8 @@ pub fn trans_closure(ccx: &CrateContext,
                      abi: Abi,
                      has_env: bool,
                      is_unboxed_closure: IsUnboxedClosureFlag,
-                     maybe_load_env: for<'blk, 'tcx> |Block<'blk, 'tcx>, ScopeId|
-                                                     -> Block<'blk, 'tcx>) {
+                     maybe_load_env: <'blk, 'tcx> |Block<'blk, 'tcx>, ScopeId|
+                                                  -> Block<'blk, 'tcx>) {
     ccx.stats().n_closures.set(ccx.stats().n_closures.get() + 1);
 
     let _icx = push_ctxt("trans_closure");

branches/try/src/librustc/middle/trans/glue.rs

@@ -528,8 +528,8 @@ fn declare_generic_glue(ccx: &CrateContext, t: ty::t, llfnty: Type,
 fn make_generic_glue(ccx: &CrateContext,
                      t: ty::t,
                      llfn: ValueRef,
-                     helper: for<'blk, 'tcx> |Block<'blk, 'tcx>, ValueRef, ty::t|
-                                              -> Block<'blk, 'tcx>,
+                     helper: <'blk, 'tcx> |Block<'blk, 'tcx>, ValueRef, ty::t|
+                                           -> Block<'blk, 'tcx>,
                      name: &str)
                      -> ValueRef {
     let _icx = push_ctxt("make_generic_glue");

branches/try/src/librustc/middle/trans/type_of.rs

@@ -455,7 +455,12 @@ pub fn llvm_type_name(cx: &CrateContext,
 
     let base = ty::item_path_str(cx.tcx(), did);
     let strings: Vec<String> = tps.iter().map(|t| t.repr(cx.tcx())).collect();
-    let tstr = format!("{}<{}>", base, strings);
+    let tstr = if strings.is_empty() {
+        base
+    } else {
+        format!("{}<{}>", base, strings)
+    };
+
     if did.krate == 0 {
         format!("{}.{}", name, tstr)
     } else {

branches/try/src/librustdoc/html/static/main.css

@@ -584,9 +584,3 @@ pre.rust { position: relative; }
         height: 1.5em;
     }
 }
-
-@media print {
-    nav.sub, .content .out-of-band, .collapse-toggle {
-        display: none;
-    }
-}

branches/try/src/libserialize/json.rs

@@ -2315,10 +2315,6 @@ impl ToJson for bool {
     fn to_json(&self) -> Json { Boolean(*self) }
 }
 
-impl ToJson for str {
-    fn to_json(&self) -> Json { String(self.into_string()) }
-}
-
 impl ToJson for string::String {
     fn to_json(&self) -> Json { String((*self).clone()) }
 }
@@ -3718,8 +3714,7 @@ mod tests {
         assert_eq!(f64::NAN.to_json(), Null);
         assert_eq!(true.to_json(), Boolean(true));
         assert_eq!(false.to_json(), Boolean(false));
-        assert_eq!("abc".to_json(), String("abc".into_string()));
-        assert_eq!("abc".into_string().to_json(), String("abc".into_string()));
+        assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
         assert_eq!((1u, 2u).to_json(), list2);
         assert_eq!((1u, 2u, 3u).to_json(), list3);
         assert_eq!([1u, 2].to_json(), list2);

branches/try/src/libstd/io/mod.rs

@@ -1437,6 +1437,16 @@ pub trait Buffer: Reader {
         )
     }
 
+    /// Create an iterator that reads a line on each iteration until EOF.
+    ///
+    /// # Error
+    ///
+    /// Any error other than `EndOfFile` that is produced by the underlying Reader
+    /// is returned by the iterator and should be handled by the caller.
+    fn lines<'r>(&'r mut self) -> Lines<'r, Self> {
+        Lines { buffer: self }
+    }
+
     /// Reads a sequence of bytes leading up to a specified delimiter. Once the
     /// specified byte is encountered, reading ceases and the bytes up to and
     /// including the delimiter are returned.
@@ -1512,36 +1522,17 @@ pub trait Buffer: Reader {
             None => Err(standard_error(InvalidInput))
         }
     }
-}
 
-/// Extension methods for the Buffer trait which are included in the prelude.
-pub trait BufferPrelude {
     /// Create an iterator that reads a utf8-encoded character on each iteration
     /// until EOF.
     ///
     /// # Error
     ///
     /// Any error other than `EndOfFile` that is produced by the underlying Reader
     /// is returned by the iterator and should be handled by the caller.
-    fn chars<'r>(&'r mut self) -> Chars<'r, Self>;
-
-    /// Create an iterator that reads a line on each iteration until EOF.
-    ///
-    /// # Error
-    ///
-    /// Any error other than `EndOfFile` that is produced by the underlying Reader
-    /// is returned by the iterator and should be handled by the caller.
-    fn lines<'r>(&'r mut self) -> Lines<'r, Self>;
-}
-
-impl<T: Buffer> BufferPrelude for T {
-    fn chars<'r>(&'r mut self) -> Chars<'r, T> {
+    fn chars<'r>(&'r mut self) -> Chars<'r, Self> {
         Chars { buffer: self }
     }
-
-    fn lines<'r>(&'r mut self) -> Lines<'r, T> {
-        Lines { buffer: self }
-    }
 }
 
 /// When seeking, the resulting cursor is offset from a base by the offset given
@@ -2012,8 +2003,4 @@ mod tests {
         assert_eq!(format!("{}", ALL_PERMISSIONS), "0777".to_string());
         assert_eq!(format!("{}", USER_READ | USER_WRITE | OTHER_WRITE), "0602".to_string());
     }
-
-    fn _ensure_buffer_is_object_safe<T: Buffer>(x: &T) -> &Buffer {
-        x as &Buffer
-    }
 }

branches/try/src/libstd/prelude.rs

@@ -73,7 +73,7 @@
 #[doc(no_inline)] pub use path::{GenericPath, Path, PosixPath, WindowsPath};
 #[doc(no_inline)] pub use ptr::{RawPtr, RawMutPtr};
 #[doc(no_inline)] pub use result::{Result, Ok, Err};
-#[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek, BufferPrelude};
+#[doc(no_inline)] pub use io::{Buffer, Writer, Reader, Seek};
 #[doc(no_inline)] pub use str::{Str, StrVector, StrPrelude};
 #[doc(no_inline)] pub use str::{IntoMaybeOwned, StrAllocating, UnicodeStrPrelude};
 #[doc(no_inline)] pub use to_string::{ToString, IntoStr};