use std::default::Default as StdDefault;
use std::cell::{Ref, RefCell};
use syntax::ast;
-use syntax::epoch;
+use syntax::edition;
use syntax_pos::{MultiSpan, Span};
use errors::DiagnosticBuilder;
use hir;
pub id: LintId,
/// e.g., a URL for an issue/PR/RFC or error code
pub reference: &'static str,
- /// If this is an epoch fixing lint, the epoch in which
+ /// If this is an edition fixing lint, the edition in which
/// this lint becomes obsolete
- pub epoch: Option<epoch::Epoch>,
+ pub edition: Option<edition::Edition>,
}
/// The target of the `by_name` map, which accounts for renaming/deprecation.
sess: Option<&Session>,
lints: Vec<FutureIncompatibleInfo>) {
- for epoch in epoch::ALL_EPOCHS {
- let lints = lints.iter().filter(|f| f.epoch == Some(*epoch)).map(|f| f.id)
+ for edition in edition::ALL_EPOCHS {
+ let lints = lints.iter().filter(|f| f.edition == Some(*edition)).map(|f| f.id)
.collect::<Vec<_>>();
if !lints.is_empty() {
- self.register_group(sess, false, epoch.lint_name(), lints)
+ self.register_group(sess, false, edition.lint_name(), lints)
}
}
use std::hash;
use syntax::ast;
use syntax::codemap::MultiSpan;
-use syntax::epoch::Epoch;
+use syntax::edition::Edition;
use syntax::symbol::Symbol;
use syntax::visit as ast_visit;
use syntax_pos::Span;
/// e.g. "imports that are never used"
pub desc: &'static str,
- /// Deny lint after this epoch
- pub epoch_deny: Option<Epoch>,
+ /// Deny lint after this edition
+ pub edition_deny: Option<Edition>,
}
impl Lint {
}
pub fn default_level(&self, session: &Session) -> Level {
- if let Some(epoch_deny) = self.epoch_deny {
- if session.epoch() >= epoch_deny {
+ if let Some(edition_deny) = self.edition_deny {
+ if session.edition() >= edition_deny {
return Level::Deny
}
}
/// Declare a static item of type `&'static Lint`.
#[macro_export]
macro_rules! declare_lint {
- ($vis: vis $NAME: ident, $Level: ident, $desc: expr, $epoch: expr) => (
+ ($vis: vis $NAME: ident, $Level: ident, $desc: expr, $edition: expr) => (
$vis static $NAME: &$crate::lint::Lint = &$crate::lint::Lint {
name: stringify!($NAME),
default_level: $crate::lint::$Level,
desc: $desc,
- epoch_deny: Some($epoch)
+ edition_deny: Some($edition)
};
);
($vis: vis $NAME: ident, $Level: ident, $desc: expr) => (
name: stringify!($NAME),
default_level: $crate::lint::$Level,
desc: $desc,
- epoch_deny: None,
+ edition_deny: None,
};
);
}
// Check for future incompatibility lints and issue a stronger warning.
let lints = sess.lint_store.borrow();
if let Some(future_incompatible) = lints.future_incompatible(LintId::of(lint)) {
- let future = if let Some(epoch) = future_incompatible.epoch {
- format!("the {} epoch", epoch)
+ let future = if let Some(edition) = future_incompatible.edition {
+ format!("the {} edition", edition)
} else {
"a future release".to_owned()
};
use syntax::ast::{self, IntTy, UintTy};
use syntax::codemap::{FileName, FilePathMapping};
-use syntax::epoch::Epoch;
+use syntax::edition::Edition;
use syntax::parse::token;
use syntax::parse;
use syntax::symbol::Symbol;
Some("`string` or `string=string`");
pub const parse_lto: Option<&'static str> =
Some("one of `thin`, `fat`, or omitted");
- pub const parse_epoch: Option<&'static str> =
+ pub const parse_edition: Option<&'static str> =
Some("one of: `2015`, `2018`");
}
use super::{$struct_name, Passes, SomePasses, AllPasses, Sanitizer, Lto};
use rustc_back::{LinkerFlavor, PanicStrategy, RelroLevel};
use std::path::PathBuf;
- use syntax::epoch::Epoch;
+ use syntax::edition::Edition;
$(
pub fn $opt(cg: &mut $struct_name, v: Option<&str>) -> bool {
true
}
- fn parse_epoch(slot: &mut Epoch, v: Option<&str>) -> bool {
+ fn parse_edition(slot: &mut Edition, v: Option<&str>) -> bool {
match v {
Some(s) => {
- let epoch = s.parse();
- if let Ok(parsed) = epoch {
+ let edition = s.parse();
+ if let Ok(parsed) = edition {
*slot = parsed;
true
} else {
`everybody_loops` (all function bodies replaced with `loop {}`),
`hir` (the HIR), `hir,identified`, or
`hir,typed` (HIR with types for each node)."),
- epoch: Epoch = (Epoch::Epoch2015, parse_epoch, [TRACKED],
- "The epoch to build Rust with. Newer epochs may include features
- that require breaking changes. The default epoch is 2015 (the first
- epoch). Crates compiled with different epochs can be linked together."),
+ edition: Edition = (Edition::Edition2015, parse_edition, [TRACKED],
+ "The edition to build Rust with. Newer editions may include features
+ that require breaking changes. The default edition is 2015 (the first
+ edition). Crates compiled with different editions can be linked together."),
run_dsymutil: Option<bool> = (None, parse_opt_bool, [TRACKED],
"run `dsymutil` and delete intermediate object files"),
ui_testing: bool = (false, parse_bool, [UNTRACKED],
use std::hash::Hash;
use std::path::PathBuf;
use std::collections::hash_map::DefaultHasher;
- use super::{CrateType, DebugInfoLevel, Epoch, ErrorOutputType, Lto, OptLevel, OutputTypes,
+ use super::{CrateType, DebugInfoLevel, Edition, ErrorOutputType, Lto, OptLevel, OutputTypes,
Passes, Sanitizer};
use syntax::feature_gate::UnstableFeatures;
use rustc_back::{PanicStrategy, RelroLevel};
impl_dep_tracking_hash_via_hash!(cstore::NativeLibraryKind);
impl_dep_tracking_hash_via_hash!(Sanitizer);
impl_dep_tracking_hash_via_hash!(Option<Sanitizer>);
- impl_dep_tracking_hash_via_hash!(Epoch);
+ impl_dep_tracking_hash_via_hash!(Edition);
impl_dep_tracking_hash_for_sortable_vec_of!(String);
impl_dep_tracking_hash_for_sortable_vec_of!(PathBuf);
use syntax::ast::NodeId;
use errors::{self, DiagnosticBuilder, DiagnosticId};
use errors::emitter::{Emitter, EmitterWriter};
-use syntax::epoch::Epoch;
+use syntax::edition::Edition;
use syntax::json::JsonEmitter;
use syntax::feature_gate;
use syntax::symbol::Symbol;
self.opts.debugging_opts.teach && !self.parse_sess.span_diagnostic.code_emitted(code)
}
- /// Are we allowed to use features from the Rust 2018 epoch?
+ /// Are we allowed to use features from the Rust 2018 edition?
pub fn rust_2018(&self) -> bool {
- self.opts.debugging_opts.epoch >= Epoch::Epoch2018
+ self.opts.debugging_opts.edition >= Edition::Edition2018
}
- pub fn epoch(&self) -> Epoch {
- self.opts.debugging_opts.epoch
+ pub fn edition(&self) -> Edition {
+ self.opts.debugging_opts.edition
}
}
{
let (mut krate, features) = syntax::config::features(krate, &sess.parse_sess,
sess.opts.test,
- sess.opts.debugging_opts.epoch);
+ sess.opts.debugging_opts.edition);
// these need to be set "early" so that expansion sees `quote` if enabled.
sess.init_features(features);
use rustc::util;
use session::Session;
-use syntax::epoch::Epoch;
+use syntax::edition::Edition;
use lint::LintId;
use lint::FutureIncompatibleInfo;
FutureIncompatibleInfo {
id: LintId::of(PRIVATE_IN_PUBLIC),
reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(PUB_USE_OF_PRIVATE_EXTERN_CRATE),
reference: "issue #34537 <https://github.com/rust-lang/rust/issues/34537>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(PATTERNS_IN_FNS_WITHOUT_BODY),
reference: "issue #35203 <https://github.com/rust-lang/rust/issues/35203>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(SAFE_EXTERN_STATICS),
reference: "issue #36247 <https://github.com/rust-lang/rust/issues/36247>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(INVALID_TYPE_PARAM_DEFAULT),
reference: "issue #36887 <https://github.com/rust-lang/rust/issues/36887>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(LEGACY_DIRECTORY_OWNERSHIP),
reference: "issue #37872 <https://github.com/rust-lang/rust/issues/37872>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(LEGACY_IMPORTS),
reference: "issue #38260 <https://github.com/rust-lang/rust/issues/38260>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(LEGACY_CONSTRUCTOR_VISIBILITY),
reference: "issue #39207 <https://github.com/rust-lang/rust/issues/39207>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(MISSING_FRAGMENT_SPECIFIER),
reference: "issue #40107 <https://github.com/rust-lang/rust/issues/40107>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(ILLEGAL_FLOATING_POINT_LITERAL_PATTERN),
reference: "issue #41620 <https://github.com/rust-lang/rust/issues/41620>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(ANONYMOUS_PARAMETERS),
reference: "issue #41686 <https://github.com/rust-lang/rust/issues/41686>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES),
reference: "issue #42238 <https://github.com/rust-lang/rust/issues/42238>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(LATE_BOUND_LIFETIME_ARGUMENTS),
reference: "issue #42868 <https://github.com/rust-lang/rust/issues/42868>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(SAFE_PACKED_BORROWS),
reference: "issue #46043 <https://github.com/rust-lang/rust/issues/46043>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(INCOHERENT_FUNDAMENTAL_IMPLS),
reference: "issue #46205 <https://github.com/rust-lang/rust/issues/46205>",
- epoch: None,
+ edition: None,
},
FutureIncompatibleInfo {
id: LintId::of(TYVAR_BEHIND_RAW_POINTER),
reference: "issue #46906 <https://github.com/rust-lang/rust/issues/46906>",
- epoch: Some(Epoch::Epoch2018),
+ edition: Some(Edition::Edition2018),
}
]);
if reached_raw_pointer
&& !self.tcx.features().arbitrary_self_types {
// this case used to be allowed by the compiler,
- // so we do a future-compat lint here for the 2015 epoch
+ // so we do a future-compat lint here for the 2015 edition
// (see https://github.com/rust-lang/rust/issues/46906)
if self.tcx.sess.rust_2018() {
span_err!(self.tcx.sess, span, E0908,
use {fold, attr};
use ast;
use codemap::Spanned;
-use epoch::Epoch;
+use edition::Edition;
use parse::{token, ParseSess};
use ptr::P;
}
// `cfg_attr`-process the crate's attributes and compute the crate's features.
-pub fn features(mut krate: ast::Crate, sess: &ParseSess, should_test: bool, epoch: Epoch)
+pub fn features(mut krate: ast::Crate, sess: &ParseSess, should_test: bool, edition: Edition)
-> (ast::Crate, Features) {
let features;
{
return (krate, Features::new());
}
- features = get_features(&sess.span_diagnostic, &krate.attrs, epoch);
+ features = get_features(&sess.span_diagnostic, &krate.attrs, edition);
// Avoid reconfiguring malformed `cfg_attr`s
if err_count == sess.span_diagnostic.err_count() {
--- /dev/null
+// Copyright 2018 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.
+
+use std::fmt;
+use std::str::FromStr;
+
+/// The edition of the compiler (RFC 2052)
+#[derive(Clone, Copy, Hash, PartialOrd, Ord, Eq, PartialEq, Debug)]
+#[non_exhaustive]
+pub enum Edition {
+ // editions must be kept in order, newest to oldest
+
+ /// The 2015 edition
+ Edition2015,
+ /// The 2018 edition
+ Edition2018,
+
+ // when adding new editions, be sure to update:
+ //
+ // - the list in the `parse_edition` static in librustc::session::config
+ // - add a `rust_####()` function to the session
+ // - update the enum in Cargo's sources as well
+ //
+ // When -Zedition becomes --edition, there will
+ // also be a check for the edition being nightly-only
+ // somewhere. That will need to be updated
+ // whenever we're stabilizing/introducing a new edition
+ // as well as changing the default Cargo template.
+}
+
+// must be in order from oldest to newest
+pub const ALL_EPOCHS: &[Edition] = &[Edition::Edition2015, Edition::Edition2018];
+
+impl fmt::Display for Edition {
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ let s = match *self {
+ Edition::Edition2015 => "2015",
+ Edition::Edition2018 => "2018",
+ };
+ write!(f, "{}", s)
+ }
+}
+
+impl Edition {
+ pub fn lint_name(&self) -> &'static str {
+ match *self {
+ Edition::Edition2015 => "edition_2015",
+ Edition::Edition2018 => "edition_2018",
+ }
+ }
+}
+
+impl FromStr for Edition {
+ type Err = ();
+ fn from_str(s: &str) -> Result<Self, ()> {
+ match s {
+ "2015" => Ok(Edition::Edition2015),
+ "2018" => Ok(Edition::Edition2018),
+ _ => Err(())
+ }
+ }
+}
+++ /dev/null
-// Copyright 2018 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.
-
-use std::fmt;
-use std::str::FromStr;
-
-/// The epoch of the compiler (RFC 2052)
-#[derive(Clone, Copy, Hash, PartialOrd, Ord, Eq, PartialEq, Debug)]
-#[non_exhaustive]
-pub enum Epoch {
- // epochs must be kept in order, newest to oldest
-
- /// The 2015 epoch
- Epoch2015,
- /// The 2018 epoch
- Epoch2018,
-
- // when adding new epochs, be sure to update:
- //
- // - the list in the `parse_epoch` static in librustc::session::config
- // - add a `rust_####()` function to the session
- // - update the enum in Cargo's sources as well
- //
- // When -Zepoch becomes --epoch, there will
- // also be a check for the epoch being nightly-only
- // somewhere. That will need to be updated
- // whenever we're stabilizing/introducing a new epoch
- // as well as changing the default Cargo template.
-}
-
-// must be in order from oldest to newest
-pub const ALL_EPOCHS: &[Epoch] = &[Epoch::Epoch2015, Epoch::Epoch2018];
-
-impl fmt::Display for Epoch {
- fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let s = match *self {
- Epoch::Epoch2015 => "2015",
- Epoch::Epoch2018 => "2018",
- };
- write!(f, "{}", s)
- }
-}
-
-impl Epoch {
- pub fn lint_name(&self) -> &'static str {
- match *self {
- Epoch::Epoch2015 => "epoch_2015",
- Epoch::Epoch2018 => "epoch_2018",
- }
- }
-}
-
-impl FromStr for Epoch {
- type Err = ();
- fn from_str(s: &str) -> Result<Self, ()> {
- match s {
- "2015" => Ok(Epoch::Epoch2015),
- "2018" => Ok(Epoch::Epoch2018),
- _ => Err(())
- }
- }
-}
use abi::Abi;
use ast::{self, NodeId, PatKind, RangeEnd};
use attr;
-use epoch::Epoch;
+use edition::Edition;
use codemap::Spanned;
use syntax_pos::{Span, DUMMY_SP};
use errors::{DiagnosticBuilder, Handler, FatalError};
}
macro_rules! declare_features {
- ($((active, $feature: ident, $ver: expr, $issue: expr, $epoch: expr),)+) => {
+ ($((active, $feature: ident, $ver: expr, $issue: expr, $edition: expr),)+) => {
/// 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>,
- Option<Epoch>, fn(&mut Features, Span))] =
- &[$((stringify!($feature), $ver, $issue, $epoch, set!($feature))),+];
+ Option<Edition>, fn(&mut Features, Span))] =
+ &[$((stringify!($feature), $ver, $issue, $edition, set!($feature))),+];
/// A set of features to be used by later passes.
#[derive(Clone)]
(active, match_default_bindings, "1.22.0", Some(42640), None),
// Trait object syntax with `dyn` prefix
- (active, dyn_trait, "1.22.0", Some(44662), Some(Epoch::Epoch2018)),
+ (active, dyn_trait, "1.22.0", Some(44662), Some(Edition::Edition2018)),
// `crate` as visibility modifier, synonymous to `pub(crate)`
(active, crate_visibility_modifier, "1.23.0", Some(45388), None),
}
pub fn get_features(span_handler: &Handler, krate_attrs: &[ast::Attribute],
- epoch: Epoch) -> Features {
+ edition: Edition) -> Features {
let mut features = Features::new();
let mut feature_checker = FeatureChecker::default();
- for &(.., f_epoch, set) in ACTIVE_FEATURES.iter() {
- if let Some(f_epoch) = f_epoch {
- if epoch >= f_epoch {
+ for &(.., f_edition, set) in ACTIVE_FEATURES.iter() {
+ if let Some(f_edition) = f_edition {
+ if edition >= f_edition {
// FIXME(Manishearth) there is currently no way to set
- // lang features by epoch
+ // lang features by edition
set(&mut features, DUMMY_SP);
}
}
#[macro_use]
pub mod config;
pub mod entry;
-pub mod epoch;
+pub mod edition;
pub mod feature_gate;
pub mod fold;
pub mod parse;
--- /dev/null
+// Copyright 2012 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.
+
+// ignore-tidy-linelength
+// compile-flags: -Zedition=2015 -Zunstable-options
+
+// tests that editions work with the tyvar warning-turned-error
+
+#[deny(warnings)]
+fn main() {
+ let x = 0;
+ let y = &x as *const _;
+ let _ = y.is_null();
+ //~^ error: type annotations needed [tyvar_behind_raw_pointer]
+ //~^^ warning: this was previously accepted
+}
--- /dev/null
+// Copyright 2012 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.
+
+// ignore-tidy-linelength
+// compile-flags: -Zedition=2018 -Zunstable-options
+
+// tests that editions work with the tyvar warning-turned-error
+
+#[deny(warnings)]
+fn main() {
+ let x = 0;
+ let y = &x as *const _;
+ let _ = y.is_null();
+ //~^ error: the type of this value must be known to call a method on a raw pointer on it [E0908]
+}
+++ /dev/null
-// Copyright 2012 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.
-
-// ignore-tidy-linelength
-// compile-flags: -Zepoch=2015 -Zunstable-options
-
-// tests that epochs work with the tyvar warning-turned-error
-
-#[deny(warnings)]
-fn main() {
- let x = 0;
- let y = &x as *const _;
- let _ = y.is_null();
- //~^ error: type annotations needed [tyvar_behind_raw_pointer]
- //~^^ warning: this was previously accepted
-}
+++ /dev/null
-// Copyright 2012 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.
-
-// ignore-tidy-linelength
-// compile-flags: -Zepoch=2018 -Zunstable-options
-
-// tests that epochs work with the tyvar warning-turned-error
-
-#[deny(warnings)]
-fn main() {
- let x = 0;
- let y = &x as *const _;
- let _ = y.is_null();
- //~^ error: the type of this value must be known to call a method on a raw pointer on it [E0908]
-}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-// ignore-pretty `dyn ::foo` parses differently in the current epoch
+// ignore-pretty `dyn ::foo` parses differently in the current edition
#![feature(dyn_trait)]
// Checks if the correct registers are being used to pass arguments
// when the sysv64 ABI is specified.
-// compile-flags: -Zepoch=2018
+// compile-flags: -Zedition=2018
pub trait Foo {}
| ^^^^^^^
|
= note: #[warn(tyvar_behind_raw_pointer)] on by default
- = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 epoch!
+ = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in the 2018 edition!
= note: for more information, see issue #46906 <https://github.com/rust-lang/rust/issues/46906>
projects / rust.git / commitdiff