Fix macro hygiene issues with hir

Using the re-exporting trick from rust-lang/rust#52234 (comment)
to reference the macro recursively at a known path. This way any
external callers don't have to import the macro or its dependencies.

Author: nwtnni

src/data.rs

@@ -1,7 +1,6 @@
 pub mod asm;
 pub mod ast;
 pub mod hir;
-#[macro_use]
 pub mod ir;
 pub mod lir;
 pub mod operand;

src/data/hir.rs

@@ -160,28 +160,42 @@ impl fmt::Display for Statement {
 #[macro_export]
 macro_rules! hir {
     ((CONST $($integer:tt)+)) => {
-        $crate::data::hir::Expression::from(hir!($($integer)+))
+        $crate::data::hir::Expression::from(
+            $crate::data::hir::hir!($($integer)+)
+        )
     };
     ((NAME $($label:tt)+)) => {
-        $crate::data::hir::Expression::from(hir!($($label)+))
+        $crate::data::hir::Expression::from(
+            $crate::data::hir::hir!($($label)+)
+        )
     };
     ((TEMP $($temporary:tt)+)) => {
-        $crate::data::hir::Expression::from(hir!($($temporary)+))
+        $crate::data::hir::Expression::from(
+            $crate::data::hir::hir!($($temporary)+)
+        )
     };
     ((MEM $expression:tt)) => {
-        $crate::data::hir::Expression::Memory(Box::new(hir!($expression)))
+        $crate::data::hir::Expression::Memory(Box::new(
+            $crate::data::hir::hir!($expression)
+        ))
     };
     ((CALL $function:tt $returns:tt $($argument:tt)*)) => {
         $crate::data::hir::Expression::Call(
-            Box::new(hir!($function)),
-            vec![$(hir!($argument),)*],
+            Box::new(
+                $crate::data::hir::hir!($function)
+            ),
+            vec![
+                $(
+                    $crate::data::hir::hir!($argument),
+                )*
+            ],
             $returns,
         )
     };
     ((ESEQ $statement:tt $expression:tt)) => {
         $crate::data::hir::Expression::Sequence(
-            Box::new(hir!($statement)),
-            Box::new(hir!($expression)),
+            Box::new($crate::data::hir::hir!($statement)),
+            Box::new($crate::data::hir::hir!($expression)),
         )
     };
 
@@ -190,9 +204,9 @@ macro_rules! hir {
     };
     ((CJUMP ($condition:ident $left:tt $right:tt) $r#true:ident $r#false:ident)) => {
         $crate::data::hir::Statement::CJump {
-            condition: ir!($condition),
-            left: hir!($left),
-            right: hir!($right),
+            condition: $crate::data::ir::ir!($condition),
+            left: $crate::data::hir::hir!($left),
+            right: $crate::data::hir::hir!($right),
             r#true: $r#true,
             r#false: $r#false,
         }
@@ -201,36 +215,47 @@ macro_rules! hir {
         $crate::data::hir::Statement::Label($label)
     };
     ((EXP $expression:tt)) => {
-        $crate::data::hir::Statement::Expression(hir!($expression))
+        $crate::data::hir::Statement::Expression(
+            $crate::data::hir::hir!($expression)
+        )
     };
     ((MOVE $into:tt $from:tt)) => {
         $crate::data::hir::Statement::Move {
-            destination: hir!($into),
-            source: hir!($from),
+            destination: $crate::data::hir::hir!($into),
+            source: $crate::data::hir::hir!($from),
         }
     };
-    ((RETURN $returns:expr)) => {
-        $crate::data::hir::Statement::Return($returns)
-    };
-    ((SEQ $statement:tt $($statements:tt)+)) => {
-        $crate::data::hir::Statement::Sequence(vec![
-            hir!($statement),
-            $(hir!($statements),)*
-        ])
+    ((RETURN $($expression:tt)*)) => {
+        $crate::data::hir::Statement::Return(
+            vec![
+                $(
+                    $crate::data::hir::hir!($expression),
+                )*
+            ]
+        )
     };
-    ((SEQ $statements:expr)) => {
-        $crate::data::hir::Statement::Sequence($statements)
+    ((SEQ $($statement:tt)*)) => {
+        $crate::data::hir::Statement::Sequence(
+            vec![
+                $(
+                    $crate::data::hir::hir!($statement),
+                )*
+            ],
+        )
     };
-
     (($binary:ident $left:tt $right:tt)) => {
         $crate::data::hir::Expression::Binary(
-            ir!($binary),
-            Box::new(hir!($left)),
-            Box::new(hir!($right)),
+            $crate::data::ir::ir!($binary),
+            Box::new($crate::data::hir::hir!($left)),
+            Box::new($crate::data::hir::hir!($right)),
         )
     };
 
     ($expression:expr) => {
         $expression
     }
 }
+
+// https://github.com/rust-lang/rust/pull/52234#issuecomment-976702997
+#[doc(hidden)]
+pub use hir;

src/data/ir.rs

@@ -144,3 +144,7 @@ macro_rules! ir {
 
     ($ident:ident) => { $ident };
 }
+
+// https://github.com/rust-lang/rust/pull/52234#issuecomment-976702997
+#[doc(hidden)]
+pub use ir;

src/emit/emit.rs

@@ -71,7 +71,7 @@ impl<'env> Emitter<'env> {
 
         hir::Function {
             name,
-            statement: hir!((SEQ statements)),
+            statement: hir::Statement::Sequence(statements),
             arguments: function.parameters.len(),
             returns: function.returns.len(),
         }
@@ -125,7 +125,7 @@ impl<'env> Emitter<'env> {
 
                 hir!(
                     (ESEQ
-                        (SEQ statements)
+                        (hir::Statement::Sequence(statements))
                         (ADD (TEMP array) (CONST abi::WORD))))
                 .into()
             }
@@ -281,7 +281,7 @@ impl<'env> Emitter<'env> {
                             //
                             // The number of returns must match the rest of the function, so return values
                             // are defined along all paths to the exit.
-                            (RETURN vec![hir!((CONST 0)); self.returns])
+                            (hir::Statement::Return(vec![hir!((CONST 0)); self.returns]))
                             (LABEL r#in))
                         (MEM (ADD (TEMP base) (MUL (TEMP index) (CONST abi::WORD)))))
                 ).into()
@@ -329,7 +329,7 @@ impl<'env> Emitter<'env> {
                 lengths.push(hir!((MOVE (TEMP fresh) (declaration))));
 
                 hir::Expression::Sequence(
-                    Box::new(hir!((SEQ lengths))),
+                    Box::new(hir::Statement::Sequence(lengths)),
                     Box::new(hir!((TEMP fresh))),
                 )
             }
@@ -382,7 +382,11 @@ impl<'env> Emitter<'env> {
             }
         }
 
-        hir!((ESEQ (SEQ statements) (ADD (TEMP array) (CONST abi::WORD))))
+        hir!(
+            (ESEQ
+                (hir::Statement::Sequence(statements))
+                (ADD (TEMP array) (CONST abi::WORD)))
+        )
     }
 
     fn emit_statement(

src/lib.rs

@@ -1,4 +1,3 @@
-#[macro_use]
 pub mod data;
 
 mod abi;