Workaround for rustc ICE

This is the specific ICE issue: rust-lang/rust#24644

Author: Valloric

base/and.rs

@@ -14,9 +14,7 @@
 
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! and( ( $ex:expr ) => ( {
-    use base;
-    &base::And::new( $ex ) } ); );
+macro_rules! and( ( $ex:expr ) => ( &base::And::new( $ex ) ); );
 
 pub struct And<'a> {
   expr: &'a ( Expression + 'a )
@@ -43,6 +41,7 @@ impl<'b> Expression for And<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{ParseResult, Expression};
 
   #[test]

base/char_class.rs

@@ -14,9 +14,8 @@
 use base::unicode::{bytesFollowing, readCodepoint};
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! class( ( $ex:expr ) => ( {
-      use base;
-      &base::CharClass::new( $ex.as_bytes() ) } ) );
+macro_rules! class( ( $ex:expr ) => (
+      &base::CharClass::new( $ex.as_bytes() ) ) );
 
 
 fn toU32Vector( input: &[u8] ) -> Vec<u32> {
@@ -135,6 +134,7 @@ impl Expression for CharClass {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, Data, ParseResult, Expression, ParseState};
   use base::test_utils::ToParseState;
   use base::unicode::bytesFollowing;

base/fuse.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! fuse( ( $ex:expr ) => ( {
-    use base;
-    &base::Fuse::new( $ex ) } ); );
+macro_rules! fuse( ( $ex:expr ) => ( &base::Fuse::new( $ex ) ); );
 
 pub struct Fuse<'a> {
   expr: &'a ( Expression + 'a )
@@ -46,6 +44,7 @@ impl<'b> Expression for Fuse<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, Data, ParseResult, Expression};
 
   #[test]

base/literal.rs

@@ -13,9 +13,8 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! lit( ( $ex:expr ) => ( {
-      use base;
-      &base::Literal::new( $ex.as_bytes() ) } ) );
+macro_rules! lit( ( $ex:expr ) => (
+      &base::Literal::new( $ex.as_bytes() ) ) );
 
 
 pub struct Literal {
@@ -45,6 +44,7 @@ impl Expression for Literal {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, Data, ParseResult, ParseState, Expression};
 
   #[test]

base/not.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! not( ( $ex:expr ) => ( {
-    use base;
-    &base::NotEx::new($ex) } ); );
+macro_rules! not( ( $ex:expr ) => ( &base::NotEx::new($ex) ); );
 
 pub struct NotEx<'a> {
   expr: &'a ( Expression + 'a )
@@ -42,6 +40,7 @@ impl<'b> Expression for NotEx<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{ParseResult, Expression};
 
   #[test]

base/option.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! opt( ( $ex:expr ) => ( {
-    use base;
-    &base::OptionEx::new( $ex ) } ); );
+macro_rules! opt( ( $ex:expr ) => ( &base::OptionEx::new( $ex ) ); );
 
 pub struct OptionEx<'a> {
   expr: &'a ( Expression + 'a )
@@ -42,6 +40,7 @@ impl<'b> Expression for OptionEx<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, ParseResult, Expression, Data};
 
   #[test]

base/or.rs

@@ -13,9 +13,8 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! or( ( $( $ex:expr ),* ) => ( {
-    use base;
-    &base::Or::new( &[ $( $ex ),* ] ) } ); );
+macro_rules! or( ( $( $ex:expr ),* ) => (
+    &base::Or::new( &[ $( $ex ),* ] ) ); );
 
 pub struct Or<'a> {
   exprs: &'a [&'a (Expression + 'a)]
@@ -45,6 +44,7 @@ impl<'b> Expression for Or<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, ParseResult, Expression, Data};
 
   #[test]

base/plus.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! plus( ( $ex:expr ) => ( {
-    use base;
-    &base::Plus::new( $ex ) } ); );
+macro_rules! plus( ( $ex:expr ) => ( &base::Plus::new( $ex ) ); );
 
 pub struct Plus<'a> {
   expr: &'a ( Expression + 'a )
@@ -56,6 +54,7 @@ impl<'b> Expression for Plus<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, ParseResult, Expression, Data};
 
   #[test]

base/sequence.rs

@@ -13,9 +13,8 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! seq( ( $( $ex:expr ),* ) => ( {
-    use base;
-    &base::Sequence::new( &[ $( $ex ),* ] ) } ); );
+macro_rules! seq( ( $( $ex:expr ),* ) => (
+    &base::Sequence::new( &[ $( $ex ),* ] ) ); );
 
 pub struct Sequence<'a> {
   exprs: &'a [&'a (Expression + 'a)]
@@ -49,6 +48,7 @@ impl<'b> Expression for Sequence<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, ParseResult, Expression, Data};
 
   #[test]

base/star.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult};
 
-macro_rules! star( ( $ex:expr ) => ( {
-    use base;
-    &base::Star::new( $ex ) } ); );
+macro_rules! star( ( $ex:expr ) => ( &base::Star::new( $ex ) ); );
 
 pub struct Star<'a> {
   expr: &'a ( Expression + 'a )
@@ -49,6 +47,7 @@ impl<'b> Expression for Star<'b> {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{Node, ParseResult, Expression, Data};
 
   #[test]

base/wrap.rs

@@ -13,9 +13,7 @@
 // limitations under the License.
 use super::{Expression, ParseState, ParseResult, Rule};
 
-macro_rules! ex( ( $ex:expr ) => ( {
-    use base;
-    &base::WrapEx{ rule: $ex } } ); );
+macro_rules! ex( ( $ex:expr ) => ( &base::WrapEx{ rule: $ex } ); );
 
 pub struct WrapEx {
   pub rule: Rule
@@ -32,6 +30,7 @@ impl Expression for WrapEx {
 
 #[cfg(test)]
 mod tests {
+  use base;
   use base::{ParseResult, Expression, ParseState};
   use super::{WrapEx};