---

yaml
---
r: 149013
b: refs/heads/try2
c: cba7ac5
h: refs/heads/master
i:
  149011: 60580d9
v: v3

Author: bors

[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: ee3fa68fed13e7b8cde523e4bc73b9a07d082212
+refs/heads/try2: cba7ac5e014e7e225a4e226f15e9c05563d6e4a9
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/libstd/macros.rs

@@ -20,23 +20,33 @@ macro_rules! log(
         }
     })
 )
+
 #[macro_export]
-macro_rules! error( ($($arg:tt)*) => (log!(1u32, $($arg)*)) )
+macro_rules! error(
+    ($($arg:tt)*) => (log!(1u32, $($arg)*))
+)
+
 #[macro_export]
-macro_rules! warn ( ($($arg:tt)*) => (log!(2u32, $($arg)*)) )
+macro_rules! warn(
+    ($($arg:tt)*) => (log!(2u32, $($arg)*))
+)
+
 #[macro_export]
-macro_rules! info ( ($($arg:tt)*) => (log!(3u32, $($arg)*)) )
+macro_rules! info(
+    ($($arg:tt)*) => (log!(3u32, $($arg)*))
+)
+
 #[macro_export]
-macro_rules! debug( ($($arg:tt)*) => (
-    if cfg!(not(ndebug)) { log!(4u32, $($arg)*) }
-))
+macro_rules! debug(
+    ($($arg:tt)*) => (if cfg!(not(ndebug)) { log!(4u32, $($arg)*) })
+)
 
 #[macro_export]
 macro_rules! log_enabled(
-    ($lvl:expr) => ( {
+    ($lvl:expr) => ({
         let lvl = $lvl;
         lvl <= __log_level() && (lvl != 4 || cfg!(not(ndebug)))
-    } )
+    })
 )
 
 #[macro_export]
@@ -47,54 +57,50 @@ macro_rules! fail(
     ($msg:expr) => (
         ::std::rt::begin_unwind($msg, file!(), line!())
     );
-    ($fmt:expr, $($arg:tt)*) => (
-        {
-            // a closure can't have return type !, so we need a full
-            // function to pass to format_args!, *and* we need the
-            // file and line numbers right here; so an inner bare fn
-            // is our only choice.
-            #[inline]
-            fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
-                ::std::rt::begin_unwind_fmt(fmt, file!(), line!())
-            }
-            format_args!(run_fmt, $fmt, $($arg)*)
+    ($fmt:expr, $($arg:tt)*) => ({
+        // a closure can't have return type !, so we need a full
+        // function to pass to format_args!, *and* we need the
+        // file and line numbers right here; so an inner bare fn
+        // is our only choice.
+        #[inline]
+        fn run_fmt(fmt: &::std::fmt::Arguments) -> ! {
+            ::std::rt::begin_unwind_fmt(fmt, file!(), line!())
         }
-        )
+        format_args!(run_fmt, $fmt, $($arg)*)
+    });
 )
 
 #[macro_export]
 macro_rules! assert(
-    ($cond:expr) => {
+    ($cond:expr) => (
         if !$cond {
             fail!("assertion failed: {:s}", stringify!($cond))
         }
-    };
-    ($cond:expr, $msg:expr) => {
+    );
+    ($cond:expr, $msg:expr) => (
         if !$cond {
             fail!($msg)
         }
-    };
-    ($cond:expr, $( $arg:expr ),+) => {
+    );
+    ($cond:expr, $($arg:expr),+) => (
         if !$cond {
-            fail!( $($arg),+ )
+            fail!($($arg),+)
         }
-    }
+    );
 )
 
 #[macro_export]
