---

yaml
---
r: 151347
b: refs/heads/try2
c: be71d80
h: refs/heads/master
i:
  151345: a330cba
  151343: 530e8ac
v: v3

Author: alexcrichton

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: df621acf5f6f5e4e5d7170963ad7ed7dfe8e2d6c
+refs/heads/try2: be71d809bde4bdc46df0bacceccd8ed76540fd04
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/AUTHORS.txt

@@ -362,7 +362,6 @@ Raphael Speyer <[email protected]>
 reedlepee <[email protected]>
 Reuben Morais <[email protected]>
 Richard Diamond <[email protected]>
-Richo Healey <[email protected]>
 Rick Waldron <[email protected]>
 Rob Arnold <[email protected]>
 Rob Hoelz <[email protected]>

branches/try2/CONTRIBUTING.md

@@ -33,11 +33,11 @@ message explaining why.
 
 In the licensing header at the beginning of any files you change,
 please make sure the listed date range includes the current year.  For
-example, if it's 2014, and you change a Rust file that was created in
+example, if it's 2013, and you change a Rust file that was created in
 2010, it should begin:
 
 ```
-// Copyright 2010-2014 The Rust Project Developers.
+// Copyright 2010-2013 The Rust Project Developers.
 ```
 
 For more details, please refer to

branches/try2/mk/platform.mk

@@ -330,7 +330,7 @@ CFG_PATH_MUNGE_arm-unknown-linux-gnueabihf := true
 CFG_LDPATH_arm-unknown-linux-gnueabihf :=
 CFG_RUN_arm-unknown-linux-gnueabihf=$(2)
 CFG_RUN_TARG_arm-unknown-linux-gnueabihf=$(call CFG_RUN_arm-unknown-linux-gnueabihf,,$(2))
-RUSTC_FLAGS_arm-unknown-linux-gnueabihf := -C target-feature=+v6,+vfp2
+RUSTC_FLAGS_arm-unknown-linux-gnueabihf := -C target-feature=+v7,+vfp3
 RUSTC_CROSS_FLAGS_arm-unknown-linux-gnueabihf :=
 
 # arm-unknown-linux-gnueabi configuration

branches/try2/src/doc/intro.md

