Merge with more recent updates

Author: matthewjasper

.gitattributes

@@ -0,0 +1,2 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+* text=auto eol=lf

.travis.yml

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

src/SUMMARY.md

@@ -16,7 +16,7 @@
 
 - [Macros](macros.md)
     - [Macros By Example](macros-by-example.md)
-    - [Procedrual Macros](procedural-macros.md)
+    - [Procedural Macros](procedural-macros.md)
 
 - [Crates and source files](crates-and-source-files.md)
 
@@ -56,3 +56,5 @@
     - [Behavior not considered unsafe](behavior-not-considered-unsafe.md)
 
 [Appendix: Influences](influences.md)
+
+[Appendix: As-yet-undocumented Features](undocumented.md)

src/attributes.md

@@ -64,6 +64,15 @@ type int8_t = i8;
                       infinitely-recursive compile-time operations like
                       auto-dereference or macro expansion. The default is
                       `#![recursion_limit="64"]`.
+- `windows_subsystem` - Indicates that when this crate is linked for a Windows
+                        target it will configure the resulting binary's
+                        [subsystem] via the linker. Valid values for this
+                        attribute are `console` and `windows`, corresponding to
+                        those two respective subsystems. More subsystems may be
+                        allowed in the future, and this attribute is ignored on
+                        non-Windows targets.
+
+[subsystem]: https://msdn.microsoft.com/en-us/library/fcc1zstk.aspx
 
 ### Module-only attributes
 
