Require rust >= 1.37 and drop libc_underscore_const_names conditional

[ adjust for ctest limitations - Trevor ]

Author: joshtriplett

build.rs

@@ -19,7 +19,6 @@ const ALLOWED_CFGS: &'static [&'static str] = &[
     "libc_deny_warnings",
     "libc_long_array",
     "libc_thread_local",
-    "libc_underscore_const_names",
     "libc_ctest",
 ];
 
@@ -86,11 +85,6 @@ fn main() {
         set_cfg("libc_long_array");
     }
 
-    // Rust >= 1.37.0 allows underscores as anonymous constant names.
-    if rustc_minor_ver >= 37 || rustc_dep_of_std {
-        set_cfg("libc_underscore_const_names");
-    }
-
     // #[thread_local] is currently unstable
     if rustc_dep_of_std {
         set_cfg("libc_thread_local");

src/fixed_width_ints.rs

@@ -60,40 +60,46 @@ cfg_if! {
         pub type __uint128_t = u128;
 
         cfg_if! {
-            if #[cfg(libc_underscore_const_names)] {
+            if #[cfg(libc_ctest)] {
+                // FIXME(ctest): ctest does not accept `_` as an identifier
+                macro_rules! static_assert_eq {
+                    ($a:expr, $b:expr) => {};
+                }
+            } else {
                 macro_rules! static_assert_eq {
                     ($a:expr, $b:expr) => {
                         const _: [(); $a] = [(); $b];
                     };
                 }
+            }
+
+        }
 
-                // NOTE: if you add more platforms to here, you may need to cfg
-                // these consts. They should always match the platform's values
-                // for `sizeof(__int128)` and `_Alignof(__int128)`.
-                const _SIZE_128: usize = 16;
-                const _ALIGN_128: usize = 16;
+        // NOTE: if you add more platforms to here, you may need to cfg
+        // these consts. They should always match the platform's values
+        // for `sizeof(__int128)` and `_Alignof(__int128)`.
+        const _SIZE_128: usize = 16;
+        const _ALIGN_128: usize = 16;
 
-                // Since Rust doesn't officially guarantee that these types
-                // have compatible ABIs, we const assert that these values have the
-                // known size/align of the target platform's libc. If rustc ever
-                // tries to regress things, it will cause a compilation error.
-                //
-                // This isn't a bullet-proof solution because e.g. it doesn't
-                // catch the fact that llvm and gcc disagree on how x64 __int128
-                // is actually *passed* on the stack (clang underaligns it for
-                // the same reason that rustc *never* properly aligns it).
-                static_assert_eq!(core::mem::size_of::<__int128>(), _SIZE_128);
-                static_assert_eq!(core::mem::align_of::<__int128>(), _ALIGN_128);
+        // Since Rust doesn't officially guarantee that these types
+        // have compatible ABIs, we const assert that these values have the
+        // known size/align of the target platform's libc. If rustc ever
+        // tries to regress things, it will cause a compilation error.
+        //
+        // This isn't a bullet-proof solution because e.g. it doesn't
+        // catch the fact that llvm and gcc disagree on how x64 __int128
+        // is actually *passed* on the stack (clang underaligns it for
+        // the same reason that rustc *never* properly aligns it).
+        static_assert_eq!(core::mem::size_of::<__int128>(), _SIZE_128);
+        static_assert_eq!(core::mem::align_of::<__int128>(), _ALIGN_128);
 
-                static_assert_eq!(core::mem::size_of::<__uint128>(), _SIZE_128);
-                static_assert_eq!(core::mem::align_of::<__uint128>(), _ALIGN_128);
+        static_assert_eq!(core::mem::size_of::<__uint128>(), _SIZE_128);
+        static_assert_eq!(core::mem::align_of::<__uint128>(), _ALIGN_128);
 
-                static_assert_eq!(core::mem::size_of::<__int128_t>(), _SIZE_128);
-                static_assert_eq!(core::mem::align_of::<__int128_t>(), _ALIGN_128);
+        static_assert_eq!(core::mem::size_of::<__int128_t>(), _SIZE_128);
+        static_assert_eq!(core::mem::align_of::<__int128_t>(), _ALIGN_128);
 
-                static_assert_eq!(core::mem::size_of::<__uint128_t>(), _SIZE_128);
-                static_assert_eq!(core::mem::align_of::<__uint128_t>(), _ALIGN_128);
-            }
-        }
+        static_assert_eq!(core::mem::size_of::<__uint128_t>(), _SIZE_128);
+        static_assert_eq!(core::mem::align_of::<__uint128_t>(), _ALIGN_128);
     }
 }