add lazy-static subtree

11 files changed, 523 insertions, 0 deletions

diff --git a/third_party/lazy-static.rs/.gitignore b/third_party/lazy-static.rs/.gitignore
new file mode 100644
index 0000000..bde55ce
--- /dev/null
+++ b/third_party/lazy-static.rs/.gitignore
@@ -0,0 +1,4 @@
+target
+doc
+Cargo.lock
+.cargo
diff --git a/third_party/lazy-static.rs/.travis.yml b/third_party/lazy-static.rs/.travis.yml
new file mode 100644
index 0000000..2280263
--- /dev/null
+++ b/third_party/lazy-static.rs/.travis.yml
@@ -0,0 +1,24 @@
+language: rust
+rust:
+- nightly
+- beta
+- stable
+before_script:
+- |
+  pip install 'travis-cargo<0.2' --user &&
+  export PATH=$HOME/.local/bin:$PATH
+script:
+- |
+  travis-cargo build &&
+  travis-cargo test &&
+  travis-cargo bench &&
+  travis-cargo --only nightly build -- --features spin_no_std &&
+  travis-cargo --only nightly test -- --features spin_no_std &&
+  travis-cargo --only nightly bench -- --features spin_no_std &&
+  travis-cargo --only stable doc
+after_success:
+- travis-cargo --only stable doc-upload
+env:
+  global:
+  - TRAVIS_CARGO_NIGHTLY_FEATURE=nightly
+  - secure: YXu24LptjeYirjWYjWGsMT2m3mB7LvQATE6TVo7VEUXv8GYoy2ORIHD83PeImxC93MmZ01QeUezRzuCW51ZcK92VnNSBttlF60SvIX18VsJrV92tsAhievFstqYQ+fB8DIuQ8noU0jPz7GpI+R9dlTRSImAqWOnVIghA+Wzz7Js=
diff --git a/third_party/lazy-static.rs/Cargo.toml b/third_party/lazy-static.rs/Cargo.toml
new file mode 100644
index 0000000..2d4c91b
--- /dev/null
+++ b/third_party/lazy-static.rs/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "lazy_static"
+version = "0.2.1"
+authors = ["Marvin Löbel <loebel.marvin@gmail.com>"]
+license = "MIT"
+
+description = "A macro for declaring lazily evaluated statics in Rust."
+readme = "README.md"
+documentation = "http://rust-lang-nursery.github.io/lazy-static.rs/lazy_static/index.html"
+
+repository = "https://github.com/rust-lang-nursery/lazy-static.rs"
+keywords = ["macro", "lazy", "static"]
+
+[dependencies.spin]
+version = "0.4"
+optional = true
+
+[features]
+nightly = []
+spin_no_std = ["nightly", "spin"]
diff --git a/third_party/lazy-static.rs/LICENSE b/third_party/lazy-static.rs/LICENSE
new file mode 100644
index 0000000..d442558
--- /dev/null
+++ b/third_party/lazy-static.rs/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Marvin Löbel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/third_party/lazy-static.rs/README.md b/third_party/lazy-static.rs/README.md
new file mode 100644
index 0000000..434589c
--- /dev/null
+++ b/third_party/lazy-static.rs/README.md
@@ -0,0 +1,81 @@
+lazy-static.rs
+==============
+
+[![Travis-CI Status](https://travis-ci.org/rust-lang-nursery/lazy-static.rs.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/lazy-static.rs)
+
+A macro for declaring lazily evaluated statics in Rust.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires function calls to be computed.
+
+# Syntax
+
+```rust
+lazy_static! {
+    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
+    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
+    ...
+    [pub] static ref NAME_N: TYPE_N = EXPR_N;
+}
+```
+
+# Semantic
+
+For a given `static ref NAME: TYPE = EXPR;`, the macro generates a
+unique type that implements `Deref<TYPE>` and stores it in a static with name `NAME`.
+
+On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
+can return a reference to the same object.
+
+Like regular `static mut`s, this macro only works for types that fulfill the `Sync`
+trait.
+
+# Getting Started
+
+[lazy-static.rs is available on crates.io](https://crates.io/crates/lazy_static).
+Add the following dependency to your Cargo manifest to get the latest version of the 0.1 branch:
+
+```toml
+[dependencies]
+lazy_static = "0.1.*"
+```
+
+To always get the latest version, add this git repository to your
+Cargo manifest:
+
+```toml
+[dependencies.lazy_static]
+git = "https://github.com/rust-lang-nursery/lazy-static.rs"
+```
+# Example
+
+Using the macro:
+
+```rust
+#[macro_use]
+extern crate lazy_static;
+
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+    static ref COUNT: usize = HASHMAP.len();
+    static ref NUMBER: u32 = times_two(21);
+}
+
+fn times_two(n: u32) -> u32 { n * 2 }
+
+fn main() {
+    println!("The map has {} entries.", *COUNT);
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+    println!("An expensive calculation on a static results in: {}.", *NUMBER);
+}
+```
diff --git a/third_party/lazy-static.rs/src/core_lazy.rs b/third_party/lazy-static.rs/src/core_lazy.rs
new file mode 100644
index 0000000..20290d9
--- /dev/null
+++ b/third_party/lazy-static.rs/src/core_lazy.rs
@@ -0,0 +1,27 @@
+extern crate spin;
+
+use self::spin::Once;
+
+pub struct Lazy<T: Sync>(Once<T>);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub const fn new() -> Self {
+        Lazy(Once::new())
+    }
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, builder: F) -> &T
+        where F: FnOnce() -> T
+    {
+        self.0.call_once(builder)
+    }
+}
+
+#[macro_export]
+#[allow_internal_unstable]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::new();
+    }
+}
diff --git a/third_party/lazy-static.rs/src/lazy.rs b/third_party/lazy-static.rs/src/lazy.rs
new file mode 100644
index 0000000..c7e6cef
--- /dev/null
+++ b/third_party/lazy-static.rs/src/lazy.rs
@@ -0,0 +1,32 @@
+extern crate std;
+
+use self::std::prelude::v1::*;
+use self::std::sync::Once;
+
+pub struct Lazy<T: Sync>(pub *const T, pub Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub fn get<F>(&'static mut self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        unsafe {
+            let r = &mut self.0;
+            self.1.call_once(|| {
+                *r = Box::into_raw(Box::new(f()));
+            });
+
+            &*self.0
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        use std::sync::ONCE_INIT;
+        static mut $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy(0 as *const $T, ONCE_INIT);
+    }
+}
diff --git a/third_party/lazy-static.rs/src/lib.rs b/third_party/lazy-static.rs/src/lib.rs
new file mode 100644
index 0000000..4837066
--- /dev/null
+++ b/third_party/lazy-static.rs/src/lib.rs
@@ -0,0 +1,137 @@
+/*!
+A macro for declaring lazily evaluated statics.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires function calls to be computed.
+
+# Syntax
+
+```ignore
+lazy_static! {
+    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
+    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
+    ...
+    [pub] static ref NAME_N: TYPE_N = EXPR_N;
+}
+```
+
+Metadata (such as doc comments) is allowed on each ref.
+
+# Semantic
+
+For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
+implements `Deref<TYPE>` and stores it in a static with name `NAME`. (Metadata ends up
+attaching to this type.)
+
+On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
+can return a reference to the same object.
+
+Like regular `static mut`s, this macro only works for types that fulfill the `Sync`
+trait.
+
+# Example
+
+Using the macro:
+
+```rust
+#[macro_use]
+extern crate lazy_static;
+
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+    static ref COUNT: usize = HASHMAP.len();
+    static ref NUMBER: u32 = times_two(21);
+}
+
+fn times_two(n: u32) -> u32 { n * 2 }
+
+fn main() {
+    println!("The map has {} entries.", *COUNT);
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+    println!("A expensive calculation on a static results in: {}.", *NUMBER);
+}
+```
+
+# Implementation details
+
+The `Deref` implementation uses a hidden static variable that is guarded by a atomic check on each access. On stable Rust, the macro may need to allocate each static on the heap.
+
+*/
+
+#![cfg_attr(feature="nightly", feature(const_fn, allow_internal_unstable, core_intrinsics))]
+
+#![no_std]
+
+#[cfg(not(feature="nightly"))]
+pub mod lazy;
+
+#[cfg(all(feature="nightly", not(feature="spin_no_std")))]
+#[path="nightly_lazy.rs"]
+pub mod lazy;
+
+#[cfg(all(feature="nightly", feature="spin_no_std"))]
+#[path="core_lazy.rs"]
+pub mod lazy;
+
+pub use core::ops::Deref as __Deref;
+
+#[macro_export]
+#[cfg_attr(feature="nightly", allow_internal_unstable)]
+macro_rules! lazy_static {
+    ($(#[$attr:meta])* static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        lazy_static!(@PRIV, $(#[$attr])* static ref $N : $T = $e; $($t)*);
+    };
+    ($(#[$attr:meta])* pub static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        lazy_static!(@PUB, $(#[$attr])* static ref $N : $T = $e; $($t)*);
+    };
+    (@$VIS:ident, $(#[$attr:meta])* static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        lazy_static!(@MAKE TY, $VIS, $(#[$attr])*, $N);
+        impl $crate::__Deref for $N {
+            type Target = $T;
+            #[allow(unsafe_code)]
+            fn deref<'a>(&'a self) -> &'a $T {
+                unsafe {
+                    #[inline(always)]
+                    fn __static_ref_initialize() -> $T { $e }
+
+                    #[inline(always)]
+                    unsafe fn __stability() -> &'static $T {
+                        __lazy_static_create!(LAZY, $T);
+                        LAZY.get(__static_ref_initialize)
+                    }
+                    __stability()
+                }
+            }
+        }
+        lazy_static!($($t)*);
+    };
+    (@MAKE TY, PUB, $(#[$attr:meta])*, $N:ident) => {
+        #[allow(missing_copy_implementations)]
+        #[allow(non_camel_case_types)]
+        #[allow(dead_code)]
+        $(#[$attr])*
+        pub struct $N {__private_field: ()}
+        #[doc(hidden)]
+        pub static $N: $N = $N {__private_field: ()};
+    };
+    (@MAKE TY, PRIV, $(#[$attr:meta])*, $N:ident) => {
+        #[allow(missing_copy_implementations)]
+        #[allow(non_camel_case_types)]
+        #[allow(dead_code)]
+        $(#[$attr])*
+        struct $N {__private_field: ()}
+        #[doc(hidden)]
+        static $N: $N = $N {__private_field: ()};
+    };
+    () => ()
+}
diff --git a/third_party/lazy-static.rs/src/nightly_lazy.rs b/third_party/lazy-static.rs/src/nightly_lazy.rs
new file mode 100644
index 0000000..5f7a110
--- /dev/null
+++ b/third_party/lazy-static.rs/src/nightly_lazy.rs
@@ -0,0 +1,40 @@
+extern crate std;
+
+use self::std::prelude::v1::*;
+use self::std::cell::UnsafeCell;
+use self::std::sync::{Once, ONCE_INIT};
+
+pub struct Lazy<T: Sync>(UnsafeCell<Option<T>>, Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub const fn new() -> Self {
+        Lazy(UnsafeCell::new(None), ONCE_INIT)
+    }
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        unsafe {
+            self.1.call_once(|| {
+                *self.0.get() = Some(f());
+            });
+
+            match *self.0.get() {
+                Some(ref x) => x,
+                None => std::intrinsics::unreachable(),
+            }
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+#[allow_internal_unstable]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::new();
+    }
+}
diff --git a/third_party/lazy-static.rs/tests/no_std.rs b/third_party/lazy-static.rs/tests/no_std.rs
new file mode 100644
index 0000000..b460e79
--- /dev/null
+++ b/third_party/lazy-static.rs/tests/no_std.rs
@@ -0,0 +1,21 @@
+#![cfg(feature="spin_no_std")]
+#![feature(const_fn)]
+
+#![no_std]
+
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(*NUMBER, 6);
+}
diff --git a/third_party/lazy-static.rs/tests/test.rs b/third_party/lazy-static.rs/tests/test.rs
new file mode 100644
index 0000000..71d22e3
--- /dev/null
+++ b/third_party/lazy-static.rs/tests/test.rs
@@ -0,0 +1,116 @@
+#![cfg_attr(feature="nightly", feature(const_fn))]
+
+#[macro_use]
+extern crate lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+
+    static ref ARRAY_BOXES: [Box<u32>; 3] = [Box::new(1), Box::new(2), Box::new(3)];
+
+    /// More documentation!
+    #[allow(unused_variables)]
+    #[derive(Copy, Clone, Debug)]
+    pub static ref STRING: String = "hello".to_string();
+
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "abc");
+        m.insert(1, "def");
+        m.insert(2, "ghi");
+        m
+    };
+
+    // This should not compile if the unsafe is removed.
+    static ref UNSAFE: u32 = unsafe {
+        std::mem::transmute::<i32, u32>(-1)
+    };
+
+    // This *should* triggger warn(dead_code) by design.
+    static ref UNUSED: () = ();
+
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(&**STRING, "hello");
+    assert_eq!(*NUMBER, 6);
+    assert!(HASHMAP.get(&1).is_some());
+    assert!(HASHMAP.get(&3).is_none());
+    assert_eq!(&*ARRAY_BOXES, &[Box::new(1), Box::new(2), Box::new(3)]);
+    assert_eq!(*UNSAFE, std::u32::MAX);
+}
+
+#[test]
+fn test_repeat() {
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+}
+
+#[test]
+fn test_meta() {
+    // this would not compile if STRING were not marked #[derive(Copy, Clone)]
+    let copy_of_string = STRING;
+    // just to make sure it was copied
+    assert!(&STRING as *const _ != &copy_of_string as *const _);
+
+    // this would not compile if STRING were not marked #[derive(Debug)]
+    assert_eq!(format!("{:?}", STRING), "STRING { __private_field: () }".to_string());
+}
+
+mod visibility {
+    lazy_static! {
+        pub static ref FOO: Box<u32> = Box::new(0);
+        static ref BAR: Box<u32> = Box::new(98);
+    }
+
+    #[test]
+    fn sub_test() {
+        assert_eq!(**FOO, 0);
+        assert_eq!(**BAR, 98);
+    }
+}
+
+#[test]
+fn test_visibility() {
+    assert_eq!(*visibility::FOO, Box::new(0));
+}
+
+// This should not cause a warning about a missing Copy implementation
+lazy_static! {
+    pub static ref VAR: i32 = { 0 };
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+struct X;
+struct Once(X);
+const ONCE_INIT: Once = Once(X);
+static DATA: X = X;
+static ONCE: X = X;
+fn require_sync() -> X { X }
+fn transmute() -> X { X }
+fn __static_ref_initialize() -> X { X }
+fn test(_: Vec<X>) -> X { X }
+
+// All these names should not be shadowed
+lazy_static! {
+    static ref ITEM_NAME_TEST: X = {
+        test(vec![X, Once(X).0, ONCE_INIT.0, DATA, ONCE,
+                  require_sync(), transmute(),
+                  // Except this, which will sadly be shadowed by internals:
+                  // __static_ref_initialize()
+                  ])
+    };
+}
+
+#[test]
+fn item_name_shadowing() {
+    assert_eq!(*ITEM_NAME_TEST, X);
+}