---

yaml
---
r: 111003
b: refs/heads/snap-stage3
c: 2f41a85
h: refs/heads/master
i:
  111001: ac2d3f0
  110999: 9f35011
v: v3

Author: bors

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 296e60be6b027a52de58251848037a92f23a0878
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 8f5d71cf71849bea25f87836cec1b06b476baf37
+refs/heads/snap-stage3: 2f41a85d8e1f577f17e5b17a1d648508e1ac5001
 refs/heads/try: 38201d7c6bf0c32b0e5bdc8ecd63976ebc1b3a4c
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/doc/guide-macros.md

@@ -407,7 +407,7 @@ As an example, `loop` and `for-loop` labels (discussed in the lifetimes guide)
 will not clash. The following code will print "Hello!" only once:
 
 ~~~
-#[feature(macro_rules)];
+#![feature(macro_rules)]
 
 macro_rules! loop_x (
     ($e: expr) => (

branches/snap-stage3/src/doc/guide-pointers.md

@@ -250,7 +250,7 @@ struct.
 # Managed Pointers
 
 > **Note**: the `@` form of managed pointers is deprecated and behind a
-> feature gate (it requires a `#[feature(managed_pointers)];` attribute on
+> feature gate (it requires a `#![feature(managed_pointers)]` attribute on
 > the crate root; remember the semicolon!). There are replacements, currently 
 > there is `std::rc::Rc` and `std::gc::Gc` for shared ownership via reference
 > counting and garbage collection respectively.

branches/snap-stage3/src/doc/guide-testing.md

@@ -185,7 +185,7 @@ amount.
 For example:
 
 ~~~
-# #[allow(unused_imports)];
+# #![allow(unused_imports)]
 extern crate test;
 
 use std::slice;
@@ -247,7 +247,7 @@ recognize that some calculation has no external effects and remove
 it entirely.
 
 ~~~
-# #[allow(unused_imports)];
+# #![allow(unused_imports)]
 extern crate test;
 use test::Bencher;
 

branches/snap-stage3/src/doc/guide-unsafe.md

@@ -424,14 +424,14 @@ Current valid options are:
 # Avoiding the standard library
 
 By default, `std` is linked to every Rust crate. In some contexts,
-this is undesirable, and can be avoided with the `#[no_std];`
+this is undesirable, and can be avoided with the `#![no_std]`
 attribute attached to the crate.
 
 ```ignore
 # // FIXME #12903: linking failures due to no_std
 // the minimal library
-#[crate_type="lib"];
-#[no_std];
+#![crate_type="lib"]
+#![no_std]
 
 # // fn main() {} tricked you, rustdoc!
 ```
@@ -446,7 +446,7 @@ in the same format as a C:
 
 ```ignore
 # // FIXME #12903: linking failures due to no_std
-#[no_std];
+#![no_std]
 
 extern "rust-intrinsic" { fn abort() -> !; }
 #[no_mangle] pub extern fn rust_stack_exhausted() {
@@ -462,14 +462,14 @@ fn start(_argc: int, _argv: **u8) -> int {
 ```
 
 To override the compiler-inserted `main` shim, one has to disable it
-with `#[no_main];` and then create the appropriate symbol with the
+with `#![no_main]` and then create the appropriate symbol with the
 correct ABI and the correct name, which requires overriding the
 compiler's name mangling too:
 
 ```ignore
 # // FIXME #12903: linking failures due to no_std
-#[no_std];
-#[no_main];
+#![no_std]
+#![no_main]
 
 extern "rust-intrinsic" { fn abort() -> !; }
 #[no_mangle] pub extern fn rust_stack_exhausted() {
@@ -543,7 +543,7 @@ sugar for dynamic allocations via `malloc` and `free`:
 
 ```ignore
 # // FIXME #12903: linking failures due to no_std
-#[no_std];
+#![no_std]
 
 #[allow(ctypes)] // `uint` == `size_t` on Rust's platforms
 extern {

branches/snap-stage3/src/doc/po/ja/rust.md.po

@@ -252,7 +252,7 @@ msgstr "# モジュールとクレート"
 #: src/doc/rust.md:627
 #, fuzzy
 #| msgid "// Turn on a warning #[warn(non_camel_case_types)]"
-msgid "// Turn on a warning #[ warn(non_camel_case_types) ]; ~~~~"
+msgid "// Turn on a warning #![ warn(non_camel_case_types) ] ~~~~"
 msgstr ""
 "// 警告を有効にする\n"
 "#[warn(non_camel_case_types)]"

branches/snap-stage3/src/doc/po/ja/tutorial.md.po

@@ -4851,13 +4851,13 @@ msgstr ""
 #. type: Plain text
 #: src/doc/tutorial.md:3134
 #, fuzzy
-#| msgid "// Make a library (\"bin\" is the default)  #[crate_type = \"lib\"];"
+#| msgid "// Make a library (\"bin\" is the default)  #![crate_type = \"lib\"]"
 msgid ""
 "// This crate is a library (\"bin\" is the default)  #[crate_id = "
-"\"farm#2.5\"]; #[crate_type = \"lib\"];"
+"\"farm#2.5\"]; #![crate_type = \"lib\"]"
 msgstr ""
 "// ライブラリを作成する (\"bin\" がデフォルト値)\n"
-"#[crate_type = \"lib\"];"
+"#![crate_type = \"lib\"]"
 
 #. type: Plain text
 #: src/doc/tutorial.md:3139
@@ -4888,15 +4888,15 @@ msgstr ""
 #: src/doc/tutorial.md:3153
 #, fuzzy
 #| msgid ""
-#| "~~~~ // world.rs #[link(name = \"world\", vers = \"1.0\")]; pub fn "
+#| "~~~~ // world.rs #![link(name = \"world\", vers = \"1.0\")] pub fn "
 #| "explore() -> &str { \"world\" } ~~~~"
 msgid ""
-"~~~~ // `world.rs` #[crate_id = \"world#0.42\"]; # extern crate extra; pub fn "
+"~~~~ // `world.rs` #![crate_id = \"world#0.42\"] # extern crate extra; pub fn "
 "explore() -> &'static str { \"world\" } # fn main() {} ~~~~"
 msgstr ""
 "~~~~\n"
 "// world.rs\n"
-"#[link(name = \"world\", vers = \"1.0\")];\n"
+"#![link(name = \"world\", vers = \"1.0\")]\n"
 "pub fn explore() -> &str { \"world\" }\n"
 "~~~~"
 

branches/snap-stage3/src/doc/rustdoc.md

@@ -13,8 +13,8 @@ comments":
 ~~~
 // the "link" crate attribute is currently required for rustdoc, but normally
 // isn't needed.
-#[crate_id = "universe"];
-#[crate_type="lib"];
+#![crate_id = "universe"]
+#![crate_type="lib"]
 
 //! Tools for dealing with universes (this is a doc comment, and is shown on
 //! the crate index page. The ! makes it apply to the parent of the comment,

branches/snap-stage3/src/doc/tutorial.md

@@ -3096,8 +3096,8 @@ Therefore, if you plan to compile your crate as a library, you should annotate i
 ~~~~
 // `lib.rs`
 
-# #[crate_type = "lib"];
-#[crate_id = "farm#2.5"];
+# #![crate_type = "lib"]
+#![crate_id = "farm#2.5"]
 
 // ...
 # fn farm() {}
@@ -3121,8 +3121,8 @@ or setting the crate type (library or executable) explicitly:
 // ...
 
 // This crate is a library ("bin" is the default)
-#[crate_id = "farm#2.5"];
-#[crate_type = "lib"];
+#![crate_id = "farm#2.5"]
+#![crate_type = "lib"]
 
 // Turn on a warning
 #[warn(non_camel_case_types)]
@@ -3137,7 +3137,7 @@ We define two crates, and use one of them as a library in the other.
 
 ~~~~
 // `world.rs`
-#[crate_id = "world#0.42"];
+#![crate_id = "world#0.42"]
 
 # mod secret_module_to_make_this_test_run {
 pub fn explore() -> &'static str { "world" }
@@ -3211,12 +3211,12 @@ Both auto-insertions can be disabled with an attribute if necessary:
 
 ~~~
 // In the crate root:
-#[no_std];
+#![no_std]
 ~~~
 
 ~~~
 // In any module:
-#[no_implicit_prelude];
+#![no_implicit_prelude]
 ~~~
 
 See the [API documentation][stddoc] for details.

branches/snap-stage3/src/librustc/middle/astencode.rs

@@ -266,7 +266,7 @@ trait def_id_encoder_helpers {
 
 impl<S:serialize::Encoder<E>, E> def_id_encoder_helpers for S {
     fn emit_def_id(&mut self, did: ast::DefId) {
-        did.encode(self).unwrap()
+        did.encode(self).ok().unwrap()
     }
 }
 
@@ -278,13 +278,13 @@ trait def_id_decoder_helpers {
 
 impl<D:serialize::Decoder<E>, E> def_id_decoder_helpers for D {
     fn read_def_id(&mut self, xcx: &ExtendedDecodeContext) -> ast::DefId {
-        let did: ast::DefId = Decodable::decode(self).unwrap();
+        let did: ast::DefId = Decodable::decode(self).ok().unwrap();
         did.tr(xcx)
     }
 
     fn read_def_id_noxcx(&mut self,
                          cdata: @cstore::crate_metadata) -> ast::DefId {
-        let did: ast::DefId = Decodable::decode(self).unwrap();
+        let did: ast::DefId = Decodable::decode(self).ok().unwrap();
         decoder::translate_def_id(cdata, did)
     }
 }

branches/snap-stage3/src/libstd/comm/mod.rs

@@ -496,7 +496,7 @@ impl<T: Send> Sender<T> {
                                 // This send cannot fail because the task is
                                 // asleep (we're looking at it), so the receiver
                                 // can't go away.
-                                (*a.get()).send(t).unwrap();
+                                (*a.get()).send(t).ok().unwrap();
                                 task.wake().map(|t| t.reawaken());
                                 (a, Ok(()))
                             }

branches/snap-stage3/src/libstd/path/mod.rs

@@ -63,17 +63,20 @@ println!("path exists: {}", path.exists());
 
 */
 
+#![deny(deprecated_owned_vector)]
+
 use container::Container;
 use c_str::CString;
 use clone::Clone;
 use fmt;
 use iter::Iterator;
 use option::{Option, None, Some};
 use str;
-use str::{MaybeOwned, OwnedStr, Str, StrSlice, from_utf8_lossy};
-use slice;
-use slice::{CloneableVector, OwnedCloneableVector, OwnedVector, Vector};
+use str::{MaybeOwned, Str, StrSlice, from_utf8_lossy};
+use strbuf::StrBuf;
+use slice::{OwnedCloneableVector, OwnedVector, Vector};
 use slice::{ImmutableEqVector, ImmutableVector};
+use vec::Vec;
 
 /// Typedef for POSIX file paths.
 /// See `posix::Path` for more info.
@@ -184,7 +187,7 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
     fn as_vec<'a>(&'a self) -> &'a [u8];
 
     /// Converts the Path into an owned byte vector
-    fn into_vec(self) -> ~[u8];
+    fn into_vec(self) -> Vec<u8>;
 
     /// Returns an object that implements `Show` for printing paths
     ///
@@ -293,15 +296,15 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
             let extlen = extension.container_as_bytes().len();
             match (name.rposition_elem(&dot), extlen) {
                 (None, 0) | (Some(0), 0) => None,
-                (Some(idx), 0) => Some(name.slice_to(idx).to_owned()),
+                (Some(idx), 0) => Some(Vec::from_slice(name.slice_to(idx))),
                 (idx, extlen) => {
                     let idx = match idx {
                         None | Some(0) => name.len(),
                         Some(val) => val
                     };
 
                     let mut v;
-                    v = slice::with_capacity(idx + extlen + 1);
+                    v = Vec::with_capacity(idx + extlen + 1);
                     v.push_all(name.slice_to(idx));
                     v.push(dot);
                     v.push_all(extension.container_as_bytes());
@@ -441,10 +444,10 @@ pub trait GenericPath: Clone + GenericPathUnsafe {
 pub trait BytesContainer {
     /// Returns a &[u8] representing the receiver
     fn container_as_bytes<'a>(&'a self) -> &'a [u8];
-    /// Consumes the receiver and converts it into ~[u8]
+    /// Consumes the receiver and converts it into Vec<u8>
     #[inline]
-    fn container_into_owned_bytes(self) -> ~[u8] {
-        self.container_as_bytes().to_owned()
+    fn container_into_owned_bytes(self) -> Vec<u8> {
+        Vec::from_slice(self.container_as_bytes())
     }
     /// Returns the receiver interpreted as a utf-8 string, if possible
     #[inline]
@@ -522,15 +525,27 @@ impl BytesContainer for ~str {
         self.as_bytes()
     }
     #[inline]
-    fn container_into_owned_bytes(self) -> ~[u8] {
+    fn container_as_str<'a>(&'a self) -> Option<&'a str> {
+        Some(self.as_slice())
+    }
+    #[inline]
+    fn is_str(_: Option<~str>) -> bool { true }
+}
+impl BytesContainer for StrBuf {
+    #[inline]
+    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
+        self.as_bytes()
+    }
+    #[inline]
+    fn container_into_owned_bytes(self) -> Vec<u8> {
         self.into_bytes()
     }
     #[inline]
     fn container_as_str<'a>(&'a self) -> Option<&'a str> {
         Some(self.as_slice())
     }
     #[inline]
-    fn is_str(_: Option<~str>) -> bool { true }
+    fn is_str(_: Option<StrBuf>) -> bool { true }
 }
 
 impl<'a> BytesContainer for &'a [u8] {
@@ -545,8 +560,15 @@ impl BytesContainer for ~[u8] {
     fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
         self.as_slice()
     }
+}
+
+impl BytesContainer for Vec<u8> {
+    #[inline]
+    fn container_as_bytes<'a>(&'a self) -> &'a [u8] {
+        self.as_slice()
+    }
     #[inline]
-    fn container_into_owned_bytes(self) -> ~[u8] {
+    fn container_into_owned_bytes(self) -> Vec<u8> {
         self
     }
 }
@@ -564,10 +586,6 @@ impl<'a> BytesContainer for str::MaybeOwned<'a> {
         self.as_slice().as_bytes()
     }
     #[inline]
-    fn container_into_owned_bytes(self) -> ~[u8] {
-        self.into_owned().into_bytes()
-    }
-    #[inline]
     fn container_as_str<'b>(&'b self) -> Option<&'b str> {
         Some(self.as_slice())
     }