Enable const_assert anywhere with an exception

If used outside of a function, a unique label is required.

This is a partial solution to issue #1.

Author: nvzqz

README.md

@@ -45,12 +45,8 @@ const_assert!(1 + 1 == 2);
 // Supports constants
 const FIVE: usize = 5;
 
-// Supports comma and semicolon-separated conditions
+// Supports comma-separated conditions
 const_assert!(4 > 3, 3 + 2 == FIVE);
-const_assert! {
-    FIVE + FIVE == 10;
-    FIVE / FIVE == 1;
-}
 
 // Fails to compile
 const_assert!(2 != 2);

src/lib.rs

@@ -78,6 +78,9 @@
 //! [`const_assert`]. If the expression evaluates to `false`, the file will fail
 //! to compile. This is synonymous to [`static_assert` in C++][static_assert].
 //!
+//! As a [limitation](#limitations), a unique label is required if the macro is
+//! used outside of a function.
+//!
 //! ```
 //! # #[macro_use]
 //! # extern crate static_assertions;
@@ -93,19 +96,25 @@
 //! ```
 //! # #[macro_use]
 //! # extern crate static_assertions;
-//! # fn main() {
-//! const NUM: usize = 32;
-//! const_assert_eq!(NUM + NUM, 64);
-//!
 //! const TWO: usize = 2;
-//! const_assert_eq!(TWO * TWO, TWO + TWO, 4);
-//! # }
+//! const_assert_eq!(two; TWO * TWO, TWO + TWO, 4);
+//!
+//! // Produces a compilation failure:
+//! // const_assert_eq!(two; TWO, TWO);
+//!
+//! fn main() {
+//!     const NUM: usize = 32;
+//!     const_assert_eq!(NUM + NUM, 64);
+//! }
 //! ```
 //!
 //! # Limitations
 //!
-//! Due to implementation details, [`assert_eq_size`], [`const_assert`], and
-//! [`const_assert_eq`] can only be used from within the context of a function.
+//! Due to implementation details, [`assert_eq_size`] can only be used from
+//! within the context of a function.
+//!
+//! This is partially resolved in [`const_assert`] and [`const_assert_eq`] by
+//! requiring a unique label when not inside a function.
 //!
 //! [crate]: https://crates.io/crates/static_assertions
 //! [static_assert]: http://en.cppreference.com/w/cpp/language/static_assert
@@ -228,15 +237,12 @@ macro_rules! assert_eq_size_val {
 /// ```
 #[macro_export]
 macro_rules! const_assert {
-    ($cond:expr) => {
-        // Causes overflow if condition is false
-        let _ = [(); 0 - (!($cond) as usize)];
-    };
     ($($xs:expr),+) => {
-        const_assert!($($xs)&&+);
+        let _ = [(); 0 - (!($($xs)&&+) as usize)];
     };
-    ($($xs:expr);+ $(;)*) => {
-        const_assert!($($xs),+);
+    ($label:ident; $($xs:expr),+) => {
+        #[allow(dead_code, non_camel_case_types)]
+        type $label = [(); 0 - (!($($xs)&&+) as usize)];
     };
 }
 
@@ -245,5 +251,8 @@ macro_rules! const_assert {
 macro_rules! const_assert_eq {
     ($x:expr, $($xs:expr),+) => {
         const_assert!($($x == $xs),+);
-    }
+    };
+    ($label:ident; $x:expr, $($xs:expr),+) => {
+        const_assert!($label; $($x == $xs),+);
+    };
 }

tests/const.rs

@@ -1,10 +1,16 @@
 #![no_std]
-
+#![deny(dead_code, non_camel_case_types)]
 #![cfg_attr(feature = "const_fn", feature(const_fn))]
 
 #[macro_use]
 extern crate static_assertions;
 
+const_assert!(less_than; 20 < 1000);
+const_assert_eq!(twenty; 20, 30 - 10, 10 + 10, 10 * 2);
+
+#[cfg(feature = "failure")]
+const_assert!(less_than; true);
+
 #[test]
 fn const_assert() {
     const FIVE: usize = 5;