2013-10-02 20:10:16 -05:00
|
|
|
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
|
|
|
// file at the top-level directory of this distribution and at
|
|
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
|
|
// option. This file may not be copied, modified, or distributed
|
|
|
|
// except according to those terms.
|
|
|
|
|
|
|
|
//! Feature gating
|
|
|
|
//!
|
2015-04-16 02:18:29 -05:00
|
|
|
//! This module implements the gating necessary for preventing certain compiler
|
2013-10-02 20:10:16 -05:00
|
|
|
//! features from being used by default. This module will crawl a pre-expanded
|
|
|
|
//! AST to ensure that there are no features which are used that are not
|
|
|
|
//! enabled.
|
|
|
|
//!
|
|
|
|
//! Features are enabled in programs via the crate-level attributes of
|
2014-06-22 12:29:42 -05:00
|
|
|
//! `#![feature(...)]` with a comma-separated list of features.
|
2015-01-14 21:27:45 -06:00
|
|
|
//!
|
|
|
|
//! For the purpose of future feature-tracking, once code for detection of feature
|
|
|
|
//! gate usage is added, *do not remove it again* even once the feature
|
|
|
|
//! becomes stable.
|
2015-02-03 16:31:06 -06:00
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
use self::AttributeType::*;
|
2015-08-28 17:23:32 -05:00
|
|
|
use self::AttributeGate::*;
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2015-04-01 14:21:03 -05:00
|
|
|
use abi::Abi;
|
2017-01-10 15:13:53 -06:00
|
|
|
use ast::{self, NodeId, PatKind, RangeEnd};
|
2016-08-22 22:54:53 -05:00
|
|
|
use attr;
|
2017-03-16 23:04:41 -05:00
|
|
|
use codemap::Spanned;
|
2016-06-21 17:08:13 -05:00
|
|
|
use syntax_pos::Span;
|
2017-01-09 03:31:14 -06:00
|
|
|
use errors::{DiagnosticBuilder, Handler, FatalError};
|
2016-06-21 17:08:13 -05:00
|
|
|
use visit::{self, FnKind, Visitor};
|
2016-06-10 20:37:24 -05:00
|
|
|
use parse::ParseSess;
|
2016-11-16 04:52:37 -06:00
|
|
|
use symbol::Symbol;
|
2013-11-26 16:55:06 -06:00
|
|
|
|
2014-12-06 19:55:34 -06:00
|
|
|
use std::ascii::AsciiExt;
|
2016-09-24 12:04:07 -05:00
|
|
|
use std::env;
|
2014-12-06 19:55:34 -06:00
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
macro_rules! setter {
|
|
|
|
($field: ident) => {{
|
|
|
|
fn f(features: &mut Features) -> &mut bool {
|
|
|
|
&mut features.$field
|
|
|
|
}
|
|
|
|
f as fn(&mut Features) -> &mut bool
|
|
|
|
}}
|
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
macro_rules! declare_features {
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
($((active, $feature: ident, $ver: expr, $issue: expr),)+) => {
|
2016-04-04 10:08:41 -05:00
|
|
|
/// Represents active features that are currently being implemented or
|
|
|
|
/// currently being considered for addition/removal.
|
|
|
|
const ACTIVE_FEATURES: &'static [(&'static str, &'static str,
|
|
|
|
Option<u32>, fn(&mut Features) -> &mut bool)] = &[
|
|
|
|
$((stringify!($feature), $ver, $issue, setter!($feature))),+
|
|
|
|
];
|
|
|
|
|
|
|
|
/// A set of features to be used by later passes.
|
|
|
|
pub struct Features {
|
2016-05-30 15:55:12 -05:00
|
|
|
/// #![feature] attrs for stable language features, for error reporting
|
2016-11-16 04:52:37 -06:00
|
|
|
pub declared_stable_lang_features: Vec<(Symbol, Span)>,
|
2016-04-04 10:08:41 -05:00
|
|
|
/// #![feature] attrs for non-language (library) features
|
2016-11-16 04:52:37 -06:00
|
|
|
pub declared_lib_features: Vec<(Symbol, Span)>,
|
2016-04-04 10:08:41 -05:00
|
|
|
$(pub $feature: bool),+
|
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
impl Features {
|
|
|
|
pub fn new() -> Features {
|
|
|
|
Features {
|
|
|
|
declared_stable_lang_features: Vec::new(),
|
|
|
|
declared_lib_features: Vec::new(),
|
|
|
|
$($feature: false),+
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
($((removed, $feature: ident, $ver: expr, $issue: expr),)+) => {
|
2017-02-25 21:42:22 -06:00
|
|
|
/// Represents unstable features which have since been removed (it was once Active)
|
2016-04-04 10:08:41 -05:00
|
|
|
const REMOVED_FEATURES: &'static [(&'static str, &'static str, Option<u32>)] = &[
|
|
|
|
$((stringify!($feature), $ver, $issue)),+
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
2017-02-25 21:42:22 -06:00
|
|
|
($((stable_removed, $feature: ident, $ver: expr, $issue: expr),)+) => {
|
|
|
|
/// Represents stable features which have since been removed (it was once Accepted)
|
|
|
|
const STABLE_REMOVED_FEATURES: &'static [(&'static str, &'static str, Option<u32>)] = &[
|
|
|
|
$((stringify!($feature), $ver, $issue)),+
|
|
|
|
];
|
|
|
|
};
|
|
|
|
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
($((accepted, $feature: ident, $ver: expr, $issue: expr),)+) => {
|
2016-04-04 10:08:41 -05:00
|
|
|
/// Those language feature has since been Accepted (it was once Active)
|
|
|
|
const ACCEPTED_FEATURES: &'static [(&'static str, &'static str, Option<u32>)] = &[
|
|
|
|
$((stringify!($feature), $ver, $issue)),+
|
|
|
|
];
|
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
}
|
|
|
|
|
2017-02-15 16:43:03 -06:00
|
|
|
// If you change this, please modify src/doc/unstable-book as well.
|
|
|
|
//
|
2015-01-14 21:27:45 -06:00
|
|
|
// Don't ever remove anything from this list; set them to 'Removed'.
|
2017-02-15 16:43:03 -06:00
|
|
|
//
|
2015-01-14 21:27:45 -06:00
|
|
|
// The version numbers here correspond to the version in which the current status
|
|
|
|
// was set. This is most important for knowing when a particular feature became
|
|
|
|
// stable (active).
|
2017-02-15 16:43:03 -06:00
|
|
|
//
|
2016-04-04 10:08:41 -05:00
|
|
|
// NB: The featureck.py script parses this information directly out of the source
|
|
|
|
// so take care when modifying it.
|
|
|
|
|
|
|
|
declare_features! (
|
|
|
|
(active, asm, "1.0.0", Some(29722)),
|
|
|
|
(active, concat_idents, "1.0.0", Some(29599)),
|
|
|
|
(active, link_args, "1.0.0", Some(29596)),
|
|
|
|
(active, log_syntax, "1.0.0", Some(29598)),
|
|
|
|
(active, non_ascii_idents, "1.0.0", Some(28979)),
|
|
|
|
(active, plugin_registrar, "1.0.0", Some(29597)),
|
|
|
|
(active, thread_local, "1.0.0", Some(29594)),
|
|
|
|
(active, trace_macros, "1.0.0", Some(29598)),
|
2015-11-09 11:09:25 -06:00
|
|
|
|
|
|
|
// rustc internal, for now:
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, intrinsics, "1.0.0", None),
|
|
|
|
(active, lang_items, "1.0.0", None),
|
2015-09-04 18:37:22 -05:00
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, link_llvm_intrinsics, "1.0.0", Some(29602)),
|
|
|
|
(active, linkage, "1.0.0", Some(29603)),
|
|
|
|
(active, quote, "1.0.0", Some(29601)),
|
|
|
|
(active, simd, "1.0.0", Some(27731)),
|
2015-09-04 18:37:22 -05:00
|
|
|
|
|
|
|
|
2015-11-09 11:09:25 -06:00
|
|
|
// rustc internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, rustc_diagnostic_macros, "1.0.0", None),
|
|
|
|
(active, advanced_slice_patterns, "1.0.0", Some(23121)),
|
|
|
|
(active, box_syntax, "1.0.0", Some(27779)),
|
|
|
|
(active, placement_in_syntax, "1.0.0", Some(27779)),
|
|
|
|
(active, unboxed_closures, "1.0.0", Some(29625)),
|
2015-11-09 11:09:25 -06:00
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, allocator, "1.0.0", Some(27389)),
|
|
|
|
(active, fundamental, "1.0.0", Some(29635)),
|
|
|
|
(active, main, "1.0.0", Some(29634)),
|
|
|
|
(active, needs_allocator, "1.4.0", Some(27389)),
|
|
|
|
(active, on_unimplemented, "1.0.0", Some(29628)),
|
|
|
|
(active, plugin, "1.0.0", Some(29597)),
|
|
|
|
(active, simd_ffi, "1.0.0", Some(27731)),
|
|
|
|
(active, start, "1.0.0", Some(29633)),
|
|
|
|
(active, structural_match, "1.8.0", Some(31434)),
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 18:18:40 -05:00
|
|
|
(active, panic_runtime, "1.10.0", Some(32837)),
|
|
|
|
(active, needs_panic_runtime, "1.10.0", Some(32837)),
|
Fix orphan checking (cc #19470). (This is not a complete fix of #19470 because of the backwards compatibility feature gate.)
This is a [breaking-change]. The new rules require that, for an impl of a trait defined
in some other crate, two conditions must hold:
1. Some type must be local.
2. Every type parameter must appear "under" some local type.
Here are some examples that are legal:
```rust
struct MyStruct<T> { ... }
// Here `T` appears "under' `MyStruct`.
impl<T> Clone for MyStruct<T> { }
// Here `T` appears "under' `MyStruct` as well. Note that it also appears
// elsewhere.
impl<T> Iterator<T> for MyStruct<T> { }
```
Here is an illegal example:
```rust
// Here `U` does not appear "under" `MyStruct` or any other local type.
// We call `U` "uncovered".
impl<T,U> Iterator<U> for MyStruct<T> { }
```
There are a couple of ways to rewrite this last example so that it is
legal:
1. In some cases, the uncovered type parameter (here, `U`) should be converted
into an associated type. This is however a non-local change that requires access
to the original trait. Also, associated types are not fully baked.
2. Add `U` as a type parameter of `MyStruct`:
```rust
struct MyStruct<T,U> { ... }
impl<T,U> Iterator<U> for MyStruct<T,U> { }
```
3. Create a newtype wrapper for `U`
```rust
impl<T,U> Iterator<Wrapper<U>> for MyStruct<T,U> { }
```
Because associated types are not fully baked, which in the case of the
`Hash` trait makes adhering to this rule impossible, you can
temporarily disable this rule in your crate by using
`#![feature(old_orphan_check)]`. Note that the `old_orphan_check`
feature will be removed before 1.0 is released.
2014-12-26 02:30:51 -06:00
|
|
|
|
2014-12-29 06:52:43 -06:00
|
|
|
// OIBIT specific features
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, optin_builtin_traits, "1.0.0", Some(13231)),
|
2014-12-29 06:52:43 -06:00
|
|
|
|
2015-02-04 22:00:02 -06:00
|
|
|
// macro reexport needs more discussion and stabilization
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, macro_reexport, "1.0.0", Some(29638)),
|
2015-01-21 20:21:14 -06:00
|
|
|
|
|
|
|
// Allows use of #[staged_api]
|
2015-11-09 11:09:25 -06:00
|
|
|
// rustc internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, staged_api, "1.0.0", None),
|
2015-02-03 13:51:26 -06:00
|
|
|
|
2015-07-29 19:01:14 -05:00
|
|
|
// Allows using #![no_core]
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, no_core, "1.3.0", Some(29639)),
|
2015-07-29 19:01:14 -05:00
|
|
|
|
2015-02-10 15:49:56 -06:00
|
|
|
// Allows using `box` in patterns; RFC 469
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, box_patterns, "1.0.0", Some(29641)),
|
2015-02-11 16:03:33 -06:00
|
|
|
|
2015-07-17 09:12:35 -05:00
|
|
|
// Allows using the unsafe_destructor_blind_to_params attribute;
|
|
|
|
// RFC 1238
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, dropck_parametricity, "1.3.0", Some(28498)),
|
2015-07-16 07:56:03 -05:00
|
|
|
|
2016-10-11 09:07:14 -05:00
|
|
|
// Allows using the may_dangle attribute; RFC 1327
|
|
|
|
(active, dropck_eyepatch, "1.10.0", Some(34761)),
|
|
|
|
|
2015-02-13 09:10:24 -06:00
|
|
|
// Allows the use of custom attributes; RFC 572
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, custom_attribute, "1.0.0", Some(29642)),
|
2015-02-16 14:16:36 -06:00
|
|
|
|
2015-03-06 15:15:54 -06:00
|
|
|
// Allows the use of #[derive(Anything)] as sugar for
|
|
|
|
// #[derive_Anything].
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, custom_derive, "1.0.0", Some(29644)),
|
2015-03-06 15:15:54 -06:00
|
|
|
|
2015-02-16 14:16:36 -06:00
|
|
|
// Allows the use of rustc_* attributes; RFC 572
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, rustc_attrs, "1.0.0", Some(29642)),
|
2015-03-02 04:46:31 -06:00
|
|
|
|
Add #[allow_internal_unstable] to track stability for macros better.
Unstable items used in a macro expansion will now always trigger
stability warnings, *unless* the unstable items are directly inside a
macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns
unless the span of the unstable item is a subspan of the definition of a
macro marked with that attribute.
E.g.
#[allow_internal_unstable]
macro_rules! foo {
($e: expr) => {{
$e;
unstable(); // no warning
only_called_by_foo!();
}}
}
macro_rules! only_called_by_foo {
() => { unstable() } // warning
}
foo!(unstable()) // warning
The unstable inside `foo` is fine, due to the attribute. But the
`unstable` inside `only_called_by_foo` is not, since that macro doesn't
have the attribute, and the `unstable` passed into `foo` is also not
fine since it isn't contained in the macro itself (that is, even though
it is only used directly in the macro).
In the process this makes the stability tracking much more precise,
e.g. previously `println!("{}", unstable())` got no warning, but now it
does. As such, this is a bug fix that may cause [breaking-change]s.
The attribute is definitely feature gated, since it explicitly allows
side-stepping the feature gating system.
2015-02-28 21:09:28 -06:00
|
|
|
// Allows the use of #[allow_internal_unstable]. This is an
|
|
|
|
// attribute on macro_rules! and can't use the attribute handling
|
|
|
|
// below (it has to be checked before expansion possibly makes
|
|
|
|
// macros disappear).
|
2015-11-09 11:09:25 -06:00
|
|
|
//
|
|
|
|
// rustc internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, allow_internal_unstable, "1.0.0", None),
|
2015-03-26 20:34:27 -05:00
|
|
|
|
|
|
|
// #23121. Array patterns have some hazards yet.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, slice_patterns, "1.0.0", Some(23121)),
|
2015-03-26 14:06:26 -05:00
|
|
|
|
|
|
|
// Allows the definition of associated constants in `trait` or `impl`
|
|
|
|
// blocks.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, associated_consts, "1.0.0", Some(29646)),
|
2015-05-05 07:47:04 -05:00
|
|
|
|
|
|
|
// Allows the definition of `const fn` functions.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, const_fn, "1.2.0", Some(24111)),
|
2015-06-30 22:05:17 -05:00
|
|
|
|
2015-11-20 03:43:04 -06:00
|
|
|
// Allows indexing into constant arrays.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, const_indexing, "1.4.0", Some(29947)),
|
2015-11-20 03:43:04 -06:00
|
|
|
|
2015-06-30 22:05:17 -05:00
|
|
|
// Allows using #[prelude_import] on glob `use` items.
|
2015-11-09 11:09:25 -06:00
|
|
|
//
|
|
|
|
// rustc internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, prelude_import, "1.2.0", None),
|
2015-07-02 16:07:42 -05:00
|
|
|
|
2015-07-29 12:31:07 -05:00
|
|
|
// Allows default type parameters to influence type inference.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, default_type_parameter_fallback, "1.3.0", Some(27336)),
|
2015-07-29 14:01:09 -05:00
|
|
|
|
|
|
|
// Allows associated type defaults
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, associated_type_defaults, "1.2.0", Some(29661)),
|
2015-08-03 22:32:02 -05:00
|
|
|
|
2015-07-13 13:35:00 -05:00
|
|
|
// allow `repr(simd)`, and importing the various simd intrinsics
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, repr_simd, "1.4.0", Some(27731)),
|
2015-07-13 19:10:44 -05:00
|
|
|
|
|
|
|
// Allows cfg(target_feature = "...").
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, cfg_target_feature, "1.4.0", Some(29717)),
|
2015-08-06 13:11:26 -05:00
|
|
|
|
|
|
|
// allow `extern "platform-intrinsic" { ... }`
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, platform_intrinsics, "1.4.0", Some(27731)),
|
2015-09-11 13:09:19 -05:00
|
|
|
|
|
|
|
// allow `#[unwind]`
|
2015-11-09 11:09:25 -06:00
|
|
|
// rust runtime internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, unwind_attributes, "1.4.0", None),
|
2015-09-18 05:36:45 -05:00
|
|
|
|
2016-03-21 15:13:50 -05:00
|
|
|
// allow the use of `#[naked]` on functions.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, naked_functions, "1.9.0", Some(32408)),
|
2015-09-19 15:33:47 -05:00
|
|
|
|
|
|
|
// allow `#[no_debug]`
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, no_debug, "1.5.0", Some(29721)),
|
2015-09-19 15:33:47 -05:00
|
|
|
|
|
|
|
// allow `#[omit_gdb_pretty_printer_section]`
|
2015-11-09 11:09:25 -06:00
|
|
|
// rustc internal.
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, omit_gdb_pretty_printer_section, "1.5.0", None),
|
2015-09-23 18:20:43 -05:00
|
|
|
|
|
|
|
// Allows cfg(target_vendor = "...").
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, cfg_target_vendor, "1.5.0", Some(29718)),
|
2015-11-24 07:56:20 -06:00
|
|
|
|
|
|
|
// Allow attributes on expressions and non-item statements
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, stmt_expr_attributes, "1.6.0", Some(15701)),
|
2015-12-02 20:37:48 -06:00
|
|
|
|
|
|
|
// allow using type ascription in expressions
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, type_ascription, "1.6.0", Some(23416)),
|
2015-12-10 14:21:55 -06:00
|
|
|
|
|
|
|
// Allows cfg(target_thread_local)
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, cfg_target_thread_local, "1.7.0", Some(29594)),
|
2016-01-11 16:45:33 -06:00
|
|
|
|
|
|
|
// rustc internal
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, abi_vectorcall, "1.7.0", None),
|
2016-01-13 00:27:40 -06:00
|
|
|
|
|
|
|
// a...b and ...b
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, inclusive_range_syntax, "1.7.0", Some(28237)),
|
2016-02-28 16:38:48 -06:00
|
|
|
|
2017-01-10 15:13:53 -06:00
|
|
|
// X..Y patterns
|
|
|
|
(active, exclusive_range_pattern, "1.11.0", Some(37854)),
|
|
|
|
|
2015-12-30 17:16:43 -06:00
|
|
|
// impl specialization (RFC 1210)
|
2016-04-04 10:08:41 -05:00
|
|
|
(active, specialization, "1.7.0", Some(31844)),
|
2016-04-10 18:33:36 -05:00
|
|
|
|
2016-04-15 14:16:19 -05:00
|
|
|
// Allow Drop types in statics/const functions (RFC 1440)
|
|
|
|
(active, drop_types_in_const, "1.9.0", Some(33156)),
|
|
|
|
|
|
|
|
// Allows cfg(target_has_atomic = "...").
|
2016-03-06 06:54:44 -06:00
|
|
|
(active, cfg_target_has_atomic, "1.9.0", Some(32976)),
|
|
|
|
|
2016-07-31 20:25:32 -05:00
|
|
|
// Allows `impl Trait` in function return types.
|
2016-07-29 15:47:55 -05:00
|
|
|
(active, conservative_impl_trait, "1.12.0", Some(34511)),
|
|
|
|
|
|
|
|
// Permits numeric fields in struct expressions and patterns.
|
2016-08-01 07:15:54 -05:00
|
|
|
(active, relaxed_adts, "1.12.0", Some(35626)),
|
|
|
|
|
|
|
|
// The `!` type
|
2016-08-19 20:58:14 -05:00
|
|
|
(active, never_type, "1.13.0", Some(35121)),
|
|
|
|
|
|
|
|
// Allows all literals in attribute lists and values of key-value pairs.
|
2016-08-27 08:14:51 -05:00
|
|
|
(active, attr_literals, "1.13.0", Some(34981)),
|
|
|
|
|
|
|
|
// Allows the sysV64 ABI to be specified on all platforms
|
|
|
|
// instead of just the platforms on which it is the C ABI
|
2016-08-16 01:03:36 -05:00
|
|
|
(active, abi_sysv64, "1.13.0", Some(36167)),
|
|
|
|
|
2016-08-08 17:18:47 -05:00
|
|
|
// Allows untagged unions `union U { ... }`
|
|
|
|
(active, untagged_unions, "1.13.0", Some(32836)),
|
2016-09-07 16:18:46 -05:00
|
|
|
|
2016-07-24 21:42:11 -05:00
|
|
|
// Used to identify the `compiler_builtins` crate
|
|
|
|
// rustc internal
|
|
|
|
(active, compiler_builtins, "1.13.0", None),
|
2016-05-17 11:51:45 -05:00
|
|
|
|
|
|
|
// Allows attributes on lifetime/type formal parameters in generics (RFC 1327)
|
|
|
|
(active, generic_param_attrs, "1.11.0", Some(34761)),
|
2016-10-26 19:15:13 -05:00
|
|
|
|
rustc: Implement #[link(cfg(..))] and crt-static
This commit is an implementation of [RFC 1721] which adds a new target feature
to the compiler, `crt-static`, which can be used to select how the C runtime for
a target is linked. Most targets dynamically linke the C runtime by default with
the notable exception of some of the musl targets.
[RFC 1721]: https://github.com/rust-lang/rfcs/blob/master/text/1721-crt-static.md
This commit first adds the new target-feature, `crt-static`. If enabled, then
the `cfg(target_feature = "crt-static")` will be available. Targets like musl
will have this enabled by default. This feature can be controlled through the
standard target-feature interface, `-C target-feature=+crt-static` or
`-C target-feature=-crt-static`.
Next this adds an gated and unstable `#[link(cfg(..))]` feature to enable the
`crt-static` semantics we want with libc. The exact behavior of this attribute
is a little squishy, but it's intended to be a forever-unstable
implementation detail of the liblibc crate.
Specifically the `#[link(cfg(..))]` annotation means that the `#[link]`
directive is only active in a compilation unit if that `cfg` value is satisfied.
For example when compiling an rlib, these directives are just encoded and
ignored for dylibs, and all staticlibs are continued to be put into the rlib as
usual. When placing that rlib into a staticlib, executable, or dylib, however,
the `cfg` is evaluated *as if it were defined in the final artifact* and the
library is decided to be linked or not.
Essentially, what'll happen is:
* On MSVC with `-C target-feature=-crt-static`, the `msvcrt.lib` library will be
linked to.
* On MSVC with `-C target-feature=+crt-static`, the `libcmt.lib` library will be
linked to.
* On musl with `-C target-feature=-crt-static`, the object files in liblibc.rlib
are removed and `-lc` is passed instead.
* On musl with `-C target-feature=+crt-static`, the object files in liblibc.rlib
are used and `-lc` is not passed.
This commit does **not** include an update to the liblibc module to implement
these changes. I plan to do that just after the 1.14.0 beta release is cut to
ensure we get ample time to test this feature.
cc #37406
2016-10-31 18:40:13 -05:00
|
|
|
// Allows #[link(..., cfg(..))]
|
|
|
|
(active, link_cfg, "1.14.0", Some(37406)),
|
2016-11-10 04:29:36 -06:00
|
|
|
|
|
|
|
(active, use_extern_macros, "1.15.0", Some(35896)),
|
Implement the `loop_break_value` feature.
This implements RFC 1624, tracking issue #37339.
- `FnCtxt` (in typeck) gets a stack of `LoopCtxt`s, which store the
currently deduced type of that loop, the desired type, and a list of
break expressions currently seen. `loop` loops get a fresh type
variable as their initial type (this logic is stolen from that for
arrays). `while` loops get `()`.
- `break {expr}` looks up the broken loop, and unifies the type of
`expr` with the type of the loop.
- `break` with no expr unifies the loop's type with `()`.
- When building MIR, `loop` loops no longer construct a `()` value at
termination of the loop; rather, the `break` expression assigns the
result of the loop. `while` loops are unchanged.
- `break` respects contexts in which expressions may not end with braced
blocks. That is, `while break { break-value } { while-body }` is
illegal; this preserves backwards compatibility.
- The RFC did not make it clear, but I chose to make `break ()` inside
of a `while` loop illegal, just in case we wanted to do anything with
that design space in the future.
This is my first time dealing with this part of rustc so I'm sure
there's plenty of problems to pick on here ^_^
2016-10-29 17:15:06 -05:00
|
|
|
|
|
|
|
// Allows `break {expr}` with a value inside `loop`s.
|
|
|
|
(active, loop_break_value, "1.14.0", Some(37339)),
|
2016-11-29 18:02:00 -06:00
|
|
|
|
|
|
|
// Allows #[target_feature(...)]
|
|
|
|
(active, target_feature, "1.15.0", None),
|
2016-10-25 15:19:19 -05:00
|
|
|
|
2016-12-22 15:24:29 -06:00
|
|
|
// `extern "ptx-*" fn()`
|
|
|
|
(active, abi_ptx, "1.15.0", None),
|
2016-08-23 18:15:15 -05:00
|
|
|
|
|
|
|
// The `i128` type
|
2016-12-15 15:57:59 -06:00
|
|
|
(active, i128_type, "1.16.0", Some(35118)),
|
2016-12-23 02:05:41 -06:00
|
|
|
|
|
|
|
// The `unadjusted` ABI. Perma unstable.
|
|
|
|
(active, abi_unadjusted, "1.16.0", None),
|
2017-01-03 21:13:01 -06:00
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
// Macros 1.1
|
2017-02-01 22:11:10 -06:00
|
|
|
(active, proc_macro, "1.16.0", Some(38356)),
|
2017-01-09 03:31:14 -06:00
|
|
|
|
2017-01-03 21:13:01 -06:00
|
|
|
// Allows attributes on struct literal fields.
|
|
|
|
(active, struct_field_attributes, "1.16.0", Some(38814)),
|
2016-12-18 22:45:20 -06:00
|
|
|
|
2016-12-16 01:46:21 -06:00
|
|
|
// Allows #[link(kind="static-nobundle"...]
|
|
|
|
(active, static_nobundle, "1.16.0", Some(37403)),
|
|
|
|
|
2016-12-18 22:45:20 -06:00
|
|
|
// `extern "msp430-interrupt" fn()`
|
|
|
|
(active, abi_msp430_interrupt, "1.16.0", Some(38487)),
|
2016-12-29 22:28:11 -06:00
|
|
|
|
2017-03-04 07:31:34 -06:00
|
|
|
// Coerces non capturing closures to function pointers
|
2017-02-23 14:35:12 -06:00
|
|
|
(active, closure_to_fn_coercion, "1.17.0", Some(39817)),
|
|
|
|
|
2016-12-29 22:28:11 -06:00
|
|
|
// Used to identify crates that contain sanitizer runtimes
|
|
|
|
// rustc internal
|
|
|
|
(active, sanitizer_runtime, "1.17.0", None),
|
2017-02-14 14:39:42 -06:00
|
|
|
|
|
|
|
// `extern "x86-interrupt" fn()`
|
|
|
|
(active, abi_x86_interrupt, "1.17.0", Some(40180)),
|
2017-02-17 17:12:47 -06:00
|
|
|
|
2017-02-20 13:42:47 -06:00
|
|
|
|
2017-02-17 17:12:47 -06:00
|
|
|
// Allows the `catch {...}` expression
|
|
|
|
(active, catch_expr, "1.17.0", Some(31436)),
|
2017-03-11 09:54:45 -06:00
|
|
|
|
2017-03-25 03:00:49 -05:00
|
|
|
// Allows `repr(align(u16))` struct attribute (RFC 1358)
|
|
|
|
(active, repr_align, "1.17.0", Some(33626)),
|
|
|
|
|
2017-03-11 09:54:45 -06:00
|
|
|
// See rust-lang/rfcs#1414. Allows code like `let x: &'static u32 = &42` to work.
|
|
|
|
(active, rvalue_static_promotion, "1.15.1", Some(38865)),
|
2017-02-20 13:42:47 -06:00
|
|
|
|
2017-04-05 21:11:22 -05:00
|
|
|
// Used to preserve symbols (see llvm.used)
|
|
|
|
(active, used, "1.18.0", Some(40289)),
|
2017-04-07 10:51:36 -05:00
|
|
|
|
2017-03-15 21:27:40 -05:00
|
|
|
// Allows module-level inline assembly by way of global_asm!()
|
|
|
|
(active, global_asm, "1.18.0", Some(35119)),
|
2017-03-17 13:16:29 -05:00
|
|
|
|
|
|
|
// Allows overlapping impls of marker traits
|
|
|
|
(active, overlapping_marker_traits, "1.18.0", Some(29864)),
|
2017-04-15 16:39:19 -05:00
|
|
|
|
2017-04-02 19:09:07 -05:00
|
|
|
// Allows use of the :vis macro fragment specifier
|
|
|
|
(active, macro_vis_matcher, "1.18.0", Some(41022)),
|
2016-04-04 10:08:41 -05:00
|
|
|
);
|
|
|
|
|
|
|
|
declare_features! (
|
|
|
|
(removed, import_shadowing, "1.0.0", None),
|
|
|
|
(removed, managed_boxes, "1.0.0", None),
|
|
|
|
// Allows use of unary negate on unsigned integers, e.g. -e for e: u8
|
|
|
|
(removed, negate_unsigned, "1.0.0", Some(29645)),
|
2017-01-15 01:42:33 -06:00
|
|
|
(removed, reflect, "1.0.0", Some(27749)),
|
2016-04-04 10:08:41 -05:00
|
|
|
// A way to temporarily opt out of opt in copy. This will *never* be accepted.
|
|
|
|
(removed, opt_out_copy, "1.0.0", None),
|
|
|
|
(removed, quad_precision_float, "1.0.0", None),
|
|
|
|
(removed, struct_inherit, "1.0.0", None),
|
|
|
|
(removed, test_removed_feature, "1.0.0", None),
|
2016-08-23 02:39:30 -05:00
|
|
|
(removed, visible_private_types, "1.0.0", None),
|
2016-09-03 12:23:40 -05:00
|
|
|
(removed, unsafe_no_drop_flag, "1.0.0", None),
|
2016-11-30 08:23:11 -06:00
|
|
|
// Allows using items which are missing stability attributes
|
|
|
|
// rustc internal
|
|
|
|
(removed, unmarked_api, "1.0.0", None),
|
2017-01-14 18:03:33 -06:00
|
|
|
(removed, pushpop_unsafe, "1.2.0", None),
|
2016-04-04 10:08:41 -05:00
|
|
|
);
|
|
|
|
|
2017-02-25 21:42:22 -06:00
|
|
|
declare_features! (
|
|
|
|
(stable_removed, no_stack_check, "1.0.0", None),
|
2016-04-04 10:08:41 -05:00
|
|
|
);
|
|
|
|
|
|
|
|
declare_features! (
|
|
|
|
(accepted, associated_types, "1.0.0", None),
|
|
|
|
// allow overloading augmented assignment operations like `a += b`
|
|
|
|
(accepted, augmented_assignments, "1.8.0", Some(28235)),
|
|
|
|
// allow empty structs and enum variants with braces
|
|
|
|
(accepted, braced_empty_structs, "1.8.0", Some(29720)),
|
|
|
|
(accepted, default_type_params, "1.0.0", None),
|
|
|
|
(accepted, globs, "1.0.0", None),
|
|
|
|
(accepted, if_let, "1.0.0", None),
|
|
|
|
// A temporary feature gate used to enable parser extensions needed
|
|
|
|
// to bootstrap fix for #5723.
|
|
|
|
(accepted, issue_5723_bootstrap, "1.0.0", None),
|
|
|
|
(accepted, macro_rules, "1.0.0", None),
|
|
|
|
// Allows using #![no_std]
|
2016-08-11 16:46:10 -05:00
|
|
|
(accepted, no_std, "1.6.0", None),
|
2016-04-04 10:08:41 -05:00
|
|
|
(accepted, slicing_syntax, "1.0.0", None),
|
|
|
|
(accepted, struct_variant, "1.0.0", None),
|
|
|
|
// These are used to test this portion of the compiler, they don't actually
|
|
|
|
// mean anything
|
|
|
|
(accepted, test_accepted_feature, "1.0.0", None),
|
|
|
|
(accepted, tuple_indexing, "1.0.0", None),
|
2016-08-24 06:07:43 -05:00
|
|
|
// Allows macros to appear in the type position.
|
|
|
|
(accepted, type_macros, "1.13.0", Some(27245)),
|
2016-04-04 10:08:41 -05:00
|
|
|
(accepted, while_let, "1.0.0", None),
|
|
|
|
// Allows `#[deprecated]` attribute
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
(accepted, deprecated, "1.9.0", Some(29935)),
|
2016-10-05 17:36:36 -05:00
|
|
|
// `expr?`
|
2016-11-08 20:35:36 -06:00
|
|
|
(accepted, question_mark, "1.13.0", Some(31436)),
|
2016-09-14 16:51:46 -05:00
|
|
|
// Allows `..` in tuple (struct) patterns
|
|
|
|
(accepted, dotdot_in_tuple_patterns, "1.14.0", Some(33627)),
|
2016-09-29 19:03:16 -05:00
|
|
|
(accepted, item_like_imports, "1.14.0", Some(35120)),
|
2016-11-12 06:33:16 -06:00
|
|
|
// Allows using `Self` and associated types in struct expressions and patterns.
|
2017-02-04 23:18:35 -06:00
|
|
|
(accepted, more_struct_aliases, "1.16.0", Some(37544)),
|
2017-02-05 11:14:14 -06:00
|
|
|
// elide `'static` lifetimes in `static`s and `const`s
|
|
|
|
(accepted, static_in_const, "1.17.0", Some(35897)),
|
2017-02-11 23:49:15 -06:00
|
|
|
// Allows field shorthands (`x` meaning `x: x`) in struct literal expressions.
|
|
|
|
(accepted, field_init_shorthand, "1.17.0", Some(37340)),
|
2017-02-22 01:41:04 -06:00
|
|
|
// Allows the definition recursive static items.
|
|
|
|
(accepted, static_recursion, "1.17.0", Some(29719)),
|
2017-03-15 16:24:02 -05:00
|
|
|
// pub(restricted) visibilities (RFC 1422)
|
2017-04-07 13:47:22 -05:00
|
|
|
(accepted, pub_restricted, "1.18.0", Some(32409)),
|
2017-03-20 14:49:13 -05:00
|
|
|
// The #![windows_subsystem] attribute
|
|
|
|
(accepted, windows_subsystem, "1.18.0", Some(37499)),
|
2016-04-04 10:08:41 -05:00
|
|
|
);
|
2017-02-15 16:43:03 -06:00
|
|
|
// If you change this, please modify src/doc/unstable-book as well. You must
|
|
|
|
// move that documentation into the relevant place in the other docs, and
|
|
|
|
// remove the chapter on the flag.
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
#[derive(PartialEq, Copy, Clone, Debug)]
|
|
|
|
pub enum AttributeType {
|
|
|
|
/// Normal, builtin attribute that is consumed
|
|
|
|
/// by the compiler before the unused_attribute check
|
|
|
|
Normal,
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
/// Builtin attribute that may not be consumed by the compiler
|
|
|
|
/// before the unused_attribute check. These attributes
|
|
|
|
/// will be ignored by the unused_attribute lint
|
|
|
|
Whitelisted,
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
/// Builtin attribute that is only allowed at the crate level
|
|
|
|
CrateLevel,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum AttributeGate {
|
|
|
|
/// Is gated by a given feature gate, reason
|
|
|
|
/// and function to check if enabled
|
2016-10-10 21:51:27 -05:00
|
|
|
Gated(Stability, &'static str, &'static str, fn(&Features) -> bool),
|
2016-04-07 04:15:32 -05:00
|
|
|
|
|
|
|
/// Ungated attribute, can be used on all release channels
|
|
|
|
Ungated,
|
|
|
|
}
|
|
|
|
|
2016-10-18 00:04:28 -05:00
|
|
|
impl AttributeGate {
|
|
|
|
fn is_deprecated(&self) -> bool {
|
|
|
|
match *self {
|
|
|
|
Gated(Stability::Deprecated(_), ..) => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
|
2016-10-10 21:51:27 -05:00
|
|
|
pub enum Stability {
|
|
|
|
Unstable,
|
2016-10-18 00:04:28 -05:00
|
|
|
// Argument is tracking issue link.
|
|
|
|
Deprecated(&'static str),
|
2016-10-10 21:51:27 -05:00
|
|
|
}
|
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
// fn() is not Debug
|
|
|
|
impl ::std::fmt::Debug for AttributeGate {
|
|
|
|
fn fmt(&self, fmt: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
|
|
|
match *self {
|
2017-05-12 13:05:39 -05:00
|
|
|
Gated(ref stab, name, expl, _) =>
|
2016-10-18 00:04:28 -05:00
|
|
|
write!(fmt, "Gated({:?}, {}, {})", stab, name, expl),
|
2016-04-07 04:15:32 -05:00
|
|
|
Ungated => write!(fmt, "Ungated")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! cfg_fn {
|
|
|
|
($field: ident) => {{
|
|
|
|
fn f(features: &Features) -> bool {
|
|
|
|
features.$field
|
|
|
|
}
|
|
|
|
f as fn(&Features) -> bool
|
|
|
|
}}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2016-10-18 00:04:28 -05:00
|
|
|
pub fn deprecated_attributes() -> Vec<&'static (&'static str, AttributeType, AttributeGate)> {
|
2016-11-07 16:00:26 -06:00
|
|
|
BUILTIN_ATTRIBUTES.iter().filter(|a| a.2.is_deprecated()).collect()
|
2016-10-18 00:04:28 -05:00
|
|
|
}
|
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
pub fn is_builtin_attr(attr: &ast::Attribute) -> bool {
|
|
|
|
BUILTIN_ATTRIBUTES.iter().any(|&(builtin_name, _, _)| attr.check_name(builtin_name))
|
|
|
|
}
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
// Attributes that have a special meaning to rustc or rustdoc
|
2016-11-07 16:00:26 -06:00
|
|
|
pub const BUILTIN_ATTRIBUTES: &'static [(&'static str, AttributeType, AttributeGate)] = &[
|
2015-02-13 09:10:24 -06:00
|
|
|
// Normal attributes
|
|
|
|
|
2015-08-28 17:23:32 -05:00
|
|
|
("warn", Normal, Ungated),
|
|
|
|
("allow", Normal, Ungated),
|
|
|
|
("forbid", Normal, Ungated),
|
|
|
|
("deny", Normal, Ungated),
|
|
|
|
|
|
|
|
("macro_reexport", Normal, Ungated),
|
|
|
|
("macro_use", Normal, Ungated),
|
|
|
|
("macro_export", Normal, Ungated),
|
|
|
|
("plugin_registrar", Normal, Ungated),
|
|
|
|
|
|
|
|
("cfg", Normal, Ungated),
|
|
|
|
("cfg_attr", Normal, Ungated),
|
|
|
|
("main", Normal, Ungated),
|
|
|
|
("start", Normal, Ungated),
|
|
|
|
("test", Normal, Ungated),
|
|
|
|
("bench", Normal, Ungated),
|
|
|
|
("simd", Normal, Ungated),
|
|
|
|
("repr", Normal, Ungated),
|
|
|
|
("path", Normal, Ungated),
|
|
|
|
("abi", Normal, Ungated),
|
|
|
|
("automatically_derived", Normal, Ungated),
|
|
|
|
("no_mangle", Normal, Ungated),
|
|
|
|
("no_link", Normal, Ungated),
|
|
|
|
("derive", Normal, Ungated),
|
|
|
|
("should_panic", Normal, Ungated),
|
|
|
|
("ignore", Normal, Ungated),
|
|
|
|
("no_implicit_prelude", Normal, Ungated),
|
|
|
|
("reexport_test_harness_main", Normal, Ungated),
|
|
|
|
("link_args", Normal, Ungated),
|
|
|
|
("macro_escape", Normal, Ungated),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
2016-03-11 12:27:42 -06:00
|
|
|
// RFC #1445.
|
2016-10-10 21:51:27 -05:00
|
|
|
("structural_match", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"structural_match",
|
2016-03-11 12:27:42 -06:00
|
|
|
"the semantics of constant patterns is \
|
2016-04-07 04:15:32 -05:00
|
|
|
not yet settled",
|
|
|
|
cfg_fn!(structural_match))),
|
2016-03-11 12:27:42 -06:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("plugin", CrateLevel, Gated(Stability::Unstable,
|
|
|
|
"plugin",
|
2015-08-28 17:23:32 -05:00
|
|
|
"compiler plugins are experimental \
|
2016-04-07 04:15:32 -05:00
|
|
|
and possibly buggy",
|
|
|
|
cfg_fn!(plugin))),
|
|
|
|
|
2015-12-02 19:31:49 -06:00
|
|
|
("no_std", CrateLevel, Ungated),
|
2016-10-10 21:51:27 -05:00
|
|
|
("no_core", CrateLevel, Gated(Stability::Unstable,
|
|
|
|
"no_core",
|
2016-04-07 04:15:32 -05:00
|
|
|
"no_core is experimental",
|
|
|
|
cfg_fn!(no_core))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("lang", Normal, Gated(Stability::Unstable,
|
|
|
|
"lang_items",
|
2016-04-07 04:15:32 -05:00
|
|
|
"language items are subject to change",
|
|
|
|
cfg_fn!(lang_items))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("linkage", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"linkage",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `linkage` attribute is experimental \
|
2016-04-07 04:15:32 -05:00
|
|
|
and not portable across platforms",
|
|
|
|
cfg_fn!(linkage))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("thread_local", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"thread_local",
|
2015-08-28 17:23:32 -05:00
|
|
|
"`#[thread_local]` is an experimental feature, and does \
|
|
|
|
not currently handle destructors. There is no \
|
|
|
|
corresponding `#[task_local]` mapping to the task \
|
2016-04-07 04:15:32 -05:00
|
|
|
model",
|
|
|
|
cfg_fn!(thread_local))),
|
2015-08-28 17:23:32 -05:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_on_unimplemented", Normal, Gated(Stability::Unstable,
|
|
|
|
"on_unimplemented",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[rustc_on_unimplemented]` attribute \
|
2016-04-07 04:15:32 -05:00
|
|
|
is an experimental feature",
|
|
|
|
cfg_fn!(on_unimplemented))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("allocator", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"allocator",
|
2016-04-07 04:15:32 -05:00
|
|
|
"the `#[allocator]` attribute is an experimental feature",
|
|
|
|
cfg_fn!(allocator))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("needs_allocator", Normal, Gated(Stability::Unstable,
|
|
|
|
"needs_allocator",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[needs_allocator]` \
|
|
|
|
attribute is an experimental \
|
2016-04-07 04:15:32 -05:00
|
|
|
feature",
|
|
|
|
cfg_fn!(needs_allocator))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("panic_runtime", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"panic_runtime",
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 18:18:40 -05:00
|
|
|
"the `#[panic_runtime]` attribute is \
|
|
|
|
an experimental feature",
|
|
|
|
cfg_fn!(panic_runtime))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("needs_panic_runtime", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"needs_panic_runtime",
|
rustc: Implement custom panic runtimes
This commit is an implementation of [RFC 1513] which allows applications to
alter the behavior of panics at compile time. A new compiler flag, `-C panic`,
is added and accepts the values `unwind` or `panic`, with the default being
`unwind`. This model affects how code is generated for the local crate, skipping
generation of landing pads with `-C panic=abort`.
[RFC 1513]: https://github.com/rust-lang/rfcs/blob/master/text/1513-less-unwinding.md
Panic implementations are then provided by crates tagged with
`#![panic_runtime]` and lazily required by crates with
`#![needs_panic_runtime]`. The panic strategy (`-C panic` value) of the panic
runtime must match the final product, and if the panic strategy is not `abort`
then the entire DAG must have the same panic strategy.
With the `-C panic=abort` strategy, users can expect a stable method to disable
generation of landing pads, improving optimization in niche scenarios,
decreasing compile time, and decreasing output binary size. With the `-C
panic=unwind` strategy users can expect the existing ability to isolate failure
in Rust code from the outside world.
Organizationally, this commit dismantles the `sys_common::unwind` module in
favor of some bits moving part of it to `libpanic_unwind` and the rest into the
`panicking` module in libstd. The custom panic runtime support is pretty similar
to the custom allocator support with the only major difference being how the
panic runtime is injected (takes the `-C panic` flag into account).
2016-04-08 18:18:40 -05:00
|
|
|
"the `#[needs_panic_runtime]` \
|
|
|
|
attribute is an experimental \
|
|
|
|
feature",
|
|
|
|
cfg_fn!(needs_panic_runtime))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_variance", Normal, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[rustc_variance]` attribute \
|
2015-08-18 16:59:21 -05:00
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_error", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[rustc_error]` attribute \
|
2015-08-18 16:59:21 -05:00
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_if_this_changed", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-04-07 04:15:32 -05:00
|
|
|
"the `#[rustc_if_this_changed]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_then_this_would_need", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-04-07 04:15:32 -05:00
|
|
|
"the `#[rustc_if_this_changed]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_dirty", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-03-28 16:42:39 -05:00
|
|
|
"the `#[rustc_dirty]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_clean", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-03-28 16:42:39 -05:00
|
|
|
"the `#[rustc_clean]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_metadata_dirty", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-08-30 15:49:54 -05:00
|
|
|
"the `#[rustc_metadata_dirty]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_metadata_clean", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-08-30 15:49:54 -05:00
|
|
|
"the `#[rustc_metadata_clean]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_partition_reused", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-07-21 11:50:15 -05:00
|
|
|
"this attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_partition_translated", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-07-21 11:50:15 -05:00
|
|
|
"this attribute \
|
|
|
|
is just used for rustc unit tests \
|
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_symbol_name", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-04-07 04:15:32 -05:00
|
|
|
"internal rustc attributes will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_item_path", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-04-07 04:15:32 -05:00
|
|
|
"internal rustc attributes will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_move_fragments", Normal, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[rustc_move_fragments]` attribute \
|
2015-08-18 16:59:21 -05:00
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_mir", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-03-09 14:46:00 -06:00
|
|
|
"the `#[rustc_mir]` attribute \
|
|
|
|
is just used for rustc unit tests \
|
2016-04-07 04:15:32 -05:00
|
|
|
and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_inherit_overflow_checks", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
2016-05-26 12:02:56 -05:00
|
|
|
"the `#[rustc_inherit_overflow_checks]` \
|
|
|
|
attribute is just used to control \
|
|
|
|
overflow checking behavior of several \
|
|
|
|
libcore functions that are inlined \
|
|
|
|
across crates and will never be stable",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("compiler_builtins", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"compiler_builtins",
|
2016-07-24 21:42:11 -05:00
|
|
|
"the `#[compiler_builtins]` attribute is used to \
|
|
|
|
identify the `compiler_builtins` crate which \
|
|
|
|
contains compiler-rt intrinsics and will never be \
|
|
|
|
stable",
|
|
|
|
cfg_fn!(compiler_builtins))),
|
2016-12-29 22:28:11 -06:00
|
|
|
("sanitizer_runtime", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"sanitizer_runtime",
|
|
|
|
"the `#[sanitizer_runtime]` attribute is used to \
|
|
|
|
identify crates that contain the runtime of a \
|
|
|
|
sanitizer and will never be stable",
|
|
|
|
cfg_fn!(sanitizer_runtime))),
|
2015-08-28 17:23:32 -05:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("allow_internal_unstable", Normal, Gated(Stability::Unstable,
|
|
|
|
"allow_internal_unstable",
|
2016-04-07 04:15:32 -05:00
|
|
|
EXPLAIN_ALLOW_INTERNAL_UNSTABLE,
|
|
|
|
cfg_fn!(allow_internal_unstable))),
|
2015-08-28 17:23:32 -05:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("fundamental", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"fundamental",
|
2015-08-28 17:23:32 -05:00
|
|
|
"the `#[fundamental]` attribute \
|
2016-04-07 04:15:32 -05:00
|
|
|
is an experimental feature",
|
|
|
|
cfg_fn!(fundamental))),
|
2015-08-28 17:23:32 -05:00
|
|
|
|
2017-01-01 18:14:35 -06:00
|
|
|
("proc_macro_derive", Normal, Ungated),
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_copy_clone_marker", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"rustc_attrs",
|
rustc: Implement custom derive (macros 1.1)
This commit is an implementation of [RFC 1681] which adds support to the
compiler for first-class user-define custom `#[derive]` modes with a far more
stable API than plugins have today.
[RFC 1681]: https://github.com/rust-lang/rfcs/blob/master/text/1681-macros-1.1.md
The main features added by this commit are:
* A new `rustc-macro` crate-type. This crate type represents one which will
provide custom `derive` implementations and perhaps eventually flower into the
implementation of macros 2.0 as well.
* A new `rustc_macro` crate in the standard distribution. This crate will
provide the runtime interface between macro crates and the compiler. The API
here is particularly conservative right now but has quite a bit of room to
expand into any manner of APIs required by macro authors.
* The ability to load new derive modes through the `#[macro_use]` annotations on
other crates.
All support added here is gated behind the `rustc_macro` feature gate, both for
the library support (the `rustc_macro` crate) as well as the language features.
There are a few minor differences from the implementation outlined in the RFC,
such as the `rustc_macro` crate being available as a dylib and all symbols are
`dlsym`'d directly instead of having a shim compiled. These should only affect
the implementation, however, not the public interface.
This commit also ended up touching a lot of code related to `#[derive]`, making
a few notable changes:
* Recognized derive attributes are no longer desugared to `derive_Foo`. Wasn't
sure how to keep this behavior and *not* expose it to custom derive.
* Derive attributes no longer have access to unstable features by default, they
have to opt in on a granular level.
* The `derive(Copy,Clone)` optimization is now done through another "obscure
attribute" which is just intended to ferry along in the compiler that such an
optimization is possible. The `derive(PartialEq,Eq)` optimization was also
updated to do something similar.
---
One part of this PR which needs to be improved before stabilizing are the errors
and exact interfaces here. The error messages are relatively poor quality and
there are surprising spects of this such as `#[derive(PartialEq, Eq, MyTrait)]`
not working by default. The custom attributes added by the compiler end up
becoming unstable again when going through a custom impl.
Hopefully though this is enough to start allowing experimentation on crates.io!
syntax-[breaking-change]
2016-08-22 19:07:11 -05:00
|
|
|
"internal implementation detail",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
// FIXME: #14408 whitelist docs since rustdoc looks at them
|
2015-08-28 17:23:32 -05:00
|
|
|
("doc", Whitelisted, Ungated),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
|
|
|
// FIXME: #14406 these are processed in trans, which happens after the
|
|
|
|
// lint pass
|
2015-08-28 17:23:32 -05:00
|
|
|
("cold", Whitelisted, Ungated),
|
2016-10-10 21:51:27 -05:00
|
|
|
("naked", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"naked_functions",
|
2016-03-21 15:01:08 -05:00
|
|
|
"the `#[naked]` attribute \
|
2016-04-07 04:15:32 -05:00
|
|
|
is an experimental feature",
|
2016-04-04 10:08:41 -05:00
|
|
|
cfg_fn!(naked_functions))),
|
2016-11-29 18:02:00 -06:00
|
|
|
("target_feature", Whitelisted, Gated(
|
|
|
|
Stability::Unstable, "target_feature",
|
|
|
|
"the `#[target_feature]` attribute is an experimental feature",
|
|
|
|
cfg_fn!(target_feature))),
|
2015-08-28 17:23:32 -05:00
|
|
|
("export_name", Whitelisted, Ungated),
|
|
|
|
("inline", Whitelisted, Ungated),
|
|
|
|
("link", Whitelisted, Ungated),
|
|
|
|
("link_name", Whitelisted, Ungated),
|
|
|
|
("link_section", Whitelisted, Ungated),
|
|
|
|
("no_builtins", Whitelisted, Ungated),
|
|
|
|
("no_mangle", Whitelisted, Ungated),
|
2016-10-18 00:04:28 -05:00
|
|
|
("no_debug", Whitelisted, Gated(
|
|
|
|
Stability::Deprecated("https://github.com/rust-lang/rust/issues/29721"),
|
|
|
|
"no_debug",
|
|
|
|
"the `#[no_debug]` attribute is an experimental feature",
|
|
|
|
cfg_fn!(no_debug))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("omit_gdb_pretty_printer_section", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"omit_gdb_pretty_printer_section",
|
2015-09-19 15:33:47 -05:00
|
|
|
"the `#[omit_gdb_pretty_printer_section]` \
|
|
|
|
attribute is just used for the Rust test \
|
2016-04-07 04:15:32 -05:00
|
|
|
suite",
|
|
|
|
cfg_fn!(omit_gdb_pretty_printer_section))),
|
2015-07-16 07:56:03 -05:00
|
|
|
("unsafe_destructor_blind_to_params",
|
|
|
|
Normal,
|
2017-01-10 16:52:33 -06:00
|
|
|
Gated(Stability::Deprecated("https://github.com/rust-lang/rust/issues/34761"),
|
2016-10-10 21:51:27 -05:00
|
|
|
"dropck_parametricity",
|
2017-01-10 16:52:33 -06:00
|
|
|
"unsafe_destructor_blind_to_params has been replaced by \
|
|
|
|
may_dangle and will be removed in the future",
|
2016-04-07 04:15:32 -05:00
|
|
|
cfg_fn!(dropck_parametricity))),
|
2016-10-11 09:07:14 -05:00
|
|
|
("may_dangle",
|
|
|
|
Normal,
|
2016-10-10 21:51:27 -05:00
|
|
|
Gated(Stability::Unstable,
|
|
|
|
"dropck_eyepatch",
|
2016-10-11 09:07:14 -05:00
|
|
|
"may_dangle has unstable semantics and may be removed in the future",
|
|
|
|
cfg_fn!(dropck_eyepatch))),
|
2016-10-10 21:51:27 -05:00
|
|
|
("unwind", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"unwind_attributes",
|
|
|
|
"#[unwind] is experimental",
|
2016-04-07 04:15:32 -05:00
|
|
|
cfg_fn!(unwind_attributes))),
|
2017-02-20 13:42:47 -06:00
|
|
|
("used", Whitelisted, Gated(
|
|
|
|
Stability::Unstable, "used",
|
|
|
|
"the `#[used]` attribute is an experimental feature",
|
|
|
|
cfg_fn!(used))),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
|
|
|
// used in resolve
|
2016-10-10 21:51:27 -05:00
|
|
|
("prelude_import", Whitelisted, Gated(Stability::Unstable,
|
|
|
|
"prelude_import",
|
2016-04-07 04:15:32 -05:00
|
|
|
"`#[prelude_import]` is for use by rustc only",
|
|
|
|
cfg_fn!(prelude_import))),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
|
|
|
// FIXME: #14407 these are only looked at on-demand so we can't
|
|
|
|
// guarantee they'll have already been checked
|
2015-11-20 07:11:20 -06:00
|
|
|
("rustc_deprecated", Whitelisted, Ungated),
|
2015-08-28 17:23:32 -05:00
|
|
|
("must_use", Whitelisted, Ungated),
|
|
|
|
("stable", Whitelisted, Ungated),
|
|
|
|
("unstable", Whitelisted, Ungated),
|
2016-04-07 12:42:53 -05:00
|
|
|
("deprecated", Normal, Ungated),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
2016-10-10 21:51:27 -05:00
|
|
|
("rustc_paren_sugar", Normal, Gated(Stability::Unstable,
|
|
|
|
"unboxed_closures",
|
2016-04-07 04:15:32 -05:00
|
|
|
"unboxed_closures are still evolving",
|
|
|
|
cfg_fn!(unboxed_closures))),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
2017-03-20 14:49:13 -05:00
|
|
|
("windows_subsystem", Whitelisted, Ungated),
|
2016-10-31 11:36:30 -05:00
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
("proc_macro_attribute", Normal, Gated(Stability::Unstable,
|
|
|
|
"proc_macro",
|
|
|
|
"attribute proc macros are currently unstable",
|
|
|
|
cfg_fn!(proc_macro))),
|
|
|
|
|
2017-02-27 14:03:19 -06:00
|
|
|
("proc_macro", Normal, Gated(Stability::Unstable,
|
|
|
|
"proc_macro",
|
|
|
|
"function-like proc macros are currently unstable",
|
|
|
|
cfg_fn!(proc_macro))),
|
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
("rustc_derive_registrar", Normal, Gated(Stability::Unstable,
|
|
|
|
"rustc_derive_registrar",
|
|
|
|
"used internally by rustc",
|
|
|
|
cfg_fn!(rustc_attrs))),
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
// Crate level attributes
|
2015-08-28 17:23:32 -05:00
|
|
|
("crate_name", CrateLevel, Ungated),
|
|
|
|
("crate_type", CrateLevel, Ungated),
|
|
|
|
("crate_id", CrateLevel, Ungated),
|
|
|
|
("feature", CrateLevel, Ungated),
|
|
|
|
("no_start", CrateLevel, Ungated),
|
|
|
|
("no_main", CrateLevel, Ungated),
|
|
|
|
("no_builtins", CrateLevel, Ungated),
|
|
|
|
("recursion_limit", CrateLevel, Ungated),
|
2016-11-15 15:25:59 -06:00
|
|
|
("type_length_limit", CrateLevel, Ungated),
|
2015-02-13 07:35:11 -06:00
|
|
|
];
|
|
|
|
|
2015-07-13 19:10:44 -05:00
|
|
|
// cfg(...)'s that are feature gated
|
2017-05-12 13:05:39 -05:00
|
|
|
const GATED_CFGS: &[(&str, &str, fn(&Features) -> bool)] = &[
|
2015-07-13 19:10:44 -05:00
|
|
|
// (name in cfg, feature, function to check if the feature is enabled)
|
2016-04-07 04:15:32 -05:00
|
|
|
("target_feature", "cfg_target_feature", cfg_fn!(cfg_target_feature)),
|
|
|
|
("target_vendor", "cfg_target_vendor", cfg_fn!(cfg_target_vendor)),
|
|
|
|
("target_thread_local", "cfg_target_thread_local", cfg_fn!(cfg_target_thread_local)),
|
2016-04-15 14:16:19 -05:00
|
|
|
("target_has_atomic", "cfg_target_has_atomic", cfg_fn!(cfg_target_has_atomic)),
|
2015-07-13 19:10:44 -05:00
|
|
|
];
|
|
|
|
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
|
|
pub struct GatedCfg {
|
|
|
|
span: Span,
|
|
|
|
index: usize,
|
|
|
|
}
|
2015-07-31 02:04:06 -05:00
|
|
|
|
2015-07-13 19:10:44 -05:00
|
|
|
impl GatedCfg {
|
|
|
|
pub fn gate(cfg: &ast::MetaItem) -> Option<GatedCfg> {
|
2017-03-24 03:31:26 -05:00
|
|
|
let name = cfg.name().as_str();
|
2015-07-13 19:10:44 -05:00
|
|
|
GATED_CFGS.iter()
|
|
|
|
.position(|info| info.0 == name)
|
|
|
|
.map(|idx| {
|
|
|
|
GatedCfg {
|
|
|
|
span: cfg.span,
|
|
|
|
index: idx
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2016-06-10 20:37:24 -05:00
|
|
|
|
|
|
|
pub fn check_and_emit(&self, sess: &ParseSess, features: &Features) {
|
2015-07-13 19:10:44 -05:00
|
|
|
let (cfg, feature, has_feature) = GATED_CFGS[self.index];
|
2017-03-16 23:04:41 -05:00
|
|
|
if !has_feature(features) && !self.span.allows_unstable() {
|
2015-07-13 19:10:44 -05:00
|
|
|
let explain = format!("`cfg({})` is experimental and subject to change", cfg);
|
2016-09-24 11:42:54 -05:00
|
|
|
emit_feature_err(sess, feature, self.span, GateIssue::Language, &explain);
|
2015-07-13 19:10:44 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-05 08:36:01 -06:00
|
|
|
struct Context<'a> {
|
2016-04-06 17:43:03 -05:00
|
|
|
features: &'a Features,
|
2016-09-24 11:42:54 -05:00
|
|
|
parse_sess: &'a ParseSess,
|
2015-05-06 11:38:36 -05:00
|
|
|
plugin_attributes: &'a [(String, AttributeType)],
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
macro_rules! gate_feature_fn {
|
|
|
|
($cx: expr, $has_feature: expr, $span: expr, $name: expr, $explain: expr) => {{
|
|
|
|
let (cx, has_feature, span, name, explain) = ($cx, $has_feature, $span, $name, $explain);
|
|
|
|
let has_feature: bool = has_feature(&$cx.features);
|
|
|
|
debug!("gate_feature(feature = {:?}, span = {:?}); has? {}", name, span, has_feature);
|
2017-03-16 23:04:41 -05:00
|
|
|
if !has_feature && !span.allows_unstable() {
|
2016-09-24 11:42:54 -05:00
|
|
|
emit_feature_err(cx.parse_sess, name, span, GateIssue::Language, explain);
|
2014-05-28 11:24:28 -05:00
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
}}
|
|
|
|
}
|
|
|
|
|
|
|
|
macro_rules! gate_feature {
|
|
|
|
($cx: expr, $feature: ident, $span: expr, $explain: expr) => {
|
|
|
|
gate_feature_fn!($cx, |x:&Features| x.$feature, $span, stringify!($feature), $explain)
|
2014-05-28 11:24:28 -05:00
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
impl<'a> Context<'a> {
|
2015-05-06 11:38:36 -05:00
|
|
|
fn check_attribute(&self, attr: &ast::Attribute, is_macro: bool) {
|
2015-03-06 17:10:20 -06:00
|
|
|
debug!("check_attribute(attr = {:?})", attr);
|
2017-03-24 03:31:26 -05:00
|
|
|
let name = unwrap_or!(attr.name(), return).as_str();
|
2016-11-07 16:00:26 -06:00
|
|
|
for &(n, ty, ref gateage) in BUILTIN_ATTRIBUTES {
|
2017-03-03 03:23:59 -06:00
|
|
|
if name == n {
|
2017-05-12 13:05:39 -05:00
|
|
|
if let Gated(_, name, desc, ref has_feature) = *gateage {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_fn!(self, has_feature, attr.span, name, desc);
|
2015-03-06 17:10:20 -06:00
|
|
|
}
|
2017-03-03 03:23:59 -06:00
|
|
|
debug!("check_attribute: {:?} is builtin, {:?}, {:?}", attr.path, ty, gateage);
|
2015-03-06 17:10:20 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-06-10 11:22:20 -05:00
|
|
|
for &(ref n, ref ty) in self.plugin_attributes {
|
2017-03-03 03:23:59 -06:00
|
|
|
if attr.path == &**n {
|
2015-05-06 11:38:36 -05:00
|
|
|
// Plugins can't gate attributes, so we don't check for it
|
2015-05-13 01:53:43 -05:00
|
|
|
// unlike the code above; we only use this loop to
|
|
|
|
// short-circuit to avoid the checks below
|
2017-03-03 03:23:59 -06:00
|
|
|
debug!("check_attribute: {:?} is registered by a plugin, {:?}", attr.path, ty);
|
2015-05-06 11:38:36 -05:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2017-03-24 03:31:26 -05:00
|
|
|
if name.starts_with("rustc_") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature!(self, rustc_attrs, attr.span,
|
|
|
|
"unless otherwise specified, attributes \
|
|
|
|
with the prefix `rustc_` \
|
|
|
|
are reserved for internal compiler diagnostics");
|
2017-03-24 03:31:26 -05:00
|
|
|
} else if name.starts_with("derive_") {
|
2016-04-06 17:43:03 -05:00
|
|
|
gate_feature!(self, custom_derive, attr.span, EXPLAIN_DERIVE_UNDERSCORE);
|
2017-03-03 03:23:59 -06:00
|
|
|
} else if !attr::is_known(attr) {
|
2015-05-13 01:53:43 -05:00
|
|
|
// Only run the custom attribute lint during regular
|
|
|
|
// feature gate checking. Macro gating runs
|
|
|
|
// before the plugin attributes are registered
|
|
|
|
// so we skip this then
|
2015-05-06 11:38:36 -05:00
|
|
|
if !is_macro {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature!(self, custom_attribute, attr.span,
|
|
|
|
&format!("The attribute `{}` is currently \
|
|
|
|
unknown to the compiler and \
|
|
|
|
may have meaning \
|
|
|
|
added to it in the future",
|
2017-03-03 03:23:59 -06:00
|
|
|
attr.path));
|
2015-05-06 11:38:36 -05:00
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
}
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2017-03-16 23:04:41 -05:00
|
|
|
pub fn check_attribute(attr: &ast::Attribute, parse_sess: &ParseSess, features: &Features) {
|
|
|
|
let cx = Context { features: features, parse_sess: parse_sess, plugin_attributes: &[] };
|
2016-04-06 17:43:03 -05:00
|
|
|
cx.check_attribute(attr, true);
|
|
|
|
}
|
|
|
|
|
2016-05-30 15:55:12 -05:00
|
|
|
pub fn find_lang_feature_accepted_version(feature: &str) -> Option<&'static str> {
|
|
|
|
ACCEPTED_FEATURES.iter().find(|t| t.0 == feature).map(|t| t.1)
|
|
|
|
}
|
|
|
|
|
2015-09-04 18:37:22 -05:00
|
|
|
fn find_lang_feature_issue(feature: &str) -> Option<u32> {
|
2016-04-04 10:08:41 -05:00
|
|
|
if let Some(info) = ACTIVE_FEATURES.iter().find(|t| t.0 == feature) {
|
|
|
|
let issue = info.2;
|
2015-09-04 18:37:22 -05:00
|
|
|
// FIXME (#28244): enforce that active features have issue numbers
|
|
|
|
// assert!(issue.is_some())
|
2016-04-04 10:08:41 -05:00
|
|
|
issue
|
|
|
|
} else {
|
2017-02-25 21:42:22 -06:00
|
|
|
// search in Accepted, Removed, or Stable Removed features
|
|
|
|
let found = ACCEPTED_FEATURES.iter().chain(REMOVED_FEATURES).chain(STABLE_REMOVED_FEATURES)
|
|
|
|
.find(|t| t.0 == feature);
|
|
|
|
match found {
|
2017-01-16 19:59:11 -06:00
|
|
|
Some(&(_, _, issue)) => issue,
|
|
|
|
None => panic!("Feature `{}` is not declared anywhere", feature),
|
|
|
|
}
|
2015-09-04 18:37:22 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum GateIssue {
|
|
|
|
Language,
|
|
|
|
Library(Option<u32>)
|
|
|
|
}
|
|
|
|
|
2016-09-24 11:42:54 -05:00
|
|
|
pub fn emit_feature_err(sess: &ParseSess, feature: &str, span: Span, issue: GateIssue,
|
2015-09-04 18:37:22 -05:00
|
|
|
explain: &str) {
|
2016-10-04 12:10:33 -05:00
|
|
|
feature_err(sess, feature, span, issue, explain).emit();
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn feature_err<'a>(sess: &'a ParseSess, feature: &str, span: Span, issue: GateIssue,
|
|
|
|
explain: &str) -> DiagnosticBuilder<'a> {
|
2016-09-24 11:42:54 -05:00
|
|
|
let diag = &sess.span_diagnostic;
|
|
|
|
|
2015-09-04 18:37:22 -05:00
|
|
|
let issue = match issue {
|
|
|
|
GateIssue::Language => find_lang_feature_issue(feature),
|
|
|
|
GateIssue::Library(lib) => lib,
|
|
|
|
};
|
|
|
|
|
2015-12-20 15:00:43 -06:00
|
|
|
let mut err = if let Some(n) = issue {
|
|
|
|
diag.struct_span_err(span, &format!("{} (see issue #{})", explain, n))
|
2015-09-04 18:37:22 -05:00
|
|
|
} else {
|
2015-12-20 15:00:43 -06:00
|
|
|
diag.struct_span_err(span, explain)
|
|
|
|
};
|
2015-04-02 10:29:22 -05:00
|
|
|
|
|
|
|
// #23973: do not suggest `#![feature(...)]` if we are in beta/stable
|
2016-09-24 12:28:46 -05:00
|
|
|
if sess.unstable_features.is_nightly_build() {
|
|
|
|
err.help(&format!("add #![feature({})] to the \
|
|
|
|
crate attributes to enable",
|
|
|
|
feature));
|
2015-12-20 15:00:43 -06:00
|
|
|
}
|
2016-09-24 12:28:46 -05:00
|
|
|
|
2016-10-04 12:10:33 -05:00
|
|
|
err
|
2015-01-14 17:20:14 -06:00
|
|
|
}
|
|
|
|
|
2016-04-09 11:01:14 -05:00
|
|
|
const EXPLAIN_BOX_SYNTAX: &'static str =
|
|
|
|
"box expression syntax is experimental; you can call `Box::new` instead.";
|
|
|
|
|
2016-06-10 20:37:24 -05:00
|
|
|
pub const EXPLAIN_STMT_ATTR_SYNTAX: &'static str =
|
2016-04-09 11:01:14 -05:00
|
|
|
"attributes on non-item statements and expressions are experimental.";
|
|
|
|
|
2015-02-15 15:14:03 -06:00
|
|
|
pub const EXPLAIN_ASM: &'static str =
|
|
|
|
"inline assembly is not stable enough for use and is subject to change";
|
|
|
|
|
2017-03-15 21:27:40 -05:00
|
|
|
pub const EXPLAIN_GLOBAL_ASM: &'static str =
|
2017-03-21 23:47:25 -05:00
|
|
|
"`global_asm!` is not stable enough for use and is subject to change";
|
2017-03-15 21:27:40 -05:00
|
|
|
|
2015-02-15 16:49:55 -06:00
|
|
|
pub const EXPLAIN_LOG_SYNTAX: &'static str =
|
|
|
|
"`log_syntax!` is not stable enough for use and is subject to change";
|
|
|
|
|
|
|
|
pub const EXPLAIN_CONCAT_IDENTS: &'static str =
|
|
|
|
"`concat_idents` is not stable enough for use and is subject to change";
|
|
|
|
|
|
|
|
pub const EXPLAIN_TRACE_MACROS: &'static str =
|
|
|
|
"`trace_macros` is not stable enough for use and is subject to change";
|
Add #[allow_internal_unstable] to track stability for macros better.
Unstable items used in a macro expansion will now always trigger
stability warnings, *unless* the unstable items are directly inside a
macro marked with `#[allow_internal_unstable]`. IOW, the compiler warns
unless the span of the unstable item is a subspan of the definition of a
macro marked with that attribute.
E.g.
#[allow_internal_unstable]
macro_rules! foo {
($e: expr) => {{
$e;
unstable(); // no warning
only_called_by_foo!();
}}
}
macro_rules! only_called_by_foo {
() => { unstable() } // warning
}
foo!(unstable()) // warning
The unstable inside `foo` is fine, due to the attribute. But the
`unstable` inside `only_called_by_foo` is not, since that macro doesn't
have the attribute, and the `unstable` passed into `foo` is also not
fine since it isn't contained in the macro itself (that is, even though
it is only used directly in the macro).
In the process this makes the stability tracking much more precise,
e.g. previously `println!("{}", unstable())` got no warning, but now it
does. As such, this is a bug fix that may cause [breaking-change]s.
The attribute is definitely feature gated, since it explicitly allows
side-stepping the feature gating system.
2015-02-28 21:09:28 -06:00
|
|
|
pub const EXPLAIN_ALLOW_INTERNAL_UNSTABLE: &'static str =
|
|
|
|
"allow_internal_unstable side-steps feature gating and stability checks";
|
2015-02-15 16:49:55 -06:00
|
|
|
|
2015-03-06 15:15:54 -06:00
|
|
|
pub const EXPLAIN_CUSTOM_DERIVE: &'static str =
|
2017-02-04 17:54:41 -06:00
|
|
|
"`#[derive]` for custom traits is deprecated and will be removed in the future.";
|
2016-10-10 23:19:51 -05:00
|
|
|
|
|
|
|
pub const EXPLAIN_DEPR_CUSTOM_DERIVE: &'static str =
|
2017-02-04 17:54:41 -06:00
|
|
|
"`#[derive]` for custom traits is deprecated and will be removed in the future. \
|
|
|
|
Prefer using procedural macro custom derive.";
|
2015-03-06 15:15:54 -06:00
|
|
|
|
2016-04-06 17:43:03 -05:00
|
|
|
pub const EXPLAIN_DERIVE_UNDERSCORE: &'static str =
|
|
|
|
"attributes of the form `#[derive_*]` are reserved for the compiler";
|
2015-02-12 04:30:16 -06:00
|
|
|
|
2017-04-02 19:09:07 -05:00
|
|
|
pub const EXPLAIN_VIS_MATCHER: &'static str =
|
|
|
|
":vis fragment specifier is experimental and subject to change";
|
|
|
|
|
2016-04-09 11:01:14 -05:00
|
|
|
pub const EXPLAIN_PLACEMENT_IN: &'static str =
|
|
|
|
"placement-in expression syntax is experimental and subject to change.";
|
2014-12-23 23:44:13 -06:00
|
|
|
|
2017-02-23 14:35:12 -06:00
|
|
|
pub const CLOSURE_TO_FN_COERCION: &'static str =
|
|
|
|
"non-capturing closure to fn coercion is experimental";
|
|
|
|
|
2014-12-23 23:44:13 -06:00
|
|
|
struct PostExpansionVisitor<'a> {
|
2015-09-28 19:46:01 -05:00
|
|
|
context: &'a Context<'a>,
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
2016-04-07 04:15:32 -05:00
|
|
|
macro_rules! gate_feature_post {
|
|
|
|
($cx: expr, $feature: ident, $span: expr, $explain: expr) => {{
|
|
|
|
let (cx, span) = ($cx, $span);
|
2017-03-16 23:04:41 -05:00
|
|
|
if !span.allows_unstable() {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature!(cx.context, $feature, span, $explain)
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
2016-04-07 04:15:32 -05:00
|
|
|
}}
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
2016-07-16 16:15:15 -05:00
|
|
|
impl<'a> PostExpansionVisitor<'a> {
|
|
|
|
fn check_abi(&self, abi: Abi, span: Span) {
|
|
|
|
match abi {
|
2016-08-27 08:14:51 -05:00
|
|
|
Abi::RustIntrinsic => {
|
2016-07-16 16:15:15 -05:00
|
|
|
gate_feature_post!(&self, intrinsics, span,
|
2016-08-27 08:14:51 -05:00
|
|
|
"intrinsics are subject to change");
|
|
|
|
},
|
2016-07-16 16:15:15 -05:00
|
|
|
Abi::PlatformIntrinsic => {
|
|
|
|
gate_feature_post!(&self, platform_intrinsics, span,
|
2016-08-27 08:14:51 -05:00
|
|
|
"platform intrinsics are experimental and possibly buggy");
|
2016-07-16 16:15:15 -05:00
|
|
|
},
|
|
|
|
Abi::Vectorcall => {
|
|
|
|
gate_feature_post!(&self, abi_vectorcall, span,
|
2016-08-27 08:14:51 -05:00
|
|
|
"vectorcall is experimental and subject to change");
|
|
|
|
},
|
2016-07-16 16:15:15 -05:00
|
|
|
Abi::RustCall => {
|
|
|
|
gate_feature_post!(&self, unboxed_closures, span,
|
|
|
|
"rust-call ABI is subject to change");
|
2016-08-27 08:14:51 -05:00
|
|
|
},
|
|
|
|
Abi::SysV64 => {
|
|
|
|
gate_feature_post!(&self, abi_sysv64, span,
|
|
|
|
"sysv64 ABI is experimental and subject to change");
|
|
|
|
},
|
2016-12-22 15:24:29 -06:00
|
|
|
Abi::PtxKernel => {
|
|
|
|
gate_feature_post!(&self, abi_ptx, span,
|
|
|
|
"PTX ABIs are experimental and subject to change");
|
2016-12-23 02:05:41 -06:00
|
|
|
},
|
|
|
|
Abi::Unadjusted => {
|
|
|
|
gate_feature_post!(&self, abi_unadjusted, span,
|
|
|
|
"unadjusted ABI is an implementation detail and perma-unstable");
|
|
|
|
},
|
2016-12-18 22:45:20 -06:00
|
|
|
Abi::Msp430Interrupt => {
|
|
|
|
gate_feature_post!(&self, abi_msp430_interrupt, span,
|
|
|
|
"msp430-interrupt ABI is experimental and subject to change");
|
|
|
|
},
|
2017-02-14 14:39:42 -06:00
|
|
|
Abi::X86Interrupt => {
|
|
|
|
gate_feature_post!(&self, abi_x86_interrupt, span,
|
|
|
|
"x86-interrupt ABI is experimental and subject to change");
|
|
|
|
},
|
2016-12-22 15:24:29 -06:00
|
|
|
// Stable
|
|
|
|
Abi::Cdecl |
|
|
|
|
Abi::Stdcall |
|
|
|
|
Abi::Fastcall |
|
|
|
|
Abi::Aapcs |
|
|
|
|
Abi::Win64 |
|
|
|
|
Abi::Rust |
|
|
|
|
Abi::C |
|
|
|
|
Abi::System => {}
|
2016-07-16 16:15:15 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-19 20:58:14 -05:00
|
|
|
fn contains_novel_literal(item: &ast::MetaItem) -> bool {
|
|
|
|
use ast::MetaItemKind::*;
|
|
|
|
use ast::NestedMetaItemKind::*;
|
|
|
|
|
|
|
|
match item.node {
|
2016-11-15 01:37:10 -06:00
|
|
|
Word => false,
|
|
|
|
NameValue(ref lit) => !lit.node.is_str(),
|
|
|
|
List(ref list) => list.iter().any(|li| {
|
2016-08-19 20:58:14 -05:00
|
|
|
match li.node {
|
2017-05-12 13:05:39 -05:00
|
|
|
MetaItem(ref mi) => contains_novel_literal(mi),
|
2016-08-19 20:58:14 -05:00
|
|
|
Literal(_) => true,
|
|
|
|
}
|
|
|
|
}),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-09-14 16:51:46 -05:00
|
|
|
fn starts_with_digit(s: &str) -> bool {
|
|
|
|
s.as_bytes().first().cloned().map_or(false, |b| b >= b'0' && b <= b'9')
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
|
2015-03-06 17:10:20 -06:00
|
|
|
fn visit_attribute(&mut self, attr: &ast::Attribute) {
|
2017-03-16 23:04:41 -05:00
|
|
|
if !attr.span.allows_unstable() {
|
2016-08-19 20:58:14 -05:00
|
|
|
// check for gated attributes
|
2015-05-06 11:38:36 -05:00
|
|
|
self.context.check_attribute(attr, false);
|
2015-03-06 17:10:20 -06:00
|
|
|
}
|
2016-08-19 20:58:14 -05:00
|
|
|
|
2017-03-08 17:13:35 -06:00
|
|
|
if self.context.features.proc_macro && attr::is_known(attr) {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
2017-05-12 13:05:39 -05:00
|
|
|
let meta = panictry!(attr.parse_meta(self.context.parse_sess));
|
2017-03-03 03:23:59 -06:00
|
|
|
if contains_novel_literal(&meta) {
|
2016-08-19 20:58:14 -05:00
|
|
|
gate_feature_post!(&self, attr_literals, attr.span,
|
|
|
|
"non-string literals in attributes, or string \
|
|
|
|
literals in top-level positions, are experimental");
|
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
}
|
|
|
|
|
2014-11-18 10:39:16 -06:00
|
|
|
fn visit_name(&mut self, sp: Span, name: ast::Name) {
|
2015-07-28 11:07:20 -05:00
|
|
|
if !name.as_str().is_ascii() {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, non_ascii_idents, sp,
|
|
|
|
"non-ascii idents are not fully supported.");
|
2013-11-22 06:25:14 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_item(&mut self, i: &'a ast::Item) {
|
2013-10-02 20:10:16 -05:00
|
|
|
match i.node {
|
2016-02-09 04:36:51 -06:00
|
|
|
ast::ItemKind::ExternCrate(_) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "macro_reexport") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, macro_reexport, i.span,
|
|
|
|
"macros reexports are experimental \
|
|
|
|
and possibly buggy");
|
2015-01-13 09:30:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-02-09 04:36:51 -06:00
|
|
|
ast::ItemKind::ForeignMod(ref foreign_module) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "link_args") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, link_args, i.span,
|
Add generation of static libraries to rustc
This commit implements the support necessary for generating both intermediate
and result static rust libraries. This is an implementation of my thoughts in
https://mail.mozilla.org/pipermail/rust-dev/2013-November/006686.html.
When compiling a library, we still retain the "lib" option, although now there
are "rlib", "staticlib", and "dylib" as options for crate_type (and these are
stackable). The idea of "lib" is to generate the "compiler default" instead of
having too choose (although all are interchangeable). For now I have left the
"complier default" to be a dynamic library for size reasons.
Of the rust libraries, lib{std,extra,rustuv} will bootstrap with an
rlib/dylib pair, but lib{rustc,syntax,rustdoc,rustpkg} will only be built as a
dynamic object. I chose this for size reasons, but also because you're probably
not going to be embedding the rustc compiler anywhere any time soon.
Other than the options outlined above, there are a few defaults/preferences that
are now opinionated in the compiler:
* If both a .dylib and .rlib are found for a rust library, the compiler will
prefer the .rlib variant. This is overridable via the -Z prefer-dynamic option
* If generating a "lib", the compiler will generate a dynamic library. This is
overridable by explicitly saying what flavor you'd like (rlib, staticlib,
dylib).
* If no options are passed to the command line, and no crate_type is found in
the destination crate, then an executable is generated
With this change, you can successfully build a rust program with 0 dynamic
dependencies on rust libraries. There is still a dynamic dependency on
librustrt, but I plan on removing that in a subsequent commit.
This change includes no tests just yet. Our current testing
infrastructure/harnesses aren't very amenable to doing flavorful things with
linking, so I'm planning on adding a new mode of testing which I believe belongs
as a separate commit.
Closes #552
2013-11-15 16:03:29 -06:00
|
|
|
"the `link_args` attribute is not portable \
|
|
|
|
across platforms, it is recommended to \
|
|
|
|
use `#[link(name = \"foo\")]` instead")
|
|
|
|
}
|
2016-07-16 16:15:15 -05:00
|
|
|
self.check_abi(foreign_module.abi, i.span);
|
Add generation of static libraries to rustc
This commit implements the support necessary for generating both intermediate
and result static rust libraries. This is an implementation of my thoughts in
https://mail.mozilla.org/pipermail/rust-dev/2013-November/006686.html.
When compiling a library, we still retain the "lib" option, although now there
are "rlib", "staticlib", and "dylib" as options for crate_type (and these are
stackable). The idea of "lib" is to generate the "compiler default" instead of
having too choose (although all are interchangeable). For now I have left the
"complier default" to be a dynamic library for size reasons.
Of the rust libraries, lib{std,extra,rustuv} will bootstrap with an
rlib/dylib pair, but lib{rustc,syntax,rustdoc,rustpkg} will only be built as a
dynamic object. I chose this for size reasons, but also because you're probably
not going to be embedding the rustc compiler anywhere any time soon.
Other than the options outlined above, there are a few defaults/preferences that
are now opinionated in the compiler:
* If both a .dylib and .rlib are found for a rust library, the compiler will
prefer the .rlib variant. This is overridable via the -Z prefer-dynamic option
* If generating a "lib", the compiler will generate a dynamic library. This is
overridable by explicitly saying what flavor you'd like (rlib, staticlib,
dylib).
* If no options are passed to the command line, and no crate_type is found in
the destination crate, then an executable is generated
With this change, you can successfully build a rust program with 0 dynamic
dependencies on rust libraries. There is still a dynamic dependency on
librustrt, but I plan on removing that in a subsequent commit.
This change includes no tests just yet. Our current testing
infrastructure/harnesses aren't very amenable to doing flavorful things with
linking, so I'm planning on adding a new mode of testing which I believe belongs
as a separate commit.
Closes #552
2013-11-15 16:03:29 -06:00
|
|
|
}
|
|
|
|
|
2016-02-09 04:36:51 -06:00
|
|
|
ast::ItemKind::Fn(..) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "plugin_registrar") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, plugin_registrar, i.span,
|
|
|
|
"compiler plugins are experimental and possibly buggy");
|
2013-12-25 12:10:33 -06:00
|
|
|
}
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "start") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, start, i.span,
|
2015-01-16 12:55:24 -06:00
|
|
|
"a #[start] function is an experimental \
|
|
|
|
feature whose signature may change \
|
|
|
|
over time");
|
|
|
|
}
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "main") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, main, i.span,
|
|
|
|
"declaration of a nonstandard #[main] \
|
|
|
|
function may change over time, for now \
|
|
|
|
a top-level `fn main()` is required");
|
2015-01-16 12:55:24 -06:00
|
|
|
}
|
2013-12-25 12:10:33 -06:00
|
|
|
}
|
|
|
|
|
2016-02-09 04:36:51 -06:00
|
|
|
ast::ItemKind::Struct(..) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "simd") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, simd, i.span,
|
|
|
|
"SIMD types are experimental and possibly buggy");
|
2016-09-24 11:42:54 -05:00
|
|
|
self.context.parse_sess.span_diagnostic.span_warn(i.span,
|
|
|
|
"the `#[simd]` attribute \
|
|
|
|
is deprecated, use \
|
|
|
|
`#[repr(simd)]` instead");
|
2015-07-13 13:35:00 -05:00
|
|
|
}
|
|
|
|
for attr in &i.attrs {
|
2017-03-03 03:23:59 -06:00
|
|
|
if attr.path == "repr" {
|
|
|
|
for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
|
2016-08-19 20:58:14 -05:00
|
|
|
if item.check_name("simd") {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, repr_simd, i.span,
|
|
|
|
"SIMD types are experimental \
|
|
|
|
and possibly buggy");
|
2015-07-13 13:35:00 -05:00
|
|
|
|
|
|
|
}
|
2017-03-25 03:00:49 -05:00
|
|
|
if item.check_name("align") {
|
|
|
|
gate_feature_post!(&self, repr_align, i.span,
|
|
|
|
"the struct `#[repr(align(u16))]` attribute \
|
|
|
|
is experimental");
|
|
|
|
}
|
2015-07-13 13:35:00 -05:00
|
|
|
}
|
|
|
|
}
|
2014-02-24 01:17:02 -06:00
|
|
|
}
|
2014-01-22 19:25:22 -06:00
|
|
|
}
|
|
|
|
|
2016-08-08 17:18:47 -05:00
|
|
|
ast::ItemKind::Union(..) => {
|
|
|
|
gate_feature_post!(&self, untagged_unions,
|
|
|
|
i.span,
|
2016-08-22 11:56:14 -05:00
|
|
|
"unions are unstable and possibly buggy");
|
2016-08-08 17:18:47 -05:00
|
|
|
}
|
|
|
|
|
2016-02-09 04:36:51 -06:00
|
|
|
ast::ItemKind::DefaultImpl(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, optin_builtin_traits,
|
|
|
|
i.span,
|
|
|
|
"default trait implementations are experimental \
|
|
|
|
and possibly buggy");
|
2015-03-10 19:51:50 -05:00
|
|
|
}
|
|
|
|
|
2016-11-18 10:14:42 -06:00
|
|
|
ast::ItemKind::Impl(_, polarity, defaultness, _, _, _, _) => {
|
2017-05-12 13:05:39 -05:00
|
|
|
if let ast::ImplPolarity::Negative = polarity {
|
|
|
|
gate_feature_post!(&self, optin_builtin_traits,
|
|
|
|
i.span,
|
|
|
|
"negative trait bounds are not yet fully implemented; \
|
|
|
|
use marker types for now");
|
2014-12-29 06:52:43 -06:00
|
|
|
}
|
2016-11-18 10:14:42 -06:00
|
|
|
|
2017-04-25 22:17:48 -05:00
|
|
|
if let ast::Defaultness::Default = defaultness {
|
|
|
|
gate_feature_post!(&self, specialization,
|
|
|
|
i.span,
|
|
|
|
"specialization is unstable");
|
2016-11-18 10:14:42 -06:00
|
|
|
}
|
2014-06-17 18:00:04 -05:00
|
|
|
}
|
|
|
|
|
2013-10-02 20:10:16 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
visit::walk_item(self, i);
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
2013-10-15 00:21:54 -05:00
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_foreign_item(&mut self, i: &'a ast::ForeignItem) {
|
2016-11-16 04:52:37 -06:00
|
|
|
let links_to_llvm = match attr::first_attr_value_str_by_name(&i.attrs, "link_name") {
|
|
|
|
Some(val) => val.as_str().starts_with("llvm."),
|
2014-12-30 09:44:31 -06:00
|
|
|
_ => false
|
|
|
|
};
|
|
|
|
if links_to_llvm {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, link_llvm_intrinsics, i.span,
|
2014-12-30 09:44:31 -06:00
|
|
|
"linking to LLVM intrinsics is experimental");
|
|
|
|
}
|
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
visit::walk_foreign_item(self, i)
|
2014-02-25 18:15:10 -06:00
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_ty(&mut self, ty: &'a ast::Ty) {
|
2016-07-16 16:15:15 -05:00
|
|
|
match ty.node {
|
|
|
|
ast::TyKind::BareFn(ref bare_fn_ty) => {
|
|
|
|
self.check_abi(bare_fn_ty.abi, ty.span);
|
|
|
|
}
|
2016-07-31 20:25:32 -05:00
|
|
|
ast::TyKind::ImplTrait(..) => {
|
|
|
|
gate_feature_post!(&self, conservative_impl_trait, ty.span,
|
|
|
|
"`impl Trait` is experimental");
|
|
|
|
}
|
2016-08-02 02:56:20 -05:00
|
|
|
ast::TyKind::Never => {
|
|
|
|
gate_feature_post!(&self, never_type, ty.span,
|
2016-08-01 07:15:54 -05:00
|
|
|
"The `!` type is experimental");
|
|
|
|
},
|
2016-07-16 16:15:15 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
visit::walk_ty(self, ty)
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_fn_ret_ty(&mut self, ret_ty: &'a ast::FunctionRetTy) {
|
2016-08-01 07:15:54 -05:00
|
|
|
if let ast::FunctionRetTy::Ty(ref output_ty) = *ret_ty {
|
2017-05-12 13:05:39 -05:00
|
|
|
if let ast::TyKind::Never = output_ty.node {
|
|
|
|
return
|
|
|
|
}
|
2016-08-13 05:02:13 -05:00
|
|
|
self.visit_ty(output_ty)
|
2016-08-01 07:15:54 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_expr(&mut self, e: &'a ast::Expr) {
|
2013-12-12 01:17:54 -06:00
|
|
|
match e.node {
|
2016-02-08 09:05:05 -06:00
|
|
|
ast::ExprKind::Box(_) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, box_syntax, e.span, EXPLAIN_BOX_SYNTAX);
|
2015-01-07 08:15:34 -06:00
|
|
|
}
|
2016-02-08 09:05:05 -06:00
|
|
|
ast::ExprKind::Type(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, type_ascription, e.span,
|
2015-12-02 20:37:48 -06:00
|
|
|
"type ascription is experimental");
|
|
|
|
}
|
2016-02-11 11:52:39 -06:00
|
|
|
ast::ExprKind::Range(_, _, ast::RangeLimits::Closed) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, inclusive_range_syntax,
|
2016-01-13 00:27:40 -06:00
|
|
|
e.span,
|
|
|
|
"inclusive range syntax is experimental");
|
|
|
|
}
|
2016-05-21 03:39:33 -05:00
|
|
|
ast::ExprKind::InPlace(..) => {
|
|
|
|
gate_feature_post!(&self, placement_in_syntax, e.span, EXPLAIN_PLACEMENT_IN);
|
|
|
|
}
|
2016-10-26 19:15:13 -05:00
|
|
|
ast::ExprKind::Struct(_, ref fields, _) => {
|
|
|
|
for field in fields {
|
2016-09-14 16:51:46 -05:00
|
|
|
if starts_with_digit(&field.ident.node.name.as_str()) {
|
|
|
|
gate_feature_post!(&self, relaxed_adts,
|
|
|
|
field.span,
|
|
|
|
"numeric fields in struct expressions are unstable");
|
|
|
|
}
|
2016-10-26 19:15:13 -05:00
|
|
|
}
|
|
|
|
}
|
Implement the `loop_break_value` feature.
This implements RFC 1624, tracking issue #37339.
- `FnCtxt` (in typeck) gets a stack of `LoopCtxt`s, which store the
currently deduced type of that loop, the desired type, and a list of
break expressions currently seen. `loop` loops get a fresh type
variable as their initial type (this logic is stolen from that for
arrays). `while` loops get `()`.
- `break {expr}` looks up the broken loop, and unifies the type of
`expr` with the type of the loop.
- `break` with no expr unifies the loop's type with `()`.
- When building MIR, `loop` loops no longer construct a `()` value at
termination of the loop; rather, the `break` expression assigns the
result of the loop. `while` loops are unchanged.
- `break` respects contexts in which expressions may not end with braced
blocks. That is, `while break { break-value } { while-body }` is
illegal; this preserves backwards compatibility.
- The RFC did not make it clear, but I chose to make `break ()` inside
of a `while` loop illegal, just in case we wanted to do anything with
that design space in the future.
This is my first time dealing with this part of rustc so I'm sure
there's plenty of problems to pick on here ^_^
2016-10-29 17:15:06 -05:00
|
|
|
ast::ExprKind::Break(_, Some(_)) => {
|
|
|
|
gate_feature_post!(&self, loop_break_value, e.span,
|
|
|
|
"`break` with a value is experimental");
|
|
|
|
}
|
2016-08-23 18:15:15 -05:00
|
|
|
ast::ExprKind::Lit(ref lit) => {
|
|
|
|
if let ast::LitKind::Int(_, ref ty) = lit.node {
|
|
|
|
match *ty {
|
|
|
|
ast::LitIntType::Signed(ast::IntTy::I128) |
|
|
|
|
ast::LitIntType::Unsigned(ast::UintTy::U128) => {
|
|
|
|
gate_feature_post!(&self, i128_type, e.span,
|
|
|
|
"128-bit integers are not stable");
|
|
|
|
}
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2017-02-17 17:12:47 -06:00
|
|
|
ast::ExprKind::Catch(_) => {
|
|
|
|
gate_feature_post!(&self, catch_expr, e.span, "`catch` expression is experimental");
|
|
|
|
}
|
2013-12-12 01:17:54 -06:00
|
|
|
_ => {}
|
|
|
|
}
|
2014-09-12 05:10:30 -05:00
|
|
|
visit::walk_expr(self, e);
|
2013-12-12 01:17:54 -06:00
|
|
|
}
|
2014-01-30 11:28:02 -06:00
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_pat(&mut self, pattern: &'a ast::Pat) {
|
2014-09-06 15:52:07 -05:00
|
|
|
match pattern.node {
|
2016-09-20 09:54:24 -05:00
|
|
|
PatKind::Slice(_, Some(_), ref last) if !last.is_empty() => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, advanced_slice_patterns,
|
2014-09-06 15:52:07 -05:00
|
|
|
pattern.span,
|
|
|
|
"multiple-element slice matches anywhere \
|
|
|
|
but at the end of a slice (e.g. \
|
2015-04-18 22:26:32 -05:00
|
|
|
`[0, ..xs, 0]`) are experimental")
|
2014-09-06 15:52:07 -05:00
|
|
|
}
|
2016-09-20 09:54:24 -05:00
|
|
|
PatKind::Slice(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, slice_patterns,
|
2015-03-26 20:34:27 -05:00
|
|
|
pattern.span,
|
|
|
|
"slice pattern syntax is experimental");
|
|
|
|
}
|
2016-02-11 12:16:33 -06:00
|
|
|
PatKind::Box(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, box_patterns,
|
2015-01-07 08:15:34 -06:00
|
|
|
pattern.span,
|
2015-02-11 05:01:57 -06:00
|
|
|
"box pattern syntax is experimental");
|
2016-03-06 06:54:44 -06:00
|
|
|
}
|
2016-09-14 16:51:46 -05:00
|
|
|
PatKind::Struct(_, ref fields, _) => {
|
|
|
|
for field in fields {
|
|
|
|
if starts_with_digit(&field.node.ident.name.as_str()) {
|
|
|
|
gate_feature_post!(&self, relaxed_adts,
|
|
|
|
field.span,
|
|
|
|
"numeric fields in struct patterns are unstable");
|
|
|
|
}
|
|
|
|
}
|
2016-03-06 06:54:44 -06:00
|
|
|
}
|
2017-01-10 15:13:53 -06:00
|
|
|
PatKind::Range(_, _, RangeEnd::Excluded) => {
|
|
|
|
gate_feature_post!(&self, exclusive_range_pattern, pattern.span,
|
|
|
|
"exclusive range pattern syntax is experimental");
|
|
|
|
}
|
2014-09-06 15:52:07 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
2014-09-12 05:10:30 -05:00
|
|
|
visit::walk_pat(self, pattern)
|
2014-09-06 15:52:07 -05:00
|
|
|
}
|
|
|
|
|
2014-06-20 18:39:23 -05:00
|
|
|
fn visit_fn(&mut self,
|
2016-12-06 04:26:52 -06:00
|
|
|
fn_kind: FnKind<'a>,
|
|
|
|
fn_decl: &'a ast::FnDecl,
|
2014-06-20 18:39:23 -05:00
|
|
|
span: Span,
|
2014-11-15 15:04:04 -06:00
|
|
|
_node_id: NodeId) {
|
2015-05-05 07:47:04 -05:00
|
|
|
// check for const fn declarations
|
2017-05-12 13:05:39 -05:00
|
|
|
if let FnKind::ItemFn(_, _, _, Spanned { node: ast::Constness::Const, .. }, _, _, _) =
|
|
|
|
fn_kind {
|
|
|
|
gate_feature_post!(&self, const_fn, span, "const fn is unstable");
|
2015-05-05 07:47:04 -05:00
|
|
|
}
|
2017-05-12 13:05:39 -05:00
|
|
|
// stability of const fn methods are covered in
|
|
|
|
// visit_trait_item and visit_impl_item below; this is
|
|
|
|
// because default methods don't pass through this
|
|
|
|
// point.
|
2015-05-05 07:47:04 -05:00
|
|
|
|
2014-09-09 17:54:36 -05:00
|
|
|
match fn_kind {
|
2016-10-25 18:17:29 -05:00
|
|
|
FnKind::ItemFn(_, _, _, _, abi, _, _) |
|
|
|
|
FnKind::Method(_, &ast::MethodSig { abi, .. }, _, _) => {
|
2016-07-16 16:15:15 -05:00
|
|
|
self.check_abi(abi, span);
|
|
|
|
}
|
2014-06-20 18:39:23 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
2016-10-25 18:17:29 -05:00
|
|
|
visit::walk_fn(self, fn_kind, fn_decl, span);
|
2014-06-20 18:39:23 -05:00
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_trait_item(&mut self, ti: &'a ast::TraitItem) {
|
2015-03-26 14:06:26 -05:00
|
|
|
match ti.node {
|
2016-02-09 10:54:11 -06:00
|
|
|
ast::TraitItemKind::Const(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, associated_consts,
|
2015-03-26 14:06:26 -05:00
|
|
|
ti.span,
|
|
|
|
"associated constants are experimental")
|
|
|
|
}
|
2016-07-16 16:15:15 -05:00
|
|
|
ast::TraitItemKind::Method(ref sig, ref block) => {
|
|
|
|
if block.is_none() {
|
|
|
|
self.check_abi(sig.abi, ti.span);
|
|
|
|
}
|
2016-08-10 18:20:12 -05:00
|
|
|
if sig.constness.node == ast::Constness::Const {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, const_fn, ti.span, "const fn is unstable");
|
2015-05-05 07:47:04 -05:00
|
|
|
}
|
|
|
|
}
|
2016-02-09 10:54:11 -06:00
|
|
|
ast::TraitItemKind::Type(_, Some(_)) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, associated_type_defaults, ti.span,
|
2015-07-29 14:01:09 -05:00
|
|
|
"associated type defaults are unstable");
|
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
visit::walk_trait_item(self, ti);
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_impl_item(&mut self, ii: &'a ast::ImplItem) {
|
2015-12-30 17:16:43 -06:00
|
|
|
if ii.defaultness == ast::Defaultness::Default {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, specialization,
|
2015-12-30 17:16:43 -06:00
|
|
|
ii.span,
|
|
|
|
"specialization is unstable");
|
|
|
|
}
|
|
|
|
|
2015-03-26 14:06:26 -05:00
|
|
|
match ii.node {
|
2015-11-13 07:15:04 -06:00
|
|
|
ast::ImplItemKind::Const(..) => {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, associated_consts,
|
2015-03-26 14:06:26 -05:00
|
|
|
ii.span,
|
|
|
|
"associated constants are experimental")
|
|
|
|
}
|
2015-11-13 07:15:04 -06:00
|
|
|
ast::ImplItemKind::Method(ref sig, _) => {
|
2016-08-10 18:20:12 -05:00
|
|
|
if sig.constness.node == ast::Constness::Const {
|
2016-04-07 04:15:32 -05:00
|
|
|
gate_feature_post!(&self, const_fn, ii.span, "const fn is unstable");
|
2015-05-05 07:47:04 -05:00
|
|
|
}
|
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
visit::walk_impl_item(self, ii);
|
|
|
|
}
|
2016-04-10 18:33:36 -05:00
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_generics(&mut self, g: &'a ast::Generics) {
|
2016-05-17 11:51:45 -05:00
|
|
|
for t in &g.ty_params {
|
|
|
|
if !t.attrs.is_empty() {
|
|
|
|
gate_feature_post!(&self, generic_param_attrs, t.attrs[0].span,
|
|
|
|
"attributes on type parameter bindings are experimental");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
visit::walk_generics(self, g)
|
|
|
|
}
|
|
|
|
|
2016-12-06 04:26:52 -06:00
|
|
|
fn visit_lifetime_def(&mut self, lifetime_def: &'a ast::LifetimeDef) {
|
2016-05-17 11:51:45 -05:00
|
|
|
if !lifetime_def.attrs.is_empty() {
|
|
|
|
gate_feature_post!(&self, generic_param_attrs, lifetime_def.attrs[0].span,
|
|
|
|
"attributes on lifetime bindings are experimental");
|
|
|
|
}
|
|
|
|
visit::walk_lifetime_def(self, lifetime_def)
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2016-06-10 20:37:24 -05:00
|
|
|
pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute]) -> Features {
|
2016-04-04 10:08:41 -05:00
|
|
|
let mut features = Features::new();
|
2014-09-10 19:55:42 -05:00
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
let mut feature_checker = MutexFeatureChecker::default();
|
|
|
|
|
2016-06-10 20:37:24 -05:00
|
|
|
for attr in krate_attrs {
|
2014-05-21 00:07:42 -05:00
|
|
|
if !attr.check_name("feature") {
|
2014-01-08 12:35:15 -06:00
|
|
|
continue
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
|
|
|
|
match attr.meta_item_list() {
|
|
|
|
None => {
|
2016-06-28 12:40:40 -05:00
|
|
|
span_err!(span_handler, attr.span, E0555,
|
|
|
|
"malformed feature attribute, expected #![feature(...)]");
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
Some(list) => {
|
2015-01-31 11:20:46 -06:00
|
|
|
for mi in list {
|
2016-08-19 20:58:14 -05:00
|
|
|
let name = if let Some(word) = mi.word() {
|
|
|
|
word.name()
|
|
|
|
} else {
|
|
|
|
span_err!(span_handler, mi.span, E0556,
|
|
|
|
"malformed feature, expected just one word");
|
|
|
|
continue
|
|
|
|
};
|
|
|
|
|
2016-04-04 10:08:41 -05:00
|
|
|
if let Some(&(_, _, _, setter)) = ACTIVE_FEATURES.iter()
|
|
|
|
.find(|& &(n, _, _, _)| name == n) {
|
|
|
|
*(setter(&mut features)) = true;
|
2017-01-09 03:31:14 -06:00
|
|
|
feature_checker.collect(&features, mi.span);
|
2016-04-04 10:08:41 -05:00
|
|
|
}
|
|
|
|
else if let Some(&(_, _, _)) = REMOVED_FEATURES.iter()
|
2017-02-25 21:42:22 -06:00
|
|
|
.find(|& &(n, _, _)| name == n)
|
|
|
|
.or_else(|| STABLE_REMOVED_FEATURES.iter()
|
|
|
|
.find(|& &(n, _, _)| name == n)) {
|
2016-06-28 12:40:40 -05:00
|
|
|
span_err!(span_handler, mi.span, E0557, "feature has been removed");
|
2016-04-04 10:08:41 -05:00
|
|
|
}
|
|
|
|
else if let Some(&(_, _, _)) = ACCEPTED_FEATURES.iter()
|
|
|
|
.find(|& &(n, _, _)| name == n) {
|
2016-05-30 15:55:12 -05:00
|
|
|
features.declared_stable_lang_features.push((name, mi.span));
|
2016-04-04 10:08:41 -05:00
|
|
|
} else {
|
|
|
|
features.declared_lib_features.push((name, mi.span));
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
feature_checker.check(span_handler);
|
|
|
|
|
2016-04-06 17:43:03 -05:00
|
|
|
features
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
2017-01-09 03:31:14 -06:00
|
|
|
// A collector for mutually-exclusive features and their flag spans
|
|
|
|
#[derive(Default)]
|
|
|
|
struct MutexFeatureChecker {
|
|
|
|
proc_macro: Option<Span>,
|
|
|
|
custom_attribute: Option<Span>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl MutexFeatureChecker {
|
|
|
|
// If this method turns out to be a hotspot due to branching,
|
|
|
|
// the branching can be eliminated by modifying `setter!()` to set these spans
|
|
|
|
// only for the features that need to be checked for mutual exclusion.
|
|
|
|
fn collect(&mut self, features: &Features, span: Span) {
|
|
|
|
if features.proc_macro {
|
|
|
|
// If self.proc_macro is None, set to Some(span)
|
|
|
|
self.proc_macro = self.proc_macro.or(Some(span));
|
|
|
|
}
|
|
|
|
|
|
|
|
if features.custom_attribute {
|
|
|
|
self.custom_attribute = self.custom_attribute.or(Some(span));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn check(self, handler: &Handler) {
|
|
|
|
if let (Some(pm_span), Some(ca_span)) = (self.proc_macro, self.custom_attribute) {
|
|
|
|
handler.struct_span_err(pm_span, "Cannot use `#![feature(proc_macro)]` and \
|
|
|
|
`#![feature(custom_attribute)] at the same time")
|
|
|
|
.span_note(ca_span, "`#![feature(custom_attribute)]` declared here")
|
|
|
|
.emit();
|
|
|
|
|
|
|
|
panic!(FatalError);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-10 20:37:24 -05:00
|
|
|
pub fn check_crate(krate: &ast::Crate,
|
|
|
|
sess: &ParseSess,
|
|
|
|
features: &Features,
|
2015-06-17 19:48:16 -05:00
|
|
|
plugin_attributes: &[(String, AttributeType)],
|
2016-06-10 20:37:24 -05:00
|
|
|
unstable: UnstableFeatures) {
|
|
|
|
maybe_stage_features(&sess.span_diagnostic, krate, unstable);
|
|
|
|
let ctx = Context {
|
|
|
|
features: features,
|
2016-09-24 11:42:54 -05:00
|
|
|
parse_sess: sess,
|
2016-06-10 20:37:24 -05:00
|
|
|
plugin_attributes: plugin_attributes,
|
|
|
|
};
|
|
|
|
visit::walk_crate(&mut PostExpansionVisitor { context: &ctx }, krate);
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
2015-06-17 19:48:16 -05:00
|
|
|
|
2016-08-02 15:53:58 -05:00
|
|
|
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
2015-06-17 19:48:16 -05:00
|
|
|
pub enum UnstableFeatures {
|
|
|
|
/// Hard errors for unstable features are active, as on
|
|
|
|
/// beta/stable channels.
|
|
|
|
Disallow,
|
2016-10-25 22:14:46 -05:00
|
|
|
/// Allow features to be activated, as on nightly.
|
2015-06-17 19:48:16 -05:00
|
|
|
Allow,
|
|
|
|
/// Errors are bypassed for bootstrapping. This is required any time
|
|
|
|
/// during the build that feature-related lints are set to warn or above
|
|
|
|
/// because the build turns on warnings-as-errors and uses lots of unstable
|
2015-10-07 17:11:25 -05:00
|
|
|
/// features. As a result, this is always required for building Rust itself.
|
2015-06-17 19:48:16 -05:00
|
|
|
Cheat
|
|
|
|
}
|
|
|
|
|
2016-09-24 12:04:07 -05:00
|
|
|
impl UnstableFeatures {
|
|
|
|
pub fn from_environment() -> UnstableFeatures {
|
|
|
|
// Whether this is a feature-staged build, i.e. on the beta or stable channel
|
|
|
|
let disable_unstable_features = option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some();
|
2016-10-18 17:42:01 -05:00
|
|
|
// Whether we should enable unstable features for bootstrapping
|
|
|
|
let bootstrap = env::var("RUSTC_BOOTSTRAP").is_ok();
|
|
|
|
match (disable_unstable_features, bootstrap) {
|
|
|
|
(_, true) => UnstableFeatures::Cheat,
|
|
|
|
(true, _) => UnstableFeatures::Disallow,
|
|
|
|
(false, _) => UnstableFeatures::Allow
|
2016-09-24 12:04:07 -05:00
|
|
|
}
|
|
|
|
}
|
2016-09-24 12:19:17 -05:00
|
|
|
|
|
|
|
pub fn is_nightly_build(&self) -> bool {
|
|
|
|
match *self {
|
|
|
|
UnstableFeatures::Allow | UnstableFeatures::Cheat => true,
|
|
|
|
_ => false,
|
|
|
|
}
|
|
|
|
}
|
2016-09-24 12:04:07 -05:00
|
|
|
}
|
|
|
|
|
2015-12-13 16:17:55 -06:00
|
|
|
fn maybe_stage_features(span_handler: &Handler, krate: &ast::Crate,
|
2015-06-17 19:48:16 -05:00
|
|
|
unstable: UnstableFeatures) {
|
|
|
|
let allow_features = match unstable {
|
|
|
|
UnstableFeatures::Allow => true,
|
|
|
|
UnstableFeatures::Disallow => false,
|
|
|
|
UnstableFeatures::Cheat => true
|
|
|
|
};
|
|
|
|
if !allow_features {
|
|
|
|
for attr in &krate.attrs {
|
|
|
|
if attr.check_name("feature") {
|
|
|
|
let release_channel = option_env!("CFG_RELEASE_CHANNEL").unwrap_or("(unknown)");
|
2016-06-29 10:23:51 -05:00
|
|
|
span_err!(span_handler, attr.span, E0554,
|
2016-06-28 12:40:40 -05:00
|
|
|
"#[feature] may not be used on the {} release channel",
|
|
|
|
release_channel);
|
2015-06-17 19:48:16 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|