@@ -84,6 +93,7 @@ type int8_t = i8;
   item](#language-items) for more details.
 - `test` - indicates that this function is a test function, to only be compiled
   in case of `--test`.
+  - `ignore` - indicates that this test function is disabled.
 - `should_panic` - indicates that this test function should panic, inverting the success condition.
 - `cold` - The function is unlikely to be executed, so optimize it (and calls
   to it) differently.
@@ -149,7 +159,7 @@ On `struct`s:
   list of names `#[macro_use(foo, bar)]` restricts the import to just those
   macros named.  The `extern crate` must appear at the crate root, not inside
   `mod`, which ensures proper function of the [`$crate` macro
-  variable](../book/macros.html#the-variable-crate).
+  variable](../book/first-edition/macros.html#the-variable-crate).
 
 - `macro_reexport` on an `extern crate` — re-export the named macros.
 
@@ -159,7 +169,7 @@ On `struct`s:
   link it into the output.
 
 See the [macros section of the
-book](../book/macros.html#scoping-and-macro-importexport) for more information on
+book](../book/first-edition/macros.html#scoping-and-macro-importexport) for more information on
 macro scope.
 
 ## Miscellaneous attributes
@@ -317,8 +327,7 @@ For any lint check `C`:
 
 The lint checks supported by the compiler can be found via `rustc -W help`,
 along with their default settings.  [Compiler
-plugins](../unstable-book/plugin.html#lint-plugins) can provide additional
-lint checks.
+plugins][unstable book plugin] can provide additional lint checks.
 
 ```rust,ignore
 pub mod m1 {
@@ -463,160 +472,8 @@ This directive informs the compiler that the feature list: `feature1`,
 crate-level, not at a module-level. Without this directive, all features are
 considered off, and using the features will result in a compiler error.
 
-The currently implemented features of the reference compiler are:
-
-* `advanced_slice_patterns` - See the [match
-                              expressions](expressions.html#match-expressions)
-			      section for discussion; the exact semantics of
-slice patterns are subject to change, so some types are still unstable.
-
-* `slice_patterns` - OK, actually, slice patterns are just scary and
-                     completely unstable.
-
-* `asm` - The `asm!` macro provides a means for inline assembly. This is often
-          useful, but the exact syntax for this feature along with its
-          semantics are likely to change, so this macro usage must be opted
-          into.
-
-* `associated_consts` - Allows constants to be defined in `impl` and `trait`
-                        blocks, so that they can be associated with a type or
-                        trait in a similar manner to methods and associated
-                        types.
-
-* `box_patterns` - Allows `box` patterns, the exact semantics of which
-                   is subject to change.
-
-* `box_syntax` - Allows use of `box` expressions, the exact semantics of which
-                 is subject to change.
-
-* `cfg_target_vendor` - Allows conditional compilation using the `target_vendor`
-                        matcher which is subject to change.
-
-* `cfg_target_has_atomic` - Allows conditional compilation using the `target_has_atomic`
-                            matcher which is subject to change.
-
-* `concat_idents` - Allows use of the `concat_idents` macro, which is in many
-                    ways insufficient for concatenating identifiers, and may be
-                    removed entirely for something more wholesome.
-
-* `custom_attribute` - Allows the usage of attributes unknown to the compiler
-                       so that new attributes can be added in a backwards compatible
-                       manner (RFC 572).
-
-* `custom_derive` - Allows the use of `#[derive(Foo,Bar)]` as sugar for
-                    `#[derive_Foo] #[derive_Bar]`, which can be user-defined syntax
-                    extensions.
-
-* `inclusive_range_syntax` - Allows use of the `a...b` and `...b` syntax for inclusive ranges.
-
-* `inclusive_range` - Allows use of the types that represent desugared inclusive ranges.
-
-* `intrinsics` - Allows use of the "rust-intrinsics" ABI. Compiler intrinsics
-                 are inherently unstable and no promise about them is made.
-
-* `lang_items` - Allows use of the `#[lang]` attribute. Like `intrinsics`,
-                 lang items are inherently unstable and no promise about them
-                 is made.
-
-* `link_args` - This attribute is used to specify custom flags to the linker,
-                but usage is strongly discouraged. The compiler's usage of the
-                system linker is not guaranteed to continue in the future, and
-                if the system linker is not used then specifying custom flags
-                doesn't have much meaning.
-
-* `link_llvm_intrinsics` - Allows linking to LLVM intrinsics via
-                           `#[link_name="llvm.*"]`.
-
-* `linkage` - Allows use of the `linkage` attribute, which is not portable.
-
-* `log_syntax` - Allows use of the `log_syntax` macro attribute, which is a
-                 nasty hack that will certainly be removed.
-
-* `main` - Allows use of the `#[main]` attribute, which changes the entry point
-           into a Rust program. This capability is subject to change.
-
-* `macro_reexport` - Allows macros to be re-exported from one crate after being imported
-                     from another. This feature was originally designed with the sole
-                     use case of the Rust standard library in mind, and is subject to
-                     change.
-
-* `non_ascii_idents` - The compiler supports the use of non-ascii identifiers,
-                       but the implementation is a little rough around the
-                       edges, so this can be seen as an experimental feature
-                       for now until the specification of identifiers is fully
-                       fleshed out.
-
-* `no_std` - Allows the `#![no_std]` crate attribute, which disables the implicit
-             `extern crate std`. This typically requires use of the unstable APIs
-             behind the libstd "facade", such as libcore and libcollections. It
-             may also cause problems when using syntax extensions, including
-             `#[derive]`.
-
-* `on_unimplemented` - Allows the `#[rustc_on_unimplemented]` attribute, which allows
-                       trait definitions to add specialized notes to error messages
-                       when an implementation was expected but not found.
-
-* `optin_builtin_traits` - Allows the definition of default and negative trait
-                           implementations. Experimental.
-
-* `plugin` - Usage of [compiler plugins][plugin] for custom lints or syntax extensions.
-             These depend on compiler internals and are subject to change.
-
-* `plugin_registrar` - Indicates that a crate provides [compiler plugins][plugin].
-
-* `quote` - Allows use of the `quote_*!` family of macros, which are
-            implemented very poorly and will likely change significantly
-            with a proper implementation.
-
-* `rustc_attrs` - Gates internal `#[rustc_*]` attributes which may be
-                  for internal use only or have meaning added to them in the future.
-
-* `rustc_diagnostic_macros`- A mysterious feature, used in the implementation
-                             of rustc, not meant for mortals.
-
-* `simd` - Allows use of the `#[simd]` attribute, which is overly simple and
-           not the SIMD interface we want to expose in the long term.
-
-* `simd_ffi` - Allows use of SIMD vectors in signatures for foreign functions.
-               The SIMD interface is subject to change.
-
-* `start` - Allows use of the `#[start]` attribute, which changes the entry point
-            into a Rust program. This capability, especially the signature for the
-            annotated function, is subject to change.
-
-* `thread_local` - The usage of the `#[thread_local]` attribute is experimental
-                   and should be seen as unstable. This attribute is used to
-                   declare a `static` as being unique per-thread leveraging
-                   LLVM's implementation which works in concert with the kernel
-                   loader and dynamic linker. This is not necessarily available
-                   on all platforms, and usage of it is discouraged.
-
-* `trace_macros` - Allows use of the `trace_macros` macro, which is a nasty
-                   hack that will certainly be removed.
-
-* `unboxed_closures` - Rust's new closure design, which is currently a work in
-                       progress feature with many known bugs.
-
-* `allow_internal_unstable` - Allows `macro_rules!` macros to be tagged with the
-                              `#[allow_internal_unstable]` attribute, designed
-                              to allow `std` macros to call
-                              `#[unstable]`/feature-gated functionality
-                              internally without imposing on callers
-                              (i.e. making them behave like function calls in
-                              terms of encapsulation).
-
-* `default_type_parameter_fallback` - Allows type parameter defaults to
-                                      influence type inference.
-
-* `stmt_expr_attributes` - Allows attributes on expressions.
-
-* `type_ascription` - Allows type ascription expressions `expr: Type`.
-
-* `abi_vectorcall` - Allows the usage of the vectorcall calling convention
-                     (e.g. `extern "vectorcall" func fn_();`)
-
-* `abi_sysv64` - Allows the usage of the system V AMD64 calling convention
-                 (e.g. `extern "sysv64" func fn_();`)
+The currently implemented features of the reference compiler are documented in
+[The Unstable Book].
 
 If a feature is promoted to a language feature, then all existing programs will
 start to receive compilation warnings about `#![feature]` directives which enabled
@@ -628,3 +485,6 @@ removed.
 
 If an unknown feature is found in a directive, it results in a compiler error.
 An unknown feature is one which has never been recognized by the compiler.
+
+[The Unstable Book]: https://doc.rust-lang.org/nightly/unstable-book/
+[unstable book plugin]: ../unstable-book/language-features/plugin.html#lint-plugins