Refactor the Call trait into the test lib

Author: gnzlbg

crates/libm-test/src/lib.rs

@@ -51,3 +51,40 @@ impl WithinUlps for i32 {
         ulps <= ulp_tol as _
     }
 }
+
+/// This implements function dispatch for tuples of arguments used in the tests
+/// above, so that we can: (f32, 32).call(fn(f32, f32) -> f32) generically.
+///
+/// We need the input parameter F to support dispatching, e.g., (f32,f32) with
+/// functions that return both f32 or i32. Those are two different types, so we
+/// need to be parametric over them.
+pub trait Call<F> {
+    type Ret;
+    fn call(self, f: F) -> Self::Ret;
+}
+
+macro_rules! impl_call {
+    (($($arg_tys:ty),*) -> $ret_ty:ty: $self_:ident: $($xs:expr),*)  => {
+        // We only care about unsafe extern "C" functions here, safe functions coerce to them:
+        impl Call<unsafe extern"C" fn($($arg_tys),*) -> $ret_ty> for ($($arg_tys,)+) {
+            type Ret = $ret_ty;
+            fn call(self, f: unsafe extern "C" fn($($arg_tys),*) -> $ret_ty) -> Self::Ret {
+                let $self_ = self;
+                unsafe { f($($xs),*) }
+            }
+        }
+    };
+}
+
+impl_call!((f32) -> f32: x: x.0);
+impl_call!((f64) -> f64: x: x.0);
+impl_call!((f64) -> i32: x: x.0);
+impl_call!((f32) -> i32: x: x.0);
+impl_call!((f32, f32) -> f32: x: x.0, x.1);
+impl_call!((f64, f64) -> f64: x: x.0, x.1);
+impl_call!((f64, i32) -> f64: x: x.0, x.1);
+impl_call!((f32, i32) -> f32: x: x.0, x.1);
+impl_call!((i32, f64) -> f64: x: x.0, x.1);
+impl_call!((i32, f32) -> f32: x: x.0, x.1);
+impl_call!((f32, f32, f32) -> f32: x: x.0, x.1, x.2);
+impl_call!((f64, f64, f64) -> f64: x: x.0, x.1, x.2);

crates/libm-test/tests/system_libm.rs

@@ -2,7 +2,7 @@
 #![cfg(test)]
 #![cfg(feature = "system_libm")]
 
-use libm_test::WithinUlps;
+use libm_test::{Call, WithinUlps};
 
 // Number of tests to generate for each function
 const NTESTS: usize = 500;
@@ -114,43 +114,6 @@ macro_rules! system_libm {
 
 libm_analyze::for_each_api!(system_libm);
 
-// This implements function dispatch for tuples of arguments used in the tests
-// above, so that we can: (f32, 32).call(fn(f32, f32) -> f32) generically.
-//
-// We need the input parameter F to support dispatching, e.g., (f32,f32) with
-// functions that return both f32 or i32. Those are two different types, so we
-// need to be parametric over them.
-trait Call<F> {
-    type Ret;
-    fn call(self, f: F) -> Self::Ret;
-}
-
-macro_rules! impl_call {
-    (($($arg_tys:ty),*) -> $ret_ty:ty: $self_:ident: $($xs:expr),*)  => {
-        // We only care about unsafe extern "C" functions here, safe functions coerce to them:
-        impl Call<unsafe extern"C" fn($($arg_tys),*) -> $ret_ty> for ($($arg_tys,)+) {
-            type Ret = $ret_ty;
-            fn call(self, f: unsafe extern "C" fn($($arg_tys),*) -> $ret_ty) -> Self::Ret {
-                let $self_ = self;
-                unsafe { f($($xs),*) }
-            }
-        }
-    };
-}
-
-impl_call!((f32) -> f32: x: x.0);
-impl_call!((f64) -> f64: x: x.0);
-impl_call!((f64) -> i32: x: x.0);
-impl_call!((f32) -> i32: x: x.0);
-impl_call!((f32, f32) -> f32: x: x.0, x.1);
-impl_call!((f64, f64) -> f64: x: x.0, x.1);
-impl_call!((f64, i32) -> f64: x: x.0, x.1);
-impl_call!((f32, i32) -> f32: x: x.0, x.1);
-impl_call!((i32, f64) -> f64: x: x.0, x.1);
-impl_call!((i32, f32) -> f32: x: x.0, x.1);
-impl_call!((f32, f32, f32) -> f32: x: x.0, x.1, x.2);
-impl_call!((f64, f64, f64) -> f64: x: x.0, x.1, x.2);
-
 // We need to be able to generate random numbers for the types involved.
 //
 // Rand does this well, but we want to also test some other specific values.