@@ -370,7 +370,7 @@ fn main() {
 ```
 
 This example is starting to get more subtle,
-but it hints at the powerful composability of Rust's concurrent types.
+but it hints at the powerful compositionality of Rust's concurrent types.
 This time we've put our array of numbers inside a `Mutex` and then put *that* inside the `Arc`.
 Like immutable data,
 `Mutex`es are sharable,

branches/try2/src/doc/tutorial.md

@@ -2992,23 +2992,21 @@ And here an example with multiple files:
 ~~~{.ignore}
 // `a.rs` - crate root
 use b::foo;
-use b::c::bar;
 mod b;
-fn main() {
-    foo();
-    bar();
-}
+fn main() { foo(); }
 ~~~
 
 ~~~{.ignore}
-// `b/mod.rs`
+// `b.rs`
+use b::c::bar;
 pub mod c;
-pub fn foo() { println!("Foo!"; }
+pub fn foo() { bar(); }
 ~~~
 
-~~~{.ignore}
-// `b/c.rs`
-pub fn bar() { println!("Bar!"); }
+~~~
+// `c.rs`
+pub fn bar() { println!("Baz!"); }
+# fn main() {}
 ~~~
 
 There also exist two short forms for importing multiple names at once:

branches/try2/src/liblog/lib.rs

@@ -195,11 +195,11 @@ impl fmt::Signed for LogLevel {
 
 impl Logger for DefaultLogger {
     fn log(&mut self, record: &LogRecord) {
-        match write!(&mut self.handle,
-                     "{}:{}: {}",
-                     record.level,
-                     record.module_path,
-                     record.args) {
+        match writeln!(&mut self.handle,
+                       "{}:{}: {}",
+                       record.level,
+                       record.module_path,
+                       record.args) {
             Err(e) => fail!("failed to log: {}", e),
             Ok(()) => {}
         }

branches/try2/src/libnative/io/file_unix.rs

@@ -335,7 +335,7 @@ pub fn open(path: &CString, fm: io::FileMode, fa: io::FileAccess)
 
 pub fn mkdir(p: &CString, mode: io::FilePermission) -> IoResult<()> {
     super::mkerr_libc(retry(|| unsafe {
-        libc::mkdir(p.with_ref(|p| p), mode.bits() as libc::mode_t)
+        libc::mkdir(p.with_ref(|p| p), mode as libc::mode_t)
     }))
 }
 
@@ -392,7 +392,7 @@ pub fn rename(old: &CString, new: &CString) -> IoResult<()> {
 
 pub fn chmod(p: &CString, mode: io::FilePermission) -> IoResult<()> {
     super::mkerr_libc(retry(|| unsafe {
-        libc::chmod(p.with_ref(|p| p), mode.bits() as libc::mode_t)
+        libc::chmod(p.with_ref(|p| p), mode as libc::mode_t)
     }))
 }
 
@@ -470,9 +470,7 @@ fn mkstat(stat: &libc::stat, path: &CString) -> io::FileStat {
         path: Path::new(path),
         size: stat.st_size as u64,
         kind: kind,
-        perm: unsafe {
-            io::FilePermission::from_bits(stat.st_mode as u32) & io::AllPermissions
-        },
+        perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
         created: mktime(stat.st_ctime as u64, stat.st_ctime_nsec as u64),
         modified: mktime(stat.st_mtime as u64, stat.st_mtime_nsec as u64),
         accessed: mktime(stat.st_atime as u64, stat.st_atime_nsec as u64),

branches/try2/src/libnative/io/file_win32.rs

@@ -392,7 +392,7 @@ pub fn rename(old: &CString, new: &CString) -> IoResult<()> {
 
 pub fn chmod(p: &CString, mode: io::FilePermission) -> IoResult<()> {
     super::mkerr_libc(as_utf16_p(p.as_str().unwrap(), |p| unsafe {
-        libc::wchmod(p, mode.bits() as libc::c_int)
+        libc::wchmod(p, mode as libc::c_int)
     }))
 }
 
@@ -471,9 +471,7 @@ fn mkstat(stat: &libc::stat, path: &CString) -> io::FileStat {
         path: Path::new(path),
         size: stat.st_size as u64,
         kind: kind,
-        perm: unsafe {
-          io::FilePermission::from_bits(stat.st_mode as u32)  & io::AllPermissions
-        },
+        perm: (stat.st_mode) as io::FilePermission & io::AllPermissions,
         created: stat.st_ctime as u64,
         modified: stat.st_mtime as u64,
         accessed: stat.st_atime as u64,

branches/try2/src/librustuv/file.rs

@@ -283,9 +283,7 @@ impl FsRequest {
             path: path,
             size: stat.st_size as u64,
             kind: kind,
-            perm: unsafe {
-                io::FilePermission::from_bits(stat.st_mode as u32) & io::AllPermissions
-            },
+            perm: (stat.st_mode as io::FilePermission) & io::AllPermissions,
             created: to_msec(stat.st_birthtim),
             modified: to_msec(stat.st_mtim),
             accessed: to_msec(stat.st_atim),

branches/try2/src/librustuv/uvio.rs

@@ -224,7 +224,7 @@ impl IoFactory for UvIoFactory {
     }
     fn fs_mkdir(&mut self, path: &CString,
                 perm: io::FilePermission) -> Result<(), IoError> {
-        let r = FsRequest::mkdir(&self.loop_, path, perm.bits() as c_int);
+        let r = FsRequest::mkdir(&self.loop_, path, perm as c_int);
         r.map_err(uv_error_to_io_error)
     }
     fn fs_rmdir(&mut self, path: &CString) -> Result<(), IoError> {
@@ -237,7 +237,7 @@ impl IoFactory for UvIoFactory {
     }
     fn fs_chmod(&mut self, path: &CString,
                 perm: io::FilePermission) -> Result<(), IoError> {
-        let r = FsRequest::chmod(&self.loop_, path, perm.bits() as c_int);
+        let r = FsRequest::chmod(&self.loop_, path, perm as c_int);
         r.map_err(uv_error_to_io_error)
     }
     fn fs_readdir(&mut self, path: &CString, flags: c_int)

branches/try2/src/libstd/bitflags.rs

@@ -17,16 +17,14 @@
 //! # Example
 //!
 //! ~~~rust
-//! bitflags!(
-//!     flags Flags: u32 {
-//!         static FlagA       = 0x00000001,
-//!         static FlagB       = 0x00000010,
-//!         static FlagC       = 0x00000100,
-//!         static FlagABC     = FlagA.bits
-//!                            | FlagB.bits
-//!                            | FlagC.bits
-//!     }
-//! )
+//! bitflags!(Flags: u32 {
+//!     FlagA       = 0x00000001,
+//!     FlagB       = 0x00000010,
+//!     FlagC       = 0x00000100,
+//!     FlagABC     = FlagA.bits
+//!                 | FlagB.bits
+//!                 | FlagC.bits
+//! })
 //!
 //! fn main() {
 //!     let e1 = FlagA | FlagC;
@@ -42,12 +40,10 @@
 //! ~~~rust
 //! use std::fmt;
 //!
-//! bitflags!(
-//!     flags Flags: u32 {
-//!         static FlagA   = 0x00000001,
-//!         static FlagB   = 0x00000010
-//!     }
-//! )
+//! bitflags!(Flags: u32 {
+//!     FlagA   = 0x00000001,
+//!     FlagB   = 0x00000010
+//! })
 //!
 //! impl Flags {
 //!     pub fn clear(&mut self) {
@@ -70,16 +66,10 @@
 //! }
 //! ~~~
 //!
-//! # Attributes
-//!
-//! Attributes can be attached to the generated `struct` by placing them
-//! before the `flags` keyword.
-//!
 //! # Derived traits
 //!
-//! The `Eq` and `Clone` traits are automatically derived for the `struct` using
-//! the `deriving` attribute. Additional traits can be derived by providing an
-//! explicit `deriving` attribute on `flags`.
+//! The `Eq`, `TotalEq`, and `Clone` traits are automatically derived for the
+//! `struct` using the `deriving` attribute.
 //!
 //! # Operators
 //!
@@ -101,20 +91,17 @@
 //! - `insert`: inserts the specified flags in-place
 //! - `remove`: removes the specified flags in-place
 
-#![macro_escape]
-
 #[macro_export]
 macro_rules! bitflags(
-    ($(#[$attr:meta])* flags $BitFlags:ident: $T:ty {
-        $($(#[$Flag_attr:meta])* static $Flag:ident = $value:expr),+
+    ($BitFlags:ident: $T:ty {
+        $($Flag:ident = $value:expr),+
     }) => (
         #[deriving(Eq, TotalEq, Clone)]
-        $(#[$attr])*
         pub struct $BitFlags {
             bits: $T,
         }
 
-        $($(#[$Flag_attr])* pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
+        $(pub static $Flag: $BitFlags = $BitFlags { bits: $value };)+
 
         impl $BitFlags {
             /// Returns an empty set of flags.
@@ -127,12 +114,6 @@ macro_rules! bitflags(
                 self.bits
             }
 
-            /// Convert from underlying bit representation. Unsafe because the
-            /// bits are not guaranteed to represent valid flags.
-            pub unsafe fn from_bits(bits: $T) -> $BitFlags {
-                $BitFlags { bits: bits }
-            }
-
             /// Returns `true` if no flags are currently stored.
             pub fn is_empty(&self) -> bool {
                 *self == $BitFlags::empty()
@@ -189,16 +170,14 @@ macro_rules! bitflags(
 mod tests {
     use ops::{BitOr, BitAnd, Sub};
 
-    bitflags!(
-        flags Flags: u32 {
-            static FlagA       = 0x00000001,
-            static FlagB       = 0x00000010,
-            static FlagC       = 0x00000100,
-            static FlagABC     = FlagA.bits
-                               | FlagB.bits
-                               | FlagC.bits
-        }
-    )
+    bitflags!(Flags: u32 {
+        FlagA       = 0x00000001,
+        FlagB       = 0x00000010,
+        FlagC       = 0x00000100,
+        FlagABC     = FlagA.bits
+                    | FlagB.bits
+                    | FlagC.bits
+    })
 
     #[test]
     fn test_bits(){

branches/try2/src/libstd/io/fs.rs

@@ -1119,7 +1119,7 @@ mod test {
         check!(File::create(&input));
         check!(chmod(&input, io::UserRead));
         check!(copy(&input, &out));
-        assert!(!check!(out.stat()).perm.intersects(io::UserWrite));
+        assert!(check!(out.stat()).perm & io::UserWrite == 0);
 
         check!(chmod(&input, io::UserFile));
         check!(chmod(&out, io::UserFile));
@@ -1193,9 +1193,9 @@ mod test {
         let file = tmpdir.join("in.txt");
 
         check!(File::create(&file));
-        assert!(check!(stat(&file)).perm.contains(io::UserWrite));
+        assert!(check!(stat(&file)).perm & io::UserWrite == io::UserWrite);
         check!(chmod(&file, io::UserRead));
-        assert!(!check!(stat(&file)).perm.contains(io::UserWrite));
+        assert!(check!(stat(&file)).perm & io::UserWrite == 0);
 
         match chmod(&tmpdir.join("foo"), io::UserRWX) {
             Ok(..) => fail!("wanted a failure"),