Automatically use the allocation-free API for Rust 1.27.0+.

1.27.0 stabilized hint::unreachable, allowing the previously
nightly-only API to be used on stable.

The version detection can still be overridden using `cfg`s
(or their related environment variables through cargo), and both
the nightly and spin_no_std features are preserved for compatibility.

Author: anp

.travis.yml

@@ -11,6 +11,8 @@ matrix:
         - cargo bench
         - cargo test --features nightly
         - cargo bench --features nightly
+        - CARGO_CFG_LAZY_STATIC_HEAP_IMPL=1 cargo test
+        - CARGO_CFG_LAZY_STATIC_HEAP_IMPL=1 cargo bench
         - cargo test --features spin_no_std
         - cargo bench --features spin_no_std
         - cd compiletest

Cargo.toml

@@ -13,10 +13,15 @@ repository = "https://github.com/rust-lang-nursery/lazy-static.rs"
 keywords = ["macro", "lazy", "static"]
 categories = [ "no-std", "rust-patterns", "memory-management" ]
 
+build = "build.rs"
+
 [dependencies.spin]
 version = "0.4.6"
 optional = true
 
+[build-dependencies]
+rustc_version = "0.2.2"
+
 [features]
 nightly = []
 spin_no_std = ["nightly", "spin"]

build.rs

@@ -0,0 +1,46 @@
+extern crate rustc_version;
+
+use rustc_version::{version, Version};
+
+fn main() {
+    let is_var_set = |s| std::env::var_os(s).is_some();
+
+    // one can manually set a cfg to force an impl -- mostly useful for our own testing
+    let force_heap_cfg = is_var_set("CARGO_CFG_LAZY_STATIC_HEAP_IMPL");
+    let force_inline_cfg = is_var_set("CARGO_CFG_LAZY_STATIC_INLINE_IMPL");
+    let force_spin_cfg = is_var_set("CARGO_CFG_LAZY_STATIC_SPIN_IMPL");
+
+    let impls_forced = [force_heap_cfg, force_inline_cfg, force_spin_cfg]
+        .into_iter()
+        .filter(|&&f| f)
+        .count();
+
+    assert!(
+        impls_forced <= 1,
+        "lazy_static can only be built with one configuration at a time."
+    );
+
+    let nightly_feature_enabled = is_var_set("CARGO_FEATURE_NIGHTLY");
+    let spin_feature_enabled = is_var_set("CARGO_FEATURE_SPIN_NO_STD");
+
+    let version_geq_127 = version().unwrap() >= Version::new(1, 27, 0);
+    let unreachable_hint_supported = version_geq_127 || nightly_feature_enabled;
+
+    // precedence:
+    // 1. explicit requests via cfg or spin_no_std feature
+    // 2. inline impl with newer rustc version or nightly feature (latter for backcompat)
+    // 3. fallback to allocating implementation
+    let impl_name = if force_heap_cfg {
+        "heap"
+    } else if force_inline_cfg {
+        "inline"
+    } else if force_spin_cfg || spin_feature_enabled {
+        "spin"
+    } else if unreachable_hint_supported {
+        "inline"
+    } else {
+        "heap"
+    };
+
+    println!("cargo:rustc-cfg=lazy_static_{}_impl", impl_name);
+}

src/lazy.rs src/heap_lazy.rssrc/lazy.rs renamed to src/heap_lazy.rs

@@ -100,22 +100,23 @@ no guarantees can be made about them in regard to SemVer stability.
 
 */
 
-#![cfg_attr(feature="spin_no_std", feature(const_fn))]
-#![cfg_attr(feature="nightly", feature(unreachable))]
+// NOTE: see build.rs for where these cfg values are set.
+#![cfg_attr(lazy_static_spin_impl, feature(const_fn))]
 
 #![doc(html_root_url = "https://docs.rs/lazy_static/1.0.1")]
 #![no_std]
 
-#[cfg(not(feature="nightly"))]
+#[cfg(lazy_static_heap_impl)]
+#[path="heap_lazy.rs"]
 #[doc(hidden)]
 pub mod lazy;
 
-#[cfg(all(feature="nightly", not(feature="spin_no_std")))]
-#[path="nightly_lazy.rs"]
+#[cfg(lazy_static_inline_impl)]
+#[path="inline_lazy.rs"]
 #[doc(hidden)]
 pub mod lazy;
 
-#[cfg(all(feature="nightly", feature="spin_no_std"))]
+#[cfg(lazy_static_spin_impl)]
 #[path="core_lazy.rs"]
 #[doc(hidden)]
 pub mod lazy;

src/nightly_lazy.rs src/inline_lazy.rssrc/nightly_lazy.rs renamed to src/inline_lazy.rs

@@ -1,5 +1,3 @@
-#![cfg_attr(feature="nightly", feature(const_fn))]
-
 #[macro_use]
 extern crate lazy_static;
 use std::collections::HashMap;