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
|
|
|
|
2014-11-06 02:05:53 -06:00
|
|
|
use self::Status::*;
|
2015-02-13 07:35:11 -06:00
|
|
|
use self::AttributeType::*;
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2015-04-01 14:21:03 -05:00
|
|
|
use abi::Abi;
|
2014-09-10 19:55:42 -05:00
|
|
|
use ast::NodeId;
|
|
|
|
use ast;
|
|
|
|
use attr;
|
|
|
|
use attr::AttrMetaMethods;
|
2014-12-23 23:44:13 -06:00
|
|
|
use codemap::{CodeMap, Span};
|
2014-09-10 19:55:42 -05:00
|
|
|
use diagnostic::SpanHandler;
|
|
|
|
use visit;
|
|
|
|
use visit::Visitor;
|
2015-01-14 17:20:14 -06:00
|
|
|
use parse::token::{self, InternedString};
|
2013-11-26 16:55:06 -06:00
|
|
|
|
2014-12-06 19:55:34 -06:00
|
|
|
use std::ascii::AsciiExt;
|
|
|
|
|
2015-01-14 21:27:45 -06:00
|
|
|
// If you change this list without updating src/doc/reference.md, @cmr will be sad
|
|
|
|
// Don't ever remove anything from this list; set them to 'Removed'.
|
|
|
|
// 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).
|
|
|
|
// NB: The featureck.py script parses this information directly out of the source
|
|
|
|
// so take care when modifying it.
|
2015-02-27 08:36:53 -06:00
|
|
|
const KNOWN_FEATURES: &'static [(&'static str, &'static str, Status)] = &[
|
2015-01-14 21:27:45 -06:00
|
|
|
("globs", "1.0.0", Accepted),
|
|
|
|
("macro_rules", "1.0.0", Accepted),
|
|
|
|
("struct_variant", "1.0.0", Accepted),
|
|
|
|
("asm", "1.0.0", Active),
|
|
|
|
("managed_boxes", "1.0.0", Removed),
|
|
|
|
("non_ascii_idents", "1.0.0", Active),
|
|
|
|
("thread_local", "1.0.0", Active),
|
|
|
|
("link_args", "1.0.0", Active),
|
|
|
|
("plugin_registrar", "1.0.0", Active),
|
|
|
|
("log_syntax", "1.0.0", Active),
|
|
|
|
("trace_macros", "1.0.0", Active),
|
|
|
|
("concat_idents", "1.0.0", Active),
|
|
|
|
("intrinsics", "1.0.0", Active),
|
|
|
|
("lang_items", "1.0.0", Active),
|
|
|
|
|
|
|
|
("simd", "1.0.0", Active),
|
|
|
|
("default_type_params", "1.0.0", Accepted),
|
|
|
|
("quote", "1.0.0", Active),
|
|
|
|
("link_llvm_intrinsics", "1.0.0", Active),
|
|
|
|
("linkage", "1.0.0", Active),
|
|
|
|
("struct_inherit", "1.0.0", Removed),
|
|
|
|
|
|
|
|
("quad_precision_float", "1.0.0", Removed),
|
|
|
|
|
|
|
|
("rustc_diagnostic_macros", "1.0.0", Active),
|
|
|
|
("unboxed_closures", "1.0.0", Active),
|
2015-03-24 14:55:29 -05:00
|
|
|
("reflect", "1.0.0", Active),
|
2015-01-24 11:15:42 -06:00
|
|
|
("import_shadowing", "1.0.0", Removed),
|
2015-01-14 21:27:45 -06:00
|
|
|
("advanced_slice_patterns", "1.0.0", Active),
|
|
|
|
("tuple_indexing", "1.0.0", Accepted),
|
|
|
|
("associated_types", "1.0.0", Accepted),
|
|
|
|
("visible_private_types", "1.0.0", Active),
|
2015-02-13 08:48:05 -06:00
|
|
|
("slicing_syntax", "1.0.0", Accepted),
|
2015-01-14 21:27:45 -06:00
|
|
|
("box_syntax", "1.0.0", Active),
|
2015-02-12 04:30:16 -06:00
|
|
|
("placement_in_syntax", "1.0.0", Active),
|
2015-06-05 01:31:27 -05:00
|
|
|
("pushpop_unsafe", "1.2.0", Active),
|
2015-01-14 21:27:45 -06:00
|
|
|
("on_unimplemented", "1.0.0", Active),
|
|
|
|
("simd_ffi", "1.0.0", Active),
|
2015-03-12 21:19:30 -05:00
|
|
|
("allocator", "1.0.0", Active),
|
2015-06-25 12:07:01 -05:00
|
|
|
("needs_allocator", "1.4.0", Active),
|
2015-07-30 16:20:36 -05:00
|
|
|
("linked_from", "1.3.0", Active),
|
2015-01-14 21:27:45 -06:00
|
|
|
|
|
|
|
("if_let", "1.0.0", Accepted),
|
|
|
|
("while_let", "1.0.0", Accepted),
|
|
|
|
|
|
|
|
("plugin", "1.0.0", Active),
|
|
|
|
("start", "1.0.0", Active),
|
|
|
|
("main", "1.0.0", Active),
|
2014-12-31 22:43:46 -06:00
|
|
|
|
2015-03-30 16:46:34 -05:00
|
|
|
("fundamental", "1.0.0", Active),
|
|
|
|
|
2014-05-02 13:04:26 -05:00
|
|
|
// A temporary feature gate used to enable parser extensions needed
|
|
|
|
// to bootstrap fix for #5723.
|
2015-01-14 21:27:45 -06:00
|
|
|
("issue_5723_bootstrap", "1.0.0", Accepted),
|
2014-05-02 13:04:26 -05:00
|
|
|
|
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
|
|
|
// A way to temporarily opt out of opt in copy. This will *never* be accepted.
|
2015-01-14 21:27:45 -06:00
|
|
|
("opt_out_copy", "1.0.0", Removed),
|
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
|
2015-01-14 21:27:45 -06:00
|
|
|
("optin_builtin_traits", "1.0.0", Active),
|
2014-12-29 06:52:43 -06:00
|
|
|
|
2015-02-04 22:00:02 -06:00
|
|
|
// macro reexport needs more discussion and stabilization
|
2015-01-30 14:26:44 -06:00
|
|
|
("macro_reexport", "1.0.0", Active),
|
2015-01-27 16:41:25 -06:00
|
|
|
|
2013-10-02 20:10:16 -05:00
|
|
|
// These are used to test this portion of the compiler, they don't actually
|
|
|
|
// mean anything
|
2015-01-14 21:27:45 -06:00
|
|
|
("test_accepted_feature", "1.0.0", Accepted),
|
|
|
|
("test_removed_feature", "1.0.0", Removed),
|
2015-01-21 20:21:14 -06:00
|
|
|
|
|
|
|
// Allows use of #[staged_api]
|
|
|
|
("staged_api", "1.0.0", Active),
|
2015-02-03 13:51:26 -06:00
|
|
|
|
|
|
|
// Allows using items which are missing stability attributes
|
2015-02-05 18:14:42 -06:00
|
|
|
("unmarked_api", "1.0.0", Active),
|
|
|
|
|
|
|
|
// Allows using #![no_std]
|
|
|
|
("no_std", "1.0.0", Active),
|
2015-02-10 15:49:56 -06:00
|
|
|
|
2015-07-29 19:01:14 -05:00
|
|
|
// Allows using #![no_core]
|
|
|
|
("no_core", "1.3.0", Active),
|
|
|
|
|
2015-02-10 15:49:56 -06:00
|
|
|
// Allows using `box` in patterns; RFC 469
|
|
|
|
("box_patterns", "1.0.0", Active),
|
2015-02-11 16:03:33 -06:00
|
|
|
|
2015-02-11 06:57:40 -06:00
|
|
|
// Allows using the unsafe_no_drop_flag attribute (unlikely to
|
|
|
|
// switch to Accepted; see RFC 320)
|
|
|
|
("unsafe_no_drop_flag", "1.0.0", Active),
|
2015-02-13 09:10:24 -06:00
|
|
|
|
|
|
|
// Allows the use of custom attributes; RFC 572
|
2015-02-16 14:16:36 -06:00
|
|
|
("custom_attribute", "1.0.0", Active),
|
|
|
|
|
2015-03-06 15:15:54 -06:00
|
|
|
// Allows the use of #[derive(Anything)] as sugar for
|
|
|
|
// #[derive_Anything].
|
|
|
|
("custom_derive", "1.0.0", Active),
|
|
|
|
|
2015-02-16 14:16:36 -06:00
|
|
|
// Allows the use of rustc_* attributes; RFC 572
|
|
|
|
("rustc_attrs", "1.0.0", Active),
|
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).
|
|
|
|
("allow_internal_unstable", "1.0.0", Active),
|
2015-03-26 20:34:27 -05:00
|
|
|
|
|
|
|
// #23121. Array patterns have some hazards yet.
|
|
|
|
("slice_patterns", "1.0.0", Active),
|
2015-03-31 18:32:41 -05:00
|
|
|
|
|
|
|
// Allows use of unary negate on unsigned integers, e.g. -e for e: u8
|
|
|
|
("negate_unsigned", "1.0.0", Active),
|
2015-03-26 14:06:26 -05:00
|
|
|
|
|
|
|
// Allows the definition of associated constants in `trait` or `impl`
|
|
|
|
// blocks.
|
|
|
|
("associated_consts", "1.0.0", Active),
|
2015-05-05 07:47:04 -05:00
|
|
|
|
|
|
|
// Allows the definition of `const fn` functions.
|
|
|
|
("const_fn", "1.2.0", Active),
|
2015-06-30 22:05:17 -05:00
|
|
|
|
|
|
|
// Allows using #[prelude_import] on glob `use` items.
|
|
|
|
("prelude_import", "1.2.0", Active),
|
2015-07-02 16:07:42 -05:00
|
|
|
|
|
|
|
// Allows the definition recursive static items.
|
|
|
|
("static_recursion", "1.3.0", Active),
|
2015-07-29 12:31:07 -05:00
|
|
|
|
|
|
|
// Allows default type parameters to influence type inference.
|
2015-07-29 14:01:09 -05:00
|
|
|
("default_type_parameter_fallback", "1.3.0", Active),
|
|
|
|
|
|
|
|
// Allows associated type defaults
|
|
|
|
("associated_type_defaults", "1.2.0", Active),
|
2015-08-03 22:32:02 -05:00
|
|
|
// Allows macros to appear in the type position.
|
|
|
|
|
2015-07-28 11:00:32 -05:00
|
|
|
("type_macros", "1.3.0", Active),
|
2015-07-13 13:35:00 -05:00
|
|
|
|
|
|
|
// allow `repr(simd)`, and importing the various simd intrinsics
|
|
|
|
("simd_basics", "1.3.0", Active),
|
2013-10-02 20:10:16 -05:00
|
|
|
];
|
2015-02-13 09:42:22 -06:00
|
|
|
// (changing above list without updating src/doc/reference.md makes @cmr sad)
|
2013-10-02 20:10:16 -05:00
|
|
|
|
|
|
|
enum Status {
|
|
|
|
/// Represents an active feature that is currently being implemented or
|
|
|
|
/// currently being considered for addition/removal.
|
|
|
|
Active,
|
|
|
|
|
|
|
|
/// Represents a feature which has since been removed (it was once Active)
|
|
|
|
Removed,
|
|
|
|
|
|
|
|
/// This language feature has since been Accepted (it was once Active)
|
|
|
|
Accepted,
|
|
|
|
}
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
// Attributes that have a special meaning to rustc or rustdoc
|
2015-02-27 08:36:53 -06:00
|
|
|
pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType)] = &[
|
2015-02-13 09:10:24 -06:00
|
|
|
// Normal attributes
|
|
|
|
|
|
|
|
("warn", Normal),
|
|
|
|
("allow", Normal),
|
|
|
|
("forbid", Normal),
|
|
|
|
("deny", Normal),
|
|
|
|
|
|
|
|
("macro_reexport", Normal),
|
|
|
|
("macro_use", Normal),
|
|
|
|
("macro_export", Normal),
|
|
|
|
("plugin_registrar", Normal),
|
|
|
|
|
|
|
|
("cfg", Normal),
|
2015-03-02 06:14:01 -06:00
|
|
|
("cfg_attr", Normal),
|
2015-02-13 09:10:24 -06:00
|
|
|
("main", Normal),
|
|
|
|
("start", Normal),
|
|
|
|
("test", Normal),
|
|
|
|
("bench", Normal),
|
|
|
|
("simd", Normal),
|
|
|
|
("repr", Normal),
|
|
|
|
("path", Normal),
|
|
|
|
("abi", Normal),
|
|
|
|
("automatically_derived", Normal),
|
|
|
|
("no_mangle", Normal),
|
|
|
|
("no_link", Normal),
|
|
|
|
("derive", Normal),
|
2015-02-26 00:04:00 -06:00
|
|
|
("should_panic", Normal),
|
2015-02-13 09:10:24 -06:00
|
|
|
("ignore", Normal),
|
|
|
|
("no_implicit_prelude", Normal),
|
|
|
|
("reexport_test_harness_main", Normal),
|
|
|
|
("link_args", Normal),
|
|
|
|
("macro_escape", Normal),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
2015-07-27 15:41:35 -05:00
|
|
|
// Not used any more, but we can't feature gate it
|
|
|
|
("no_stack_check", Normal),
|
|
|
|
|
2015-02-16 12:44:51 -06:00
|
|
|
("staged_api", Gated("staged_api",
|
|
|
|
"staged_api is for use by rustc only")),
|
|
|
|
("plugin", Gated("plugin",
|
|
|
|
"compiler plugins are experimental \
|
|
|
|
and possibly buggy")),
|
|
|
|
("no_std", Gated("no_std",
|
|
|
|
"no_std is experimental")),
|
2015-07-29 19:01:14 -05:00
|
|
|
("no_core", Gated("no_core",
|
|
|
|
"no_core is experimental")),
|
2015-02-16 12:44:51 -06:00
|
|
|
("lang", Gated("lang_items",
|
|
|
|
"language items are subject to change")),
|
2015-02-16 12:49:35 -06:00
|
|
|
("linkage", Gated("linkage",
|
|
|
|
"the `linkage` attribute is experimental \
|
|
|
|
and not portable across platforms")),
|
|
|
|
("thread_local", Gated("thread_local",
|
|
|
|
"`#[thread_local]` is an experimental feature, and does not \
|
|
|
|
currently handle destructors. There is no corresponding \
|
|
|
|
`#[task_local]` mapping to the task model")),
|
2015-02-16 12:44:51 -06:00
|
|
|
|
2015-02-16 14:16:36 -06:00
|
|
|
("rustc_on_unimplemented", Gated("on_unimplemented",
|
|
|
|
"the `#[rustc_on_unimplemented]` attribute \
|
|
|
|
is an experimental feature")),
|
2015-03-12 21:19:30 -05:00
|
|
|
("allocator", Gated("allocator",
|
|
|
|
"the `#[allocator]` attribute is an experimental feature")),
|
2015-06-25 12:07:01 -05:00
|
|
|
("needs_allocator", Gated("needs_allocator", "the `#[needs_allocator]` \
|
|
|
|
attribute is an experimental \
|
|
|
|
feature")),
|
2015-02-16 14:16:36 -06:00
|
|
|
("rustc_variance", Gated("rustc_attrs",
|
|
|
|
"the `#[rustc_variance]` attribute \
|
|
|
|
is an experimental feature")),
|
|
|
|
("rustc_error", Gated("rustc_attrs",
|
|
|
|
"the `#[rustc_error]` attribute \
|
|
|
|
is an experimental feature")),
|
|
|
|
("rustc_move_fragments", Gated("rustc_attrs",
|
|
|
|
"the `#[rustc_move_fragments]` attribute \
|
|
|
|
is an experimental feature")),
|
|
|
|
|
2015-03-06 17:10:20 -06:00
|
|
|
("allow_internal_unstable", Gated("allow_internal_unstable",
|
|
|
|
EXPLAIN_ALLOW_INTERNAL_UNSTABLE)),
|
|
|
|
|
2015-03-30 16:46:34 -05:00
|
|
|
("fundamental", Gated("fundamental",
|
|
|
|
"the `#[fundamental]` attribute \
|
|
|
|
is an experimental feature")),
|
|
|
|
|
2015-07-30 16:20:36 -05:00
|
|
|
("linked_from", Gated("linked_from",
|
|
|
|
"the `#[linked_from]` attribute \
|
|
|
|
is an experimental feature")),
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
// FIXME: #14408 whitelist docs since rustdoc looks at them
|
|
|
|
("doc", Whitelisted),
|
|
|
|
|
|
|
|
// FIXME: #14406 these are processed in trans, which happens after the
|
|
|
|
// lint pass
|
|
|
|
("cold", Whitelisted),
|
|
|
|
("export_name", Whitelisted),
|
|
|
|
("inline", Whitelisted),
|
|
|
|
("link", Whitelisted),
|
|
|
|
("link_name", Whitelisted),
|
|
|
|
("link_section", Whitelisted),
|
|
|
|
("no_builtins", Whitelisted),
|
|
|
|
("no_mangle", Whitelisted),
|
|
|
|
("no_debug", Whitelisted),
|
|
|
|
("omit_gdb_pretty_printer_section", Whitelisted),
|
2015-02-24 18:35:41 -06:00
|
|
|
("unsafe_no_drop_flag", Gated("unsafe_no_drop_flag",
|
|
|
|
"unsafe_no_drop_flag has unstable semantics \
|
|
|
|
and may be removed in the future")),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
|
|
|
// used in resolve
|
2015-06-30 22:05:17 -05:00
|
|
|
("prelude_import", Gated("prelude_import",
|
|
|
|
"`#[prelude_import]` is for use by rustc only")),
|
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
|
|
|
|
("deprecated", Whitelisted),
|
|
|
|
("must_use", Whitelisted),
|
|
|
|
("stable", Whitelisted),
|
|
|
|
("unstable", Whitelisted),
|
|
|
|
|
2015-03-24 14:55:29 -05:00
|
|
|
("rustc_paren_sugar", Gated("unboxed_closures",
|
|
|
|
"unboxed_closures are still evolving")),
|
|
|
|
("rustc_reflect_like", Gated("reflect",
|
|
|
|
"defining reflective traits is still evolving")),
|
2015-02-13 07:35:11 -06:00
|
|
|
|
|
|
|
// Crate level attributes
|
|
|
|
("crate_name", CrateLevel),
|
|
|
|
("crate_type", CrateLevel),
|
2015-02-13 09:10:24 -06:00
|
|
|
("crate_id", CrateLevel),
|
2015-02-13 07:35:11 -06:00
|
|
|
("feature", CrateLevel),
|
|
|
|
("no_start", CrateLevel),
|
|
|
|
("no_main", CrateLevel),
|
|
|
|
("no_builtins", CrateLevel),
|
2015-02-13 09:10:24 -06:00
|
|
|
("recursion_limit", CrateLevel),
|
2015-02-13 07:35:11 -06:00
|
|
|
];
|
|
|
|
|
2015-03-30 08:38:59 -05:00
|
|
|
#[derive(PartialEq, Copy, Clone, Debug)]
|
2015-02-13 07:35:11 -06:00
|
|
|
pub enum AttributeType {
|
|
|
|
/// Normal, builtin attribute that is consumed
|
|
|
|
/// by the compiler before the unused_attribute check
|
|
|
|
Normal,
|
|
|
|
|
|
|
|
/// 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,
|
|
|
|
|
2015-02-16 12:44:51 -06:00
|
|
|
/// Is gated by a given feature gate and reason
|
|
|
|
/// These get whitelisted too
|
|
|
|
Gated(&'static str, &'static str),
|
|
|
|
|
2015-02-13 07:35:11 -06:00
|
|
|
/// Builtin attribute that is only allowed at the crate level
|
|
|
|
CrateLevel,
|
|
|
|
}
|
|
|
|
|
2014-02-24 14:45:31 -06:00
|
|
|
/// A set of features to be used by later passes.
|
|
|
|
pub struct Features {
|
2014-11-15 18:10:22 -06:00
|
|
|
pub unboxed_closures: bool,
|
2014-09-10 19:55:42 -05:00
|
|
|
pub rustc_diagnostic_macros: bool,
|
2014-09-19 14:30:07 -05:00
|
|
|
pub visible_private_types: bool,
|
2015-02-15 15:14:03 -06:00
|
|
|
pub allow_quote: bool,
|
|
|
|
pub allow_asm: bool,
|
2015-02-15 16:49:55 -06:00
|
|
|
pub allow_log_syntax: bool,
|
|
|
|
pub allow_concat_idents: bool,
|
|
|
|
pub allow_trace_macros: bool,
|
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 allow_internal_unstable: bool,
|
2015-03-06 15:15:54 -06:00
|
|
|
pub allow_custom_derive: bool,
|
2015-02-12 04:30:16 -06:00
|
|
|
pub allow_placement_in: bool,
|
|
|
|
pub allow_box: bool,
|
2015-06-05 01:31:27 -05:00
|
|
|
pub allow_pushpop_unsafe: bool,
|
2015-01-15 17:16:20 -06:00
|
|
|
pub simd_ffi: bool,
|
2015-07-13 13:35:00 -05:00
|
|
|
pub simd_basics: bool,
|
2015-02-03 13:51:26 -06:00
|
|
|
pub unmarked_api: bool,
|
2015-03-31 18:32:41 -05:00
|
|
|
pub negate_unsigned: bool,
|
2015-02-02 22:25:42 -06:00
|
|
|
/// spans of #![feature] attrs for stable language features. for error reporting
|
|
|
|
pub declared_stable_lang_features: Vec<Span>,
|
|
|
|
/// #![feature] attrs for non-language (library) features
|
2015-05-28 10:22:00 -05:00
|
|
|
pub declared_lib_features: Vec<(InternedString, Span)>,
|
|
|
|
pub const_fn: bool,
|
2015-07-24 15:39:11 -05:00
|
|
|
pub static_recursion: bool,
|
|
|
|
pub default_type_parameter_fallback: bool,
|
2015-07-28 11:00:32 -05:00
|
|
|
pub type_macros: bool,
|
2014-02-24 14:45:31 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Features {
|
|
|
|
pub fn new() -> Features {
|
|
|
|
Features {
|
2014-11-15 18:10:22 -06:00
|
|
|
unboxed_closures: false,
|
2014-09-10 19:55:42 -05:00
|
|
|
rustc_diagnostic_macros: false,
|
2014-09-19 14:30:07 -05:00
|
|
|
visible_private_types: false,
|
2015-02-15 15:14:03 -06:00
|
|
|
allow_quote: false,
|
|
|
|
allow_asm: false,
|
2015-02-15 16:49:55 -06:00
|
|
|
allow_log_syntax: false,
|
|
|
|
allow_concat_idents: false,
|
|
|
|
allow_trace_macros: false,
|
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
|
|
|
allow_internal_unstable: false,
|
2015-03-06 15:15:54 -06:00
|
|
|
allow_custom_derive: false,
|
2015-02-12 04:30:16 -06:00
|
|
|
allow_placement_in: false,
|
|
|
|
allow_box: false,
|
2015-06-05 01:31:27 -05:00
|
|
|
allow_pushpop_unsafe: false,
|
2015-01-15 17:16:20 -06:00
|
|
|
simd_ffi: false,
|
2015-07-13 13:35:00 -05:00
|
|
|
simd_basics: false,
|
2015-02-03 13:51:26 -06:00
|
|
|
unmarked_api: false,
|
2015-03-31 18:32:41 -05:00
|
|
|
negate_unsigned: false,
|
2015-02-02 22:25:42 -06:00
|
|
|
declared_stable_lang_features: Vec::new(),
|
2015-05-28 10:22:00 -05:00
|
|
|
declared_lib_features: Vec::new(),
|
|
|
|
const_fn: false,
|
2015-07-24 15:39:11 -05:00
|
|
|
static_recursion: false,
|
|
|
|
default_type_parameter_fallback: false,
|
2015-07-28 11:00:32 -05:00
|
|
|
type_macros: false,
|
2014-02-24 14:45:31 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-12 04:30:16 -06:00
|
|
|
const EXPLAIN_BOX_SYNTAX: &'static str =
|
|
|
|
"box expression syntax is experimental; you can call `Box::new` instead.";
|
|
|
|
|
|
|
|
const EXPLAIN_PLACEMENT_IN: &'static str =
|
|
|
|
"placement-in expression syntax is experimental and subject to change.";
|
|
|
|
|
|
|
|
const EXPLAIN_PUSHPOP_UNSAFE: &'static str =
|
|
|
|
"push/pop_unsafe macros are experimental and subject to change.";
|
|
|
|
|
|
|
|
pub fn check_for_box_syntax(f: Option<&Features>, diag: &SpanHandler, span: Span) {
|
|
|
|
if let Some(&Features { allow_box: true, .. }) = f {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emit_feature_err(diag, "box_syntax", span, EXPLAIN_BOX_SYNTAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn check_for_placement_in(f: Option<&Features>, diag: &SpanHandler, span: Span) {
|
|
|
|
if let Some(&Features { allow_placement_in: true, .. }) = f {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emit_feature_err(diag, "placement_in_syntax", span, EXPLAIN_PLACEMENT_IN);
|
|
|
|
}
|
|
|
|
|
2015-06-05 01:31:27 -05:00
|
|
|
pub fn check_for_pushpop_syntax(f: Option<&Features>, diag: &SpanHandler, span: Span) {
|
|
|
|
if let Some(&Features { allow_pushpop_unsafe: true, .. }) = f {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emit_feature_err(diag, "pushpop_unsafe", span, EXPLAIN_PUSHPOP_UNSAFE);
|
|
|
|
}
|
|
|
|
|
2014-03-05 08:36:01 -06:00
|
|
|
struct Context<'a> {
|
|
|
|
features: Vec<&'static str>,
|
2014-09-10 19:55:42 -05:00
|
|
|
span_handler: &'a SpanHandler,
|
2014-12-23 23:44:13 -06:00
|
|
|
cm: &'a CodeMap,
|
2015-05-06 11:38:36 -05:00
|
|
|
plugin_attributes: &'a [(String, AttributeType)],
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2014-03-05 08:36:01 -06:00
|
|
|
impl<'a> Context<'a> {
|
2015-02-12 04:30:16 -06:00
|
|
|
fn enable_feature(&mut self, feature: &'static str) {
|
|
|
|
debug!("enabling feature: {}", feature);
|
|
|
|
self.features.push(feature);
|
|
|
|
}
|
|
|
|
|
2014-05-28 11:24:28 -05:00
|
|
|
fn gate_feature(&self, feature: &str, span: Span, explain: &str) {
|
2015-03-04 01:10:54 -06:00
|
|
|
let has_feature = self.has_feature(feature);
|
|
|
|
debug!("gate_feature(feature = {:?}, span = {:?}); has? {}", feature, span, has_feature);
|
|
|
|
if !has_feature {
|
2015-01-14 17:20:14 -06:00
|
|
|
emit_feature_err(self.span_handler, feature, span, explain);
|
2014-05-28 11:24:28 -05:00
|
|
|
}
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
fn has_feature(&self, feature: &str) -> bool {
|
2014-11-27 14:00:50 -06:00
|
|
|
self.features.iter().any(|&n| n == feature)
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
|
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);
|
|
|
|
let name = &*attr.name();
|
|
|
|
for &(n, ty) in KNOWN_ATTRIBUTES {
|
|
|
|
if n == name {
|
|
|
|
if let Gated(gate, desc) = ty {
|
|
|
|
self.gate_feature(gate, attr.span, desc);
|
|
|
|
}
|
|
|
|
debug!("check_attribute: {:?} is known, {:?}", name, ty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-06-10 11:22:20 -05:00
|
|
|
for &(ref n, ref ty) in self.plugin_attributes {
|
2015-05-06 11:38:36 -05:00
|
|
|
if &*n == name {
|
|
|
|
// 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
|
2015-05-06 11:38:36 -05:00
|
|
|
debug!("check_attribute: {:?} is registered by a plugin, {:?}", name, ty);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
if name.starts_with("rustc_") {
|
|
|
|
self.gate_feature("rustc_attrs", attr.span,
|
|
|
|
"unless otherwise specified, attributes \
|
|
|
|
with the prefix `rustc_` \
|
|
|
|
are reserved for internal compiler diagnostics");
|
2015-03-06 15:15:54 -06:00
|
|
|
} else if name.starts_with("derive_") {
|
|
|
|
self.gate_feature("custom_derive", attr.span,
|
2015-04-17 07:46:36 -05:00
|
|
|
"attributes of the form `#[derive_*]` are reserved \
|
2015-03-06 15:15:54 -06:00
|
|
|
for the compiler");
|
2015-03-06 17:10:20 -06:00
|
|
|
} else {
|
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 {
|
|
|
|
self.gate_feature("custom_attribute", attr.span,
|
|
|
|
&format!("The attribute `{}` is currently \
|
|
|
|
unknown to the compiler and \
|
|
|
|
may have meaning \
|
|
|
|
added to it in the future",
|
|
|
|
name));
|
|
|
|
}
|
2015-03-06 17:10:20 -06:00
|
|
|
}
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2015-01-14 17:20:14 -06:00
|
|
|
pub fn emit_feature_err(diag: &SpanHandler, feature: &str, span: Span, explain: &str) {
|
|
|
|
diag.span_err(span, explain);
|
2015-04-02 10:29:22 -05:00
|
|
|
|
|
|
|
// #23973: do not suggest `#![feature(...)]` if we are in beta/stable
|
2015-04-02 10:47:51 -05:00
|
|
|
if option_env!("CFG_DISABLE_UNSTABLE_FEATURES").is_some() { return; }
|
2015-02-24 08:07:54 -06:00
|
|
|
diag.fileline_help(span, &format!("add #![feature({})] to the \
|
2015-01-14 17:20:14 -06:00
|
|
|
crate attributes to enable",
|
2015-02-18 13:48:57 -06:00
|
|
|
feature));
|
2015-01-14 17:20:14 -06:00
|
|
|
}
|
|
|
|
|
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";
|
|
|
|
|
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 =
|
|
|
|
"`#[derive]` for custom traits is not stable enough for use and is subject to change";
|
|
|
|
|
2014-12-23 23:44:13 -06:00
|
|
|
struct MacroVisitor<'a> {
|
|
|
|
context: &'a Context<'a>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, 'v> Visitor<'v> for MacroVisitor<'a> {
|
2015-01-02 15:39:05 -06:00
|
|
|
fn visit_mac(&mut self, mac: &ast::Mac) {
|
|
|
|
let ast::MacInvocTT(ref path, _, _) = mac.node;
|
2014-12-23 23:44:13 -06:00
|
|
|
let id = path.segments.last().unwrap().identifier;
|
|
|
|
|
2015-02-15 16:49:55 -06:00
|
|
|
// Issue 22234: If you add a new case here, make sure to also
|
|
|
|
// add code to catch the macro during or after expansion.
|
|
|
|
//
|
|
|
|
// We still keep this MacroVisitor (rather than *solely*
|
|
|
|
// relying on catching cases during or after expansion) to
|
|
|
|
// catch uses of these macros within conditionally-compiled
|
|
|
|
// code, e.g. `#[cfg]`-guarded functions.
|
|
|
|
|
2015-01-02 21:41:40 -06:00
|
|
|
if id == token::str_to_ident("asm") {
|
2015-02-15 15:14:03 -06:00
|
|
|
self.context.gate_feature("asm", path.span, EXPLAIN_ASM);
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
else if id == token::str_to_ident("log_syntax") {
|
2015-02-15 16:49:55 -06:00
|
|
|
self.context.gate_feature("log_syntax", path.span, EXPLAIN_LOG_SYNTAX);
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
else if id == token::str_to_ident("trace_macros") {
|
2015-02-15 16:49:55 -06:00
|
|
|
self.context.gate_feature("trace_macros", path.span, EXPLAIN_TRACE_MACROS);
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
else if id == token::str_to_ident("concat_idents") {
|
2015-02-15 16:49:55 -06:00
|
|
|
self.context.gate_feature("concat_idents", path.span, EXPLAIN_CONCAT_IDENTS);
|
2014-12-23 23:44:13 -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
|
|
|
|
|
|
|
fn visit_attribute(&mut self, attr: &'v ast::Attribute) {
|
2015-05-06 11:38:36 -05:00
|
|
|
self.context.check_attribute(attr, true);
|
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
|
|
|
}
|
2015-02-12 04:30:16 -06:00
|
|
|
|
|
|
|
fn visit_expr(&mut self, e: &ast::Expr) {
|
|
|
|
// Issue 22181: overloaded-`box` and placement-`in` are
|
|
|
|
// implemented via a desugaring expansion, so their feature
|
|
|
|
// gates go into MacroVisitor since that works pre-expansion.
|
|
|
|
//
|
|
|
|
// Issue 22234: we also check during expansion as well.
|
|
|
|
// But we keep these checks as a pre-expansion check to catch
|
|
|
|
// uses in e.g. conditionalized code.
|
|
|
|
|
|
|
|
if let ast::ExprBox(None, _) = e.node {
|
|
|
|
self.context.gate_feature("box_syntax", e.span, EXPLAIN_BOX_SYNTAX);
|
|
|
|
}
|
|
|
|
|
|
|
|
if let ast::ExprBox(Some(_), _) = e.node {
|
|
|
|
self.context.gate_feature("placement_in_syntax", e.span, EXPLAIN_PLACEMENT_IN);
|
|
|
|
}
|
|
|
|
|
|
|
|
visit::walk_expr(self, e);
|
|
|
|
}
|
2014-12-23 23:44:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
struct PostExpansionVisitor<'a> {
|
|
|
|
context: &'a Context<'a>
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> PostExpansionVisitor<'a> {
|
|
|
|
fn gate_feature(&self, feature: &str, span: Span, explain: &str) {
|
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
|
|
|
if !self.context.cm.span_allows_unstable(span) {
|
2014-12-23 23:44:13 -06:00
|
|
|
self.context.gate_feature(feature, span, explain)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, 'v> Visitor<'v> for PostExpansionVisitor<'a> {
|
2015-03-06 17:10:20 -06:00
|
|
|
fn visit_attribute(&mut self, attr: &ast::Attribute) {
|
|
|
|
if !self.context.cm.span_allows_unstable(attr.span) {
|
2015-05-06 11:38:36 -05:00
|
|
|
self.context.check_attribute(attr, false);
|
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() {
|
2013-11-22 06:25:14 -06:00
|
|
|
self.gate_feature("non_ascii_idents", sp,
|
|
|
|
"non-ascii idents are not fully supported.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
fn visit_item(&mut self, i: &ast::Item) {
|
2013-10-02 20:10:16 -05:00
|
|
|
match i.node {
|
2015-01-13 09:30:17 -06:00
|
|
|
ast::ItemExternCrate(_) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "macro_reexport") {
|
2015-01-27 16:41:25 -06:00
|
|
|
self.gate_feature("macro_reexport", i.span,
|
|
|
|
"macros reexports are experimental \
|
|
|
|
and possibly buggy");
|
2015-01-13 09:30:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-20 18:39:23 -05:00
|
|
|
ast::ItemForeignMod(ref foreign_module) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "link_args") {
|
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
|
|
|
self.gate_feature("link_args", i.span,
|
|
|
|
"the `link_args` attribute is not portable \
|
|
|
|
across platforms, it is recommended to \
|
|
|
|
use `#[link(name = \"foo\")]` instead")
|
|
|
|
}
|
2015-04-01 14:21:03 -05:00
|
|
|
if foreign_module.abi == Abi::RustIntrinsic {
|
2014-06-20 18:39:23 -05:00
|
|
|
self.gate_feature("intrinsics",
|
|
|
|
i.span,
|
|
|
|
"intrinsics are subject to change")
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2013-12-25 12:10:33 -06:00
|
|
|
ast::ItemFn(..) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "plugin_registrar") {
|
2014-05-24 18:16:10 -05:00
|
|
|
self.gate_feature("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") {
|
2015-01-16 12:55:24 -06:00
|
|
|
self.gate_feature("start", i.span,
|
|
|
|
"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") {
|
2015-01-16 12:55:24 -06:00
|
|
|
self.gate_feature("main", i.span,
|
|
|
|
"declaration of a nonstandard #[main] \
|
|
|
|
function may change over time, for now \
|
|
|
|
a top-level `fn main()` is required");
|
|
|
|
}
|
2013-12-25 12:10:33 -06:00
|
|
|
}
|
|
|
|
|
2014-10-11 12:24:58 -05:00
|
|
|
ast::ItemStruct(..) => {
|
2015-02-18 13:48:57 -06:00
|
|
|
if attr::contains_name(&i.attrs[..], "simd") {
|
2014-01-22 19:25:22 -06:00
|
|
|
self.gate_feature("simd", i.span,
|
|
|
|
"SIMD types are experimental and possibly buggy");
|
2015-07-13 13:35:00 -05:00
|
|
|
self.context.span_handler.span_warn(i.span,
|
|
|
|
"the `#[simd]` attribute is deprecated, \
|
|
|
|
use `#[repr(simd)]` instead");
|
|
|
|
}
|
|
|
|
for attr in &i.attrs {
|
|
|
|
if attr.name() == "repr" {
|
|
|
|
for item in attr.meta_item_list().unwrap_or(&[]) {
|
|
|
|
if item.name() == "simd" {
|
|
|
|
self.gate_feature("simd_basics", i.span,
|
|
|
|
"SIMD types are experimental and possibly buggy");
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2014-02-24 01:17:02 -06:00
|
|
|
}
|
2014-01-22 19:25:22 -06:00
|
|
|
}
|
|
|
|
|
2015-03-10 19:51:50 -05:00
|
|
|
ast::ItemDefaultImpl(..) => {
|
|
|
|
self.gate_feature("optin_builtin_traits",
|
|
|
|
i.span,
|
|
|
|
"default trait implementations are experimental \
|
|
|
|
and possibly buggy");
|
|
|
|
}
|
|
|
|
|
2015-01-05 21:13:38 -06:00
|
|
|
ast::ItemImpl(_, polarity, _, _, _, _) => {
|
2014-12-29 06:52:43 -06:00
|
|
|
match polarity {
|
|
|
|
ast::ImplPolarity::Negative => {
|
|
|
|
self.gate_feature("optin_builtin_traits",
|
|
|
|
i.span,
|
|
|
|
"negative trait bounds are not yet fully implemented; \
|
|
|
|
use marker types for now");
|
|
|
|
},
|
|
|
|
_ => {}
|
|
|
|
}
|
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
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
fn visit_foreign_item(&mut self, i: &ast::ForeignItem) {
|
2015-02-01 20:53:25 -06:00
|
|
|
let links_to_llvm = match attr::first_attr_value_str_by_name(&i.attrs,
|
2015-01-03 22:43:24 -06:00
|
|
|
"link_name") {
|
2015-02-03 16:31:06 -06:00
|
|
|
Some(val) => val.starts_with("llvm."),
|
2014-12-30 09:44:31 -06:00
|
|
|
_ => false
|
|
|
|
};
|
|
|
|
if links_to_llvm {
|
|
|
|
self.gate_feature("link_llvm_intrinsics", i.span,
|
|
|
|
"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
|
|
|
}
|
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
fn visit_expr(&mut self, e: &ast::Expr) {
|
2013-12-12 01:17:54 -06:00
|
|
|
match e.node {
|
2015-01-07 08:15:34 -06:00
|
|
|
ast::ExprBox(..) | ast::ExprUnary(ast::UnOp::UnUniq, _) => {
|
|
|
|
self.gate_feature("box_syntax",
|
|
|
|
e.span,
|
2015-02-11 07:13:33 -06:00
|
|
|
"box expression syntax is experimental; \
|
2015-01-07 08:15:34 -06:00
|
|
|
you can call `Box::new` instead.");
|
|
|
|
}
|
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
|
|
|
|
2014-09-12 05:10:30 -05:00
|
|
|
fn visit_pat(&mut self, pattern: &ast::Pat) {
|
2014-09-06 15:52:07 -05:00
|
|
|
match pattern.node {
|
|
|
|
ast::PatVec(_, Some(_), ref last) if !last.is_empty() => {
|
|
|
|
self.gate_feature("advanced_slice_patterns",
|
|
|
|
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
|
|
|
}
|
2015-03-26 20:34:27 -05:00
|
|
|
ast::PatVec(..) => {
|
|
|
|
self.gate_feature("slice_patterns",
|
|
|
|
pattern.span,
|
|
|
|
"slice pattern syntax is experimental");
|
|
|
|
}
|
2015-01-07 08:15:34 -06:00
|
|
|
ast::PatBox(..) => {
|
2015-02-10 15:49:56 -06:00
|
|
|
self.gate_feature("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");
|
2015-01-07 08:15:34 -06:00
|
|
|
}
|
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,
|
2014-09-09 17:54:36 -05:00
|
|
|
fn_kind: visit::FnKind<'v>,
|
|
|
|
fn_decl: &'v ast::FnDecl,
|
|
|
|
block: &'v ast::Block,
|
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
|
|
|
|
match fn_kind {
|
|
|
|
visit::FkItemFn(_, _, _, ast::Constness::Const, _, _) => {
|
|
|
|
self.gate_feature("const_fn", span, "const fn is unstable");
|
|
|
|
}
|
|
|
|
_ => {
|
|
|
|
// 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.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-09-09 17:54:36 -05:00
|
|
|
match fn_kind {
|
2015-02-25 14:05:07 -06:00
|
|
|
visit::FkItemFn(_, _, _, _, abi, _) if abi == Abi::RustIntrinsic => {
|
2014-06-20 18:39:23 -05:00
|
|
|
self.gate_feature("intrinsics",
|
|
|
|
span,
|
|
|
|
"intrinsics are subject to change")
|
|
|
|
}
|
2015-02-25 14:05:07 -06:00
|
|
|
visit::FkItemFn(_, _, _, _, abi, _) |
|
2015-04-13 16:54:58 -05:00
|
|
|
visit::FkMethod(_, &ast::MethodSig { abi, .. }, _) if abi == Abi::RustCall => {
|
2015-04-01 14:21:03 -05:00
|
|
|
self.gate_feature("unboxed_closures",
|
|
|
|
span,
|
|
|
|
"rust-call ABI is subject to change")
|
|
|
|
}
|
2014-06-20 18:39:23 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
2014-09-12 05:10:30 -05:00
|
|
|
visit::walk_fn(self, fn_kind, fn_decl, block, span);
|
2014-06-20 18:39:23 -05:00
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
|
|
|
|
fn visit_trait_item(&mut self, ti: &'v ast::TraitItem) {
|
|
|
|
match ti.node {
|
|
|
|
ast::ConstTraitItem(..) => {
|
|
|
|
self.gate_feature("associated_consts",
|
|
|
|
ti.span,
|
|
|
|
"associated constants are experimental")
|
|
|
|
}
|
2015-05-05 07:47:04 -05:00
|
|
|
ast::MethodTraitItem(ref sig, _) => {
|
|
|
|
if sig.constness == ast::Constness::Const {
|
|
|
|
self.gate_feature("const_fn", ti.span, "const fn is unstable");
|
|
|
|
}
|
|
|
|
}
|
2015-07-29 14:01:09 -05:00
|
|
|
ast::TypeTraitItem(_, Some(_)) => {
|
|
|
|
self.gate_feature("associated_type_defaults", ti.span,
|
|
|
|
"associated type defaults are unstable");
|
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
visit::walk_trait_item(self, ti);
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_impl_item(&mut self, ii: &'v ast::ImplItem) {
|
|
|
|
match ii.node {
|
|
|
|
ast::ConstImplItem(..) => {
|
|
|
|
self.gate_feature("associated_consts",
|
|
|
|
ii.span,
|
|
|
|
"associated constants are experimental")
|
|
|
|
}
|
2015-05-05 07:47:04 -05:00
|
|
|
ast::MethodImplItem(ref sig, _) => {
|
|
|
|
if sig.constness == ast::Constness::Const {
|
|
|
|
self.gate_feature("const_fn", ii.span, "const fn is unstable");
|
|
|
|
}
|
|
|
|
}
|
2015-03-26 14:06:26 -05:00
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
visit::walk_impl_item(self, ii);
|
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
|
2015-03-24 15:26:16 -05:00
|
|
|
fn check_crate_inner<F>(cm: &CodeMap, span_handler: &SpanHandler,
|
|
|
|
krate: &ast::Crate,
|
2015-05-06 11:38:36 -05:00
|
|
|
plugin_attributes: &[(String, AttributeType)],
|
2014-12-23 23:44:13 -06:00
|
|
|
check: F)
|
2015-01-14 17:20:14 -06:00
|
|
|
-> Features
|
2014-12-23 23:44:13 -06:00
|
|
|
where F: FnOnce(&mut Context, &ast::Crate)
|
|
|
|
{
|
2013-10-02 20:10:16 -05:00
|
|
|
let mut cx = Context {
|
2014-03-04 12:02:49 -06:00
|
|
|
features: Vec::new(),
|
2014-09-10 19:55:42 -05:00
|
|
|
span_handler: span_handler,
|
2014-12-23 23:44:13 -06:00
|
|
|
cm: cm,
|
2015-05-06 11:38:36 -05:00
|
|
|
plugin_attributes: plugin_attributes,
|
2013-10-02 20:10:16 -05:00
|
|
|
};
|
|
|
|
|
2015-02-02 22:25:42 -06:00
|
|
|
let mut accepted_features = Vec::new();
|
2014-09-10 19:55:42 -05:00
|
|
|
let mut unknown_features = Vec::new();
|
|
|
|
|
2015-01-31 11:20:46 -06: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 => {
|
2014-09-10 19:55:42 -05:00
|
|
|
span_handler.span_err(attr.span, "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 {
|
2013-10-02 20:10:16 -05:00
|
|
|
let name = match mi.node {
|
2014-01-08 12:35:15 -06:00
|
|
|
ast::MetaWord(ref word) => (*word).clone(),
|
2013-10-02 20:10:16 -05:00
|
|
|
_ => {
|
2014-09-10 19:55:42 -05:00
|
|
|
span_handler.span_err(mi.span,
|
|
|
|
"malformed feature, expected just \
|
|
|
|
one word");
|
2013-10-02 20:10:16 -05:00
|
|
|
continue
|
|
|
|
}
|
|
|
|
};
|
2014-01-08 12:35:15 -06:00
|
|
|
match KNOWN_FEATURES.iter()
|
2015-01-14 21:27:45 -06:00
|
|
|
.find(|& &(n, _, _)| name == n) {
|
|
|
|
Some(&(name, _, Active)) => {
|
2015-02-12 04:30:16 -06:00
|
|
|
cx.enable_feature(name);
|
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
|
|
|
}
|
2015-01-14 21:27:45 -06:00
|
|
|
Some(&(_, _, Removed)) => {
|
2014-09-10 19:55:42 -05:00
|
|
|
span_handler.span_err(mi.span, "feature has been removed");
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
2015-01-14 21:27:45 -06:00
|
|
|
Some(&(_, _, Accepted)) => {
|
2015-02-02 22:25:42 -06:00
|
|
|
accepted_features.push(mi.span);
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
None => {
|
2015-01-14 17:20:14 -06:00
|
|
|
unknown_features.push((name, mi.span));
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-12-23 23:44:13 -06:00
|
|
|
check(&mut cx, krate);
|
2013-10-02 20:10:16 -05:00
|
|
|
|
2015-02-15 16:49:55 -06:00
|
|
|
// FIXME (pnkfelix): Before adding the 99th entry below, change it
|
|
|
|
// to a single-pass (instead of N calls to `.has_feature`).
|
|
|
|
|
2015-01-14 17:20:14 -06:00
|
|
|
Features {
|
2014-11-15 18:10:22 -06:00
|
|
|
unboxed_closures: cx.has_feature("unboxed_closures"),
|
2014-09-10 19:55:42 -05:00
|
|
|
rustc_diagnostic_macros: cx.has_feature("rustc_diagnostic_macros"),
|
2014-09-19 14:30:07 -05:00
|
|
|
visible_private_types: cx.has_feature("visible_private_types"),
|
2015-02-15 15:14:03 -06:00
|
|
|
allow_quote: cx.has_feature("quote"),
|
|
|
|
allow_asm: cx.has_feature("asm"),
|
2015-02-15 16:49:55 -06:00
|
|
|
allow_log_syntax: cx.has_feature("log_syntax"),
|
|
|
|
allow_concat_idents: cx.has_feature("concat_idents"),
|
|
|
|
allow_trace_macros: cx.has_feature("trace_macros"),
|
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
|
|
|
allow_internal_unstable: cx.has_feature("allow_internal_unstable"),
|
2015-03-06 15:15:54 -06:00
|
|
|
allow_custom_derive: cx.has_feature("custom_derive"),
|
2015-02-12 04:30:16 -06:00
|
|
|
allow_placement_in: cx.has_feature("placement_in_syntax"),
|
|
|
|
allow_box: cx.has_feature("box_syntax"),
|
2015-06-05 01:31:27 -05:00
|
|
|
allow_pushpop_unsafe: cx.has_feature("pushpop_unsafe"),
|
2015-01-15 17:16:20 -06:00
|
|
|
simd_ffi: cx.has_feature("simd_ffi"),
|
2015-07-13 13:35:00 -05:00
|
|
|
simd_basics: cx.has_feature("simd_basics"),
|
2015-02-03 13:51:26 -06:00
|
|
|
unmarked_api: cx.has_feature("unmarked_api"),
|
2015-03-31 18:32:41 -05:00
|
|
|
negate_unsigned: cx.has_feature("negate_unsigned"),
|
2015-02-02 22:25:42 -06:00
|
|
|
declared_stable_lang_features: accepted_features,
|
2015-05-28 10:22:00 -05:00
|
|
|
declared_lib_features: unknown_features,
|
|
|
|
const_fn: cx.has_feature("const_fn"),
|
2015-07-25 23:22:38 -05:00
|
|
|
static_recursion: cx.has_feature("static_recursion"),
|
2015-07-24 15:39:11 -05:00
|
|
|
default_type_parameter_fallback: cx.has_feature("default_type_parameter_fallback"),
|
2015-07-28 11:00:32 -05:00
|
|
|
type_macros: cx.has_feature("type_macros"),
|
2015-01-14 17:20:14 -06:00
|
|
|
}
|
2013-10-02 20:10:16 -05:00
|
|
|
}
|
2014-12-23 23:44:13 -06:00
|
|
|
|
|
|
|
pub fn check_crate_macros(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate)
|
2015-01-14 17:20:14 -06:00
|
|
|
-> Features {
|
2015-05-06 11:38:36 -05:00
|
|
|
check_crate_inner(cm, span_handler, krate, &[] as &'static [_],
|
2014-12-23 23:44:13 -06:00
|
|
|
|ctx, krate| visit::walk_crate(&mut MacroVisitor { context: ctx }, krate))
|
|
|
|
}
|
|
|
|
|
2015-05-06 11:38:36 -05:00
|
|
|
pub fn check_crate(cm: &CodeMap, span_handler: &SpanHandler, krate: &ast::Crate,
|
2015-06-17 19:48:16 -05:00
|
|
|
plugin_attributes: &[(String, AttributeType)],
|
|
|
|
unstable: UnstableFeatures) -> Features
|
2015-03-04 01:05:38 -06:00
|
|
|
{
|
2015-06-17 19:48:16 -05:00
|
|
|
maybe_stage_features(span_handler, krate, unstable);
|
|
|
|
|
2015-05-06 11:38:36 -05:00
|
|
|
check_crate_inner(cm, span_handler, krate, plugin_attributes,
|
2014-12-23 23:44:13 -06:00
|
|
|
|ctx, krate| visit::walk_crate(&mut PostExpansionVisitor { context: ctx },
|
|
|
|
krate))
|
|
|
|
}
|
2015-06-17 19:48:16 -05:00
|
|
|
|
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
pub enum UnstableFeatures {
|
|
|
|
/// Hard errors for unstable features are active, as on
|
|
|
|
/// beta/stable channels.
|
|
|
|
Disallow,
|
|
|
|
/// Allow features to me activated, as on nightly.
|
|
|
|
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
|
|
|
|
/// features. As a result, this this is always required for building Rust
|
|
|
|
/// itself.
|
|
|
|
Cheat
|
|
|
|
}
|
|
|
|
|
|
|
|
fn maybe_stage_features(span_handler: &SpanHandler, krate: &ast::Crate,
|
|
|
|
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)");
|
|
|
|
let ref msg = format!("#[feature] may not be used on the {} release channel",
|
|
|
|
release_channel);
|
|
|
|
span_handler.span_err(attr.span, msg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|