clean up macro scoping

Author: jimblandy

naga/src/proc/overloads/constructor_set.rs

@@ -170,3 +170,5 @@ macro_rules! constructor_set {
         }
     }
 }
+
+pub(in crate::proc::overloads) use constructor_set;

naga/src/proc/overloads/mathfunction.rs

@@ -2,6 +2,7 @@
 
 use crate::proc::overloads::any_overload_set::AnyOverloadSet;
 use crate::proc::overloads::list::List;
+use crate::proc::overloads::regular::regular;
 use crate::proc::overloads::utils::{
     concrete_int_scalars, float_scalars, float_scalars_unimplemented_abstract, list, pairs, rule,
     scalar_or_vecn, triples, vector_sizes,

naga/src/proc/overloads/mod.rs

@@ -12,12 +12,9 @@ representing the given `MathFunction`'s overloads.
 
 */
 
-#[macro_use]
 mod constructor_set;
-#[macro_use]
-mod scalar_set;
-#[macro_use]
 mod regular;
+mod scalar_set;
 
 mod any_overload_set;
 mod list;
@@ -126,6 +123,7 @@ use core::fmt;
 ///
 /// [`List`]: list::List
 /// [`Regular`]: regular::Regular
+/// [`regular!`]: regular::regular
 pub trait OverloadSet: Clone {
     /// Return true if `self` is the empty set of overloads.
     fn is_empty(&self) -> bool;

naga/src/proc/overloads/regular.rs

@@ -288,27 +288,41 @@ impl ForDebugWithTypes for &[Rule] {}
 /// When a return type identifier is given, it is treated as a variant
 /// of the the [`ConclusionRule`] enum.
 macro_rules! regular {
-    //
+    // regular!(ARITY, CONSTRUCTOR of SCALAR)
     ( $arity:literal , $( $constr:ident )|* of $( $scalar:ident )|*) => {
-        $crate::proc::overloads::regular::Regular {
-            arity: $arity,
-            constructors: constructor_set!( $( $constr )|* ),
-            scalars: scalar_set!( $( $scalar )|* ),
-            conclude: $crate::proc::overloads::regular::ConclusionRule::ArgumentType,
+        {
+            use $crate::proc::overloads;
+            use overloads::constructor_set::constructor_set;
+            use overloads::regular::{Regular, ConclusionRule};
+            use overloads::scalar_set::scalar_set;
+            Regular {
+                arity: $arity,
+                constructors: constructor_set!( $( $constr )|* ),
+                scalars: scalar_set!( $( $scalar )|* ),
+                conclude: ConclusionRule::ArgumentType,
+            }
         }
     };
 
-    // regular!(ARITY, CONSTRUCTOR<SCALAR>)
+    // regular!(ARITY, CONSTRUCTOR of SCALAR -> CONCLUSION_RULE)
     ( $arity:literal , $( $constr:ident )|* of $( $scalar:ident )|* -> $conclude:ident) => {
-        $crate::proc::overloads::regular::Regular {
-            arity: $arity,
-            constructors: constructor_set!( $( $constr )|* ),
-            scalars: scalar_set!( $( $scalar )|* ),
-            conclude: $crate::proc::overloads::regular::ConclusionRule::$conclude,
+        {
+            use $crate::proc::overloads;
+            use overloads::constructor_set::constructor_set;
+            use overloads::regular::{Regular, ConclusionRule};
+            use overloads::scalar_set::scalar_set;
+            Regular {
+                arity: $arity,
+                constructors:constructor_set!( $( $constr )|* ),
+                scalars: scalar_set!( $( $scalar )|* ),
+                conclude: ConclusionRule::$conclude,
+            }
         }
     };
 }
 
+pub(in crate::proc::overloads) use regular;
+
 #[cfg(test)]
 mod test {
     use super::*;

naga/src/proc/overloads/scalar_set.rs

@@ -137,3 +137,5 @@ macro_rules! scalar_set {
         }
     }
 }
+
+pub(in crate::proc::overloads) use scalar_set;