Make sure we don't talk about unstable things

Fixes #14

Author: steveklabnik

Diff for: .travis.yml

@@ -8,3 +8,4 @@ before_script:
 
 script: 
   - export PATH=$PATH:/home/travis/.cargo/bin && mdbook test
+  - cd stable-check && cargo run -- ../src

Diff for: src/expressions.md

@@ -308,25 +308,6 @@ let y = 0..10;
 assert_eq!(x, y);
 ```
 
-Similarly, the `...` operator will construct an object of one of the
-`std::ops::RangeInclusive` variants.
-
-```rust
-# #![feature(inclusive_range_syntax)]
-1...2;   // std::ops::RangeInclusive
-...4;    // std::ops::RangeToInclusive
-```
-
-The following expressions are equivalent.
-
-```rust
-# #![feature(inclusive_range_syntax, inclusive_range)]
-let x = std::ops::RangeInclusive::NonEmpty {start: 0, end: 10};
-let y = 0...10;
-
-assert_eq!(x, y);
-```
-
 ## Unary operator expressions
 
 Rust defines the following unary operators. With the exception of `?`, they are

Diff for: src/items.md

@@ -663,53 +663,6 @@ unsafe fn bump_levels_unsafe2() -> u32 {
 Mutable statics have the same restrictions as normal statics, except that the
 type of the value is not required to ascribe to `Sync`.
 
-#### `'static` lifetime elision
-
-[Unstable] Both constant and static declarations of reference types have
-*implicit* `'static` lifetimes unless an explicit lifetime is specified. As
-such, the constant declarations involving `'static` above may be written
-without the lifetimes. Returning to our previous example:
-
-```rust
-# #![feature(static_in_const)]
-const BIT1: u32 = 1 << 0;
-const BIT2: u32 = 1 << 1;
-
-const BITS: [u32; 2] = [BIT1, BIT2];
-const STRING: &str = "bitstring";
-
-struct BitsNStrings<'a> {
-    mybits: [u32; 2],
-    mystring: &'a str,
-}
-
-const BITS_N_STRINGS: BitsNStrings = BitsNStrings {
-    mybits: BITS,
-    mystring: STRING,
-};
-```
-
-Note that if the `static` or `const` items include function or closure
-references, which themselves include references, the compiler will first try the
-standard elision rules ([see discussion in the nomicon][elision-nomicon]). If it
-is unable to resolve the lifetimes by its usual rules, it will default to using
-the `'static` lifetime. By way of example:
-
-[elision-nomicon]: ../nomicon/lifetime-elision.html
-
-```rust,ignore
-// Resolved as `fn<'a>(&'a str) -> &'a str`.
-const RESOLVED_SINGLE: fn(&str) -> &str = ..
-
-// Resolved as `Fn<'a, 'b, 'c>(&'a Foo, &'b Bar, &'c Baz) -> usize`.
-const RESOLVED_MULTIPLE: Fn(&Foo, &Bar, &Baz) -> usize = ..
-
-// There is insufficient information to bound the return reference lifetime
-// relative to the argument lifetimes, so the signature is resolved as
-// `Fn(&'static Foo, &'static Bar) -> &'static Baz`.
-const RESOLVED_STATIC: Fn(&Foo, &Bar) -> &Baz = ..
-```
-
 ### Traits
 
 A _trait_ describes an abstract interface that types can

Diff for: stable-check/.gitignore

@@ -0,0 +1 @@
+target

Diff for: stable-check/Cargo.lock

@@ -0,0 +1,6 @@
+[package]
+name = "stable-check"
+version = "0.1.0"
+authors = ["steveklabnik <steve@steveklabnik.com>"]
+
+[dependencies]

Diff for: stable-check/Cargo.toml

@@ -0,0 +1,46 @@
+use std::error::Error;
+use std::env;
+use std::fs;
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::Path;
+
+fn main() {
+    let arg = env::args().nth(1).unwrap_or_else(|| {
+        println!("Please pass a src directory as the first argument");
+        std::process::exit(1);
+    });
+
+    match check_directory(&Path::new(&arg)) {
+        Ok(()) => println!("passed!"),
+        Err(e) => {
+            println!("Error: {}", e);
+            std::process::exit(1);
+        }
+    }
+
+}
+
+fn check_directory(dir: &Path) -> Result<(), Box<Error>> {
+    for entry in fs::read_dir(dir)? {
+        let entry = entry?;
+        let path = entry.path();
+
+        if path.is_dir() {
+            continue;
+        }
+
+        let mut file = File::open(&path)?;
+        let mut contents = String::new();
+        file.read_to_string(&mut contents)?;
+
+        if contents.contains("#![feature") {
+            // attributes.md contains this and it is legitimate
+            if !contents.contains("#![feature(feature1, feature2, feature3)]") {
+                return Err(From::from(format!("Feature flag found in {:?}", path)));
+            }
+        }
+    }
+
+    Ok(())
+}