auto merge of #12090 : bjz/rust/unimplemented, r=cmr

Adds a standardised placeholder for marking unfinished code.

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,8 +57,7 @@ macro_rules! fail(
     ($msg:expr) => (
         ::std::rt::begin_unwind($msg, file!(), line!())
     );
-    ($fmt:expr, $($arg:tt)*) => (
-        {
+    ($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
@@ -58,33 +67,31 @@ macro_rules! fail(
             ::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) => (
-        {
+macro_rules! assert_eq(
+    ($given:expr , $expected:expr) => ({
         let given_val = &($given);
         let expected_val = &($expected);
         // check both directions of equality....
@@ -93,8 +100,7 @@ macro_rules! assert_eq (
             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");
-))
+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! unimplemented(
+    () => (fail!("not yet implemented"))
+)
 
 #[macro_export]
-macro_rules! format(($($arg:tt)*) => (
+macro_rules! format(
+    ($($arg:tt)*) => (
         format_args!(::std::fmt::format, $($arg)*)
-))
+    )
+)
+
 #[macro_export]
-macro_rules! write(($dst:expr, $($arg:tt)*) => (
+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)*) => (
+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) })
 )

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!() }

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!() }