-macro_rules! assert_eq (
-    ($given:expr , $expected:expr) => (
-        {
-            let given_val = &($given);
-            let expected_val = &($expected);
-            // check both directions of equality....
-            if !((*given_val == *expected_val) &&
-                 (*expected_val == *given_val)) {
-                fail!("assertion failed: `(left == right) && (right == left)` \
-                       (left: `{:?}`, right: `{:?}`)", *given_val, *expected_val)
-            }
+macro_rules! assert_eq(
+    ($given:expr , $expected:expr) => ({
+        let given_val = &($given);
+        let expected_val = &($expected);
+        // check both directions of equality....
+        if !((*given_val == *expected_val) &&
+             (*expected_val == *given_val)) {
+            fail!("assertion failed: `(left == right) && (right == left)` \
+                   (left: `{:?}`, right: `{:?}`)", *given_val, *expected_val)
         }
-    )
+    })
 )
 
 /// A utility macro for indicating unreachable code. It will fail if
@@ -103,7 +109,7 @@ macro_rules! assert_eq (
 ///
 /// # Example
 ///
-/// ```rust
+/// ~~~rust
 /// fn choose_weighted_item(v: &[Item]) -> Item {
 ///     assert!(!v.is_empty());
 ///     let mut so_far = 0u;
@@ -117,44 +123,61 @@ macro_rules! assert_eq (
 ///     // type checker that it isn't possible to get down here
 ///     unreachable!();
 /// }
-/// ```
+/// ~~~
+#[macro_export]
+macro_rules! unreachable(
+    () => (fail!("internal error: entered unreachable code"))
+)
+
+/// A standardised placeholder for marking unfinished code. It fails with the
+/// message `"not yet implemented"` when executed.
 #[macro_export]
-macro_rules! unreachable (() => (
-    fail!("internal error: entered unreachable code");
-))
+macro_rules! unimplemented(
+    () => (fail!("not yet implemented"))
+)
 
 #[macro_export]
-macro_rules! format(($($arg:tt)*) => (
-    format_args!(::std::fmt::format, $($arg)*)
-))
+macro_rules! format(
+    ($($arg:tt)*) => (
+        format_args!(::std::fmt::format, $($arg)*)
+    )
+)
+
 #[macro_export]
-macro_rules! write(($dst:expr, $($arg:tt)*) => (
-    format_args!(|args| { ::std::fmt::write($dst, args) }, $($arg)*)
-))
+macro_rules! write(
+    ($dst:expr, $($arg:tt)*) => (
+        format_args!(|args| { ::std::fmt::write($dst, args) }, $($arg)*)
+    )
+)
+
 #[macro_export]
-macro_rules! writeln(($dst:expr, $($arg:tt)*) => (
-    format_args!(|args| { ::std::fmt::writeln($dst, args) }, $($arg)*)
-))
+macro_rules! writeln(
+    ($dst:expr, $($arg:tt)*) => (
+        format_args!(|args| { ::std::fmt::writeln($dst, args) }, $($arg)*)
+    )
+)
+
 #[macro_export]
-macro_rules! print (
+macro_rules! print(
     ($($arg:tt)*) => (format_args!(::std::io::stdio::print_args, $($arg)*))
 )
+
 #[macro_export]
-macro_rules! println (
+macro_rules! println(
     ($($arg:tt)*) => (format_args!(::std::io::stdio::println_args, $($arg)*))
 )
 
 #[macro_export]
-macro_rules! local_data_key (
+macro_rules! local_data_key(
     ($name:ident: $ty:ty) => (
         static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key;
     );
     (pub $name:ident: $ty:ty) => (
         pub static $name: ::std::local_data::Key<$ty> = &::std::local_data::Key;
-    )
+    );
 )
 
 #[macro_export]
-macro_rules! if_ok (
+macro_rules! if_ok(
     ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) })
 )

branches/try2/src/test/run-fail/unimplemented-macro-fail.rs

@@ -0,0 +1,12 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:not yet implemented
+fn main() { unimplemented!() }

branches/try2/src/test/run-fail/unreachable-macro-fail.rs

@@ -0,0 +1,12 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern:internal error: entered unreachable code
+fn main() { unreachable!() }