remove feature thanks to @petrochenkov

Author: steveklabnik

_posts/2017-03-16-Rust-1.16.md

@@ -41,25 +41,25 @@ time: 0.049; rss: 34MB  expansion
 <snip>
  ```
 
- There's a lot of them. However, you can think of this process in two big steps: first, `rustc` does
- all of its safety checks, makes sure your syntax is correct, all that stuff. Second, once it's satisfied
- that everything is in order, it produces the actual binary code that you end up executing.
+There's a lot of them. However, you can think of this process in two big steps: first, `rustc` does
+all of its safety checks, makes sure your syntax is correct, all that stuff. Second, once it's satisfied
+that everything is in order, it produces the actual binary code that you end up executing.
 
- It turns out that that second step takes a lot of time. And most of the time, it's not neccesary. That is,
- when you're working on some Rust code, many developers will get into a workflow like this:
+It turns out that that second step takes a lot of time. And most of the time, it's not neccesary. That is,
+when you're working on some Rust code, many developers will get into a workflow like this:
 
  1. Write some code.
  2. Run `cargo build` to make sure it compiles.
  3. Repeat 1-2 as needed.
  4. Run `cargo test` to make sure your tests pass.
  5. GOTO 1.
 
- In step two, you never actually run your code. You're looking for feedback from the compiler, not to
- actually run the binary. `cargo check` supports exactly this use-case: it runs all of the compiler's
- checks, but doesn't produce the final binary.
+In step two, you never actually run your code. You're looking for feedback from the compiler, not to
+actually run the binary. `cargo check` supports exactly this use-case: it runs all of the compiler's
+checks, but doesn't produce the final binary.
 
- So how much speedup do you actually get? Like most performance related questions, the answer is "it
- depends." Here are some very un-scientific benchmarks:
+So how much speedup do you actually get? Like most performance related questions, the answer is "it
+depends." Here are some very un-scientific benchmarks:
 
 |        | initial build | initial check | speedup | secondary build | secondary check | speedup |
 |--------|---------------|---------------|---------|-----------------|-----------------|---------|
@@ -201,11 +201,6 @@ results in a significant improvement in these sorts of diagnostics.
 [This now happens nearly everywhere]: https://github.com/rust-lang/rust/pull/38927
 [some other related improvements]: https://github.com/rust-lang/rust/pull/38154
 
-Finally, `Self` can now appear [in impl headers] and [in struct expressions].
-
-[in impl headers]: https://github.com/rust-lang/rust/pull/38920
-[in struct expressions]: https://github.com/rust-lang/rust/pull/39282
-
 See the [detailed release notes][notes] for more.
 
 #### Library stabilizations