squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Auto merge of #28349 - nrc:ast-lints, r=manishearth

Browse source 
r? @nikomatsakis, f? @Manishearth
This commit is contained in:
bors 2015-09-17 03:05:56 +00:00
commit d16129bca5
58 changed files with 792 additions and 434 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/librustc/lint/builtin.rs
View file

@ -14,7 +14,7 @@
//! compiler code, rather than using their own custom pass. Those
//! lints are all available in `rustc_lint::builtin`.
use lint::{LintPass, LintArray};
use lint::{LintPass, LateLintPass, LintArray};
declare_lint! {
pub UNUSED_IMPORTS,
@ -138,3 +138,5 @@ impl LintPass for HardwiredLints {
)
}
}
impl LateLintPass for HardwiredLints {}

561
src/librustc/lint/context.rs
View file

@ -28,7 +28,8 @@ use self::TargetLint::*;
use middle::privacy::ExportedItems;
use middle::ty::{self, Ty};
use session::{early_error, Session};
use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass, LintPassObject};
use lint::{Level, LevelSource, Lint, LintId, LintArray, LintPass};
use lint::{EarlyLintPass, EarlyLintPassObject, LateLintPass, LateLintPassObject};
use lint::{Default, CommandLine, Node, Allow, Warn, Deny, Forbid};
use lint::builtin;
use util::nodemap::FnvHashMap;
@ -36,15 +37,15 @@ use util::nodemap::FnvHashMap;
use std::cell::RefCell;
use std::cmp;
use std::mem;
use syntax::ast_util::IdVisitingOperation;
use syntax::ast_util::{self, IdVisitingOperation};
use syntax::attr::{self, AttrMetaMethods};
use syntax::codemap::Span;
use syntax::parse::token::InternedString;
use syntax::ast;
use rustc_front::hir;
use rustc_front::visit::{self, Visitor, FnKind};
use rustc_front::util;
use syntax::visit::Visitor as SyntaxVisitor;
use rustc_front::visit as hir_visit;
use syntax::visit as ast_visit;
use syntax::diagnostic;
/// Information about the registered lints.
@ -59,7 +60,8 @@ pub struct LintStore {
/// Trait objects for each lint pass.
/// This is only `None` while iterating over the objects. See the definition
/// of run_lints.
passes: Option<Vec<LintPassObject>>,
early_passes: Option<Vec<EarlyLintPassObject>>,
late_passes: Option<Vec<LateLintPassObject>>,
/// Lints indexed by name.
by_name: FnvHashMap<String, TargetLint>,
@ -115,7 +117,8 @@ impl LintStore {
pub fn new() -> LintStore {
LintStore {
lints: vec!(),
passes: Some(vec!()),
early_passes: Some(vec!()),
late_passes: Some(vec!()),
by_name: FnvHashMap(),
levels: FnvHashMap(),
lint_groups: FnvHashMap(),
@ -133,8 +136,27 @@ impl LintStore {
v.1)).collect()
}
pub fn register_pass(&mut self, sess: Option<&Session>,
from_plugin: bool, pass: LintPassObject) {
pub fn register_early_pass(&mut self,
sess: Option<&Session>,
from_plugin: bool,
pass: EarlyLintPassObject) {
self.push_pass(sess, from_plugin, &pass);
self.early_passes.as_mut().unwrap().push(pass);
}
pub fn register_late_pass(&mut self,
sess: Option<&Session>,
from_plugin: bool,
pass: LateLintPassObject) {
self.push_pass(sess, from_plugin, &pass);
self.late_passes.as_mut().unwrap().push(pass);
}
// Helper method for register_early/late_pass
fn push_pass<P: LintPass + ?Sized + 'static>(&mut self,
sess: Option<&Session>,
from_plugin: bool,
pass: &Box<P>) {
for &lint in pass.get_lints() {
self.lints.push((*lint, from_plugin));
@ -156,7 +178,6 @@ impl LintStore {
self.levels.insert(id, (lint.default_level, Default));
}
}
self.passes.as_mut().unwrap().push(pass);
}
pub fn register_group(&mut self, sess: Option<&Session>,
@ -248,8 +269,8 @@ impl LintStore {
}
}
/// Context for lint checking.
pub struct Context<'a, 'tcx: 'a> {
/// Context for lint checking after type checking.
pub struct LateContext<'a, 'tcx: 'a> {
/// Type context we're checking in.
pub tcx: &'a ty::ctxt<'tcx>,
@ -272,15 +293,33 @@ pub struct Context<'a, 'tcx: 'a> {
node_levels: RefCell<FnvHashMap<(ast::NodeId, LintId), LevelSource>>,
}
/// Context for lint checking of the AST, after expansion, before lowering to
/// HIR.
pub struct EarlyContext<'a> {
/// Type context we're checking in.
pub sess: &'a Session,
/// The crate being checked.
pub krate: &'a ast::Crate,
/// The store of registered lints.
lints: LintStore,
/// When recursing into an attributed node of the ast which modifies lint
/// levels, this stack keeps track of the previous lint levels of whatever
/// was modified.
level_stack: Vec<(LintId, LevelSource)>,
}
/// Convenience macro for calling a `LintPass` method on every pass in the context.
macro_rules! run_lints { ($cx:expr, $f:ident, $($args:expr),*) => ({
macro_rules! run_lints { ($cx:expr, $f:ident, $ps:ident, $($args:expr),*) => ({
// Move the vector of passes out of `$cx` so that we can
// iterate over it mutably while passing `$cx` to the methods.
let mut passes = $cx.lints.passes.take().unwrap();
let mut passes = $cx.mut_lints().$ps.take().unwrap();
for obj in &mut passes {
obj.$f($cx, $($args),*);
}
$cx.lints.passes = Some(passes);
$cx.mut_lints().$ps = Some(passes);
}) }
/// Parse the lint attributes into a vector, with `Err`s for malformed lint
@ -364,65 +403,50 @@ pub fn raw_emit_lint(sess: &Session, lint: &'static Lint,
}
}
impl<'a, 'tcx> Context<'a, 'tcx> {
fn new(tcx: &'a ty::ctxt<'tcx>,
krate: &'a hir::Crate,
exported_items: &'a ExportedItems) -> Context<'a, 'tcx> {
// We want to own the lint store, so move it out of the session.
let lint_store = mem::replace(&mut *tcx.sess.lint_store.borrow_mut(),
LintStore::new());
Context {
tcx: tcx,
krate: krate,
exported_items: exported_items,
lints: lint_store,
level_stack: vec![],
node_levels: RefCell::new(FnvHashMap()),
}
}
/// Get the overall compiler `Session` object.
pub fn sess(&'a self) -> &'a Session {
&self.tcx.sess
}
pub trait LintContext: Sized {
fn sess(&self) -> &Session;
fn lints(&self) -> &LintStore;
fn mut_lints(&mut self) -> &mut LintStore;
fn level_stack(&mut self) -> &mut Vec<(LintId, LevelSource)>;
fn enter_attrs(&mut self, attrs: &[ast::Attribute]);
fn exit_attrs(&mut self, attrs: &[ast::Attribute]);
/// Get the level of `lint` at the current position of the lint
/// traversal.
pub fn current_level(&self, lint: &'static Lint) -> Level {
self.lints.levels.get(&LintId::of(lint)).map_or(Allow, |&(lvl, _)| lvl)
fn current_level(&self, lint: &'static Lint) -> Level {
self.lints().levels.get(&LintId::of(lint)).map_or(Allow, |&(lvl, _)| lvl)
}
fn lookup_and_emit(&self, lint: &'static Lint, span: Option<Span>, msg: &str) {
let (level, src) = match self.lints.levels.get(&LintId::of(lint)) {
let (level, src) = match self.lints().levels.get(&LintId::of(lint)) {
None => return,
Some(&(Warn, src)) => {
let lint_id = LintId::of(builtin::WARNINGS);
(self.lints.get_level_source(lint_id).0, src)
(self.lints().get_level_source(lint_id).0, src)
}
Some(&pair) => pair,
};
raw_emit_lint(&self.tcx.sess, lint, (level, src), span, msg);
}
/// Emit a lint at the appropriate level, with no associated span.
pub fn lint(&self, lint: &'static Lint, msg: &str) {
self.lookup_and_emit(lint, None, msg);
raw_emit_lint(&self.sess(), lint, (level, src), span, msg);
}
/// Emit a lint at the appropriate level, for a particular span.
pub fn span_lint(&self, lint: &'static Lint, span: Span, msg: &str) {
fn span_lint(&self, lint: &'static Lint, span: Span, msg: &str) {
self.lookup_and_emit(lint, Some(span), msg);
}
/// Emit a lint at the appropriate level, with no associated span.
fn lint(&self, lint: &'static Lint, msg: &str) {
self.lookup_and_emit(lint, None, msg);
}
/// Merge the lints specified by any lint attributes into the
/// current lint context, call the provided function, then reset the
/// lints in effect to their previous state.
fn with_lint_attrs<F>(&mut self,
attrs: &[ast::Attribute],
f: F) where
F: FnOnce(&mut Context),
f: F)
where F: FnOnce(&mut Self),
{
// Parse all of the lint attributes, and then add them all to the
// current dictionary of lint information. Along the way, keep a history
@ -433,15 +457,15 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
for result in gather_attrs(attrs) {
let v = match result {
Err(span) => {
span_err!(self.tcx.sess, span, E0452,
span_err!(self.sess(), span, E0452,
"malformed lint attribute");
continue;
}
Ok((lint_name, level, span)) => {
match self.lints.find_lint(&lint_name, &self.tcx.sess, Some(span)) {
match self.lints().find_lint(&lint_name, &self.sess(), Some(span)) {
Ok(lint_id) => vec![(lint_id, level, span)],
Err(FindLintError::NotFound) => {
match self.lints.lint_groups.get(&lint_name[..]) {
match self.lints().lint_groups.get(&lint_name[..]) {
Some(&(ref v, _)) => v.iter()
.map(|lint_id: &LintId|
(*lint_id, level, span))
@ -460,35 +484,82 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
};
for (lint_id, level, span) in v {
let now = self.lints.get_level_source(lint_id).0;
let now = self.lints().get_level_source(lint_id).0;
if now == Forbid && level != Forbid {
let lint_name = lint_id.as_str();
span_err!(self.tcx.sess, span, E0453,
span_err!(self.sess(), span, E0453,
"{}({}) overruled by outer forbid({})",
level.as_str(), lint_name,
lint_name);
} else if now != level {
let src = self.lints.get_level_source(lint_id).1;
self.level_stack.push((lint_id, (now, src)));
let src = self.lints().get_level_source(lint_id).1;
self.level_stack().push((lint_id, (now, src)));
pushed += 1;
self.lints.set_level(lint_id, (level, Node(span)));
self.mut_lints().set_level(lint_id, (level, Node(span)));
}
}
}
run_lints!(self, enter_lint_attrs, attrs);
self.enter_attrs(attrs);
f(self);
run_lints!(self, exit_lint_attrs, attrs);
self.exit_attrs(attrs);
// rollback
for _ in 0..pushed {
let (lint, lvlsrc) = self.level_stack.pop().unwrap();
self.lints.set_level(lint, lvlsrc);
let (lint, lvlsrc) = self.level_stack().pop().unwrap();
self.mut_lints().set_level(lint, lvlsrc);
}
}
}
impl<'a> EarlyContext<'a> {
fn new(sess: &'a Session,
krate: &'a ast::Crate) -> EarlyContext<'a> {
// We want to own the lint store, so move it out of the session. Remember
// to put it back later...
let lint_store = mem::replace(&mut *sess.lint_store.borrow_mut(),
LintStore::new());
EarlyContext {
sess: sess,
krate: krate,
lints: lint_store,
level_stack: vec![],
}
}
fn visit_ids<F>(&mut self, f: F) where
F: FnOnce(&mut util::IdVisitor<Context>)
fn visit_ids<F>(&mut self, f: F)
where F: FnOnce(&mut ast_util::IdVisitor<EarlyContext>)
{
let mut v = ast_util::IdVisitor {
operation: self,
pass_through_items: false,
visited_outermost: false,
};
f(&mut v);
}
}
impl<'a, 'tcx> LateContext<'a, 'tcx> {
fn new(tcx: &'a ty::ctxt<'tcx>,
krate: &'a hir::Crate,
exported_items: &'a ExportedItems) -> LateContext<'a, 'tcx> {
// We want to own the lint store, so move it out of the session.
let lint_store = mem::replace(&mut *tcx.sess.lint_store.borrow_mut(),
LintStore::new());
LateContext {
tcx: tcx,
krate: krate,
exported_items: exported_items,
lints: lint_store,
level_stack: vec![],
node_levels: RefCell::new(FnvHashMap()),
}
}
fn visit_ids<F>(&mut self, f: F)
where F: FnOnce(&mut util::IdVisitor<LateContext>)
{
let mut v = util::IdVisitor {
operation: self,
@ -499,41 +570,95 @@ impl<'a, 'tcx> Context<'a, 'tcx> {
}
}
impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
impl<'a, 'tcx> LintContext for LateContext<'a, 'tcx> {
/// Get the overall compiler `Session` object.
fn sess(&self) -> &Session {
&self.tcx.sess
}
fn lints(&self) -> &LintStore {
&self.lints
}
fn mut_lints(&mut self) -> &mut LintStore {
&mut self.lints
}
fn level_stack(&mut self) -> &mut Vec<(LintId, LevelSource)> {
&mut self.level_stack
}
fn enter_attrs(&mut self, attrs: &[ast::Attribute]) {
run_lints!(self, enter_lint_attrs, late_passes, attrs);
}
fn exit_attrs(&mut self, attrs: &[ast::Attribute]) {
run_lints!(self, exit_lint_attrs, late_passes, attrs);
}
}
impl<'a> LintContext for EarlyContext<'a> {
/// Get the overall compiler `Session` object.
fn sess(&self) -> &Session {
&self.sess
}
fn lints(&self) -> &LintStore {
&self.lints
}
fn mut_lints(&mut self) -> &mut LintStore {
&mut self.lints
}
fn level_stack(&mut self) -> &mut Vec<(LintId, LevelSource)> {
&mut self.level_stack
}
fn enter_attrs(&mut self, attrs: &[ast::Attribute]) {
run_lints!(self, enter_lint_attrs, early_passes, attrs);
}
fn exit_attrs(&mut self, attrs: &[ast::Attribute]) {
run_lints!(self, exit_lint_attrs, early_passes, attrs);
}
}
impl<'a, 'tcx, 'v> hir_visit::Visitor<'v> for LateContext<'a, 'tcx> {
fn visit_item(&mut self, it: &hir::Item) {
self.with_lint_attrs(&it.attrs, |cx| {
run_lints!(cx, check_item, it);
run_lints!(cx, check_item, late_passes, it);
cx.visit_ids(|v| v.visit_item(it));
visit::walk_item(cx, it);
hir_visit::walk_item(cx, it);
})
}
fn visit_foreign_item(&mut self, it: &hir::ForeignItem) {
self.with_lint_attrs(&it.attrs, |cx| {
run_lints!(cx, check_foreign_item, it);
visit::walk_foreign_item(cx, it);
run_lints!(cx, check_foreign_item, late_passes, it);
hir_visit::walk_foreign_item(cx, it);
})
}
fn visit_pat(&mut self, p: &hir::Pat) {
run_lints!(self, check_pat, p);
visit::walk_pat(self, p);
run_lints!(self, check_pat, late_passes, p);
hir_visit::walk_pat(self, p);
}
fn visit_expr(&mut self, e: &hir::Expr) {
run_lints!(self, check_expr, e);
visit::walk_expr(self, e);
run_lints!(self, check_expr, late_passes, e);
hir_visit::walk_expr(self, e);
}
fn visit_stmt(&mut self, s: &hir::Stmt) {
run_lints!(self, check_stmt, s);
visit::walk_stmt(self, s);
run_lints!(self, check_stmt, late_passes, s);
hir_visit::walk_stmt(self, s);
}
fn visit_fn(&mut self, fk: FnKind<'v>, decl: &'v hir::FnDecl,
fn visit_fn(&mut self, fk: hir_visit::FnKind<'v>, decl: &'v hir::FnDecl,
body: &'v hir::Block, span: Span, id: ast::NodeId) {
run_lints!(self, check_fn, fk, decl, body, span, id);
visit::walk_fn(self, fk, decl, body, span);
run_lints!(self, check_fn, late_passes, fk, decl, body, span, id);
hir_visit::walk_fn(self, fk, decl, body, span);
}
fn visit_struct_def(&mut self,
@ -541,116 +666,276 @@ impl<'a, 'tcx, 'v> Visitor<'v> for Context<'a, 'tcx> {
ident: ast::Ident,
g: &hir::Generics,
id: ast::NodeId) {
run_lints!(self, check_struct_def, s, ident, g, id);
visit::walk_struct_def(self, s);
run_lints!(self, check_struct_def_post, s, ident, g, id);
run_lints!(self, check_struct_def, late_passes, s, ident, g, id);
hir_visit::walk_struct_def(self, s);
run_lints!(self, check_struct_def_post, late_passes, s, ident, g, id);
}
fn visit_struct_field(&mut self, s: &hir::StructField) {
self.with_lint_attrs(&s.node.attrs, |cx| {
run_lints!(cx, check_struct_field, s);
visit::walk_struct_field(cx, s);
run_lints!(cx, check_struct_field, late_passes, s);
hir_visit::walk_struct_field(cx, s);
})
}
fn visit_variant(&mut self, v: &hir::Variant, g: &hir::Generics) {
self.with_lint_attrs(&v.node.attrs, |cx| {
run_lints!(cx, check_variant, v, g);
visit::walk_variant(cx, v, g);
run_lints!(cx, check_variant_post, v, g);
run_lints!(cx, check_variant, late_passes, v, g);
hir_visit::walk_variant(cx, v, g);
run_lints!(cx, check_variant_post, late_passes, v, g);
})
}
fn visit_ty(&mut self, t: &hir::Ty) {
run_lints!(self, check_ty, t);
visit::walk_ty(self, t);
run_lints!(self, check_ty, late_passes, t);
hir_visit::walk_ty(self, t);
}
fn visit_ident(&mut self, sp: Span, id: ast::Ident) {
run_lints!(self, check_ident, sp, id);
run_lints!(self, check_ident, late_passes, sp, id);
}
fn visit_mod(&mut self, m: &hir::Mod, s: Span, n: ast::NodeId) {
run_lints!(self, check_mod, m, s, n);
visit::walk_mod(self, m);
run_lints!(self, check_mod, late_passes, m, s, n);
hir_visit::walk_mod(self, m);
}
fn visit_local(&mut self, l: &hir::Local) {
run_lints!(self, check_local, l);
visit::walk_local(self, l);
run_lints!(self, check_local, late_passes, l);
hir_visit::walk_local(self, l);
}
fn visit_block(&mut self, b: &hir::Block) {
run_lints!(self, check_block, b);
visit::walk_block(self, b);
run_lints!(self, check_block, late_passes, b);
hir_visit::walk_block(self, b);
}
fn visit_arm(&mut self, a: &hir::Arm) {
run_lints!(self, check_arm, a);
visit::walk_arm(self, a);
run_lints!(self, check_arm, late_passes, a);
hir_visit::walk_arm(self, a);
}
fn visit_decl(&mut self, d: &hir::Decl) {
run_lints!(self, check_decl, d);
visit::walk_decl(self, d);
run_lints!(self, check_decl, late_passes, d);
hir_visit::walk_decl(self, d);
}
fn visit_expr_post(&mut self, e: &hir::Expr) {
run_lints!(self, check_expr_post, e);
run_lints!(self, check_expr_post, late_passes, e);
}
fn visit_generics(&mut self, g: &hir::Generics) {
run_lints!(self, check_generics, g);
visit::walk_generics(self, g);
run_lints!(self, check_generics, late_passes, g);
hir_visit::walk_generics(self, g);
}
fn visit_trait_item(&mut self, trait_item: &hir::TraitItem) {
self.with_lint_attrs(&trait_item.attrs, |cx| {
run_lints!(cx, check_trait_item, trait_item);
run_lints!(cx, check_trait_item, late_passes, trait_item);
cx.visit_ids(|v| v.visit_trait_item(trait_item));
visit::walk_trait_item(cx, trait_item);
hir_visit::walk_trait_item(cx, trait_item);
});
}
fn visit_impl_item(&mut self, impl_item: &hir::ImplItem) {
self.with_lint_attrs(&impl_item.attrs, |cx| {
run_lints!(cx, check_impl_item, impl_item);
run_lints!(cx, check_impl_item, late_passes, impl_item);
cx.visit_ids(|v| v.visit_impl_item(impl_item));
visit::walk_impl_item(cx, impl_item);
hir_visit::walk_impl_item(cx, impl_item);
});
}
fn visit_opt_lifetime_ref(&mut self, sp: Span, lt: &Option<hir::Lifetime>) {
run_lints!(self, check_opt_lifetime_ref, sp, lt);
run_lints!(self, check_opt_lifetime_ref, late_passes, sp, lt);
}
fn visit_lifetime_ref(&mut self, lt: &hir::Lifetime) {
run_lints!(self, check_lifetime_ref, lt);
run_lints!(self, check_lifetime_ref, late_passes, lt);
}
fn visit_lifetime_def(&mut self, lt: &hir::LifetimeDef) {
run_lints!(self, check_lifetime_def, lt);
run_lints!(self, check_lifetime_def, late_passes, lt);
}
fn visit_explicit_self(&mut self, es: &hir::ExplicitSelf) {
run_lints!(self, check_explicit_self, es);
visit::walk_explicit_self(self, es);
run_lints!(self, check_explicit_self, late_passes, es);
hir_visit::walk_explicit_self(self, es);
}
fn visit_path(&mut self, p: &hir::Path, id: ast::NodeId) {
run_lints!(self, check_path, p, id);
visit::walk_path(self, p);
run_lints!(self, check_path, late_passes, p, id);
hir_visit::walk_path(self, p);
}
fn visit_attribute(&mut self, attr: &ast::Attribute) {
run_lints!(self, check_attribute, attr);
run_lints!(self, check_attribute, late_passes, attr);
}
}
impl<'a, 'v> ast_visit::Visitor<'v> for EarlyContext<'a> {
fn visit_item(&mut self, it: &ast::Item) {
self.with_lint_attrs(&it.attrs, |cx| {
run_lints!(cx, check_item, early_passes, it);
cx.visit_ids(|v| v.visit_item(it));
ast_visit::walk_item(cx, it);
})
}
fn visit_foreign_item(&mut self, it: &ast::ForeignItem) {
self.with_lint_attrs(&it.attrs, |cx| {
run_lints!(cx, check_foreign_item, early_passes, it);
ast_visit::walk_foreign_item(cx, it);
})
}
fn visit_pat(&mut self, p: &ast::Pat) {
run_lints!(self, check_pat, early_passes, p);
ast_visit::walk_pat(self, p);
}
fn visit_expr(&mut self, e: &ast::Expr) {
run_lints!(self, check_expr, early_passes, e);
ast_visit::walk_expr(self, e);
}
fn visit_stmt(&mut self, s: &ast::Stmt) {
run_lints!(self, check_stmt, early_passes, s);
ast_visit::walk_stmt(self, s);
}
fn visit_fn(&mut self, fk: ast_visit::FnKind<'v>, decl: &'v ast::FnDecl,
body: &'v ast::Block, span: Span, id: ast::NodeId) {
run_lints!(self, check_fn, early_passes, fk, decl, body, span, id);
ast_visit::walk_fn(self, fk, decl, body, span);
}
fn visit_struct_def(&mut self,
s: &ast::StructDef,
ident: ast::Ident,
g: &ast::Generics,
id: ast::NodeId) {
run_lints!(self, check_struct_def, early_passes, s, ident, g, id);
ast_visit::walk_struct_def(self, s);
run_lints!(self, check_struct_def_post, early_passes, s, ident, g, id);
}
fn visit_struct_field(&mut self, s: &ast::StructField) {
self.with_lint_attrs(&s.node.attrs, |cx| {
run_lints!(cx, check_struct_field, early_passes, s);
ast_visit::walk_struct_field(cx, s);
})
}
fn visit_variant(&mut self, v: &ast::Variant, g: &ast::Generics) {
self.with_lint_attrs(&v.node.attrs, |cx| {
run_lints!(cx, check_variant, early_passes, v, g);
ast_visit::walk_variant(cx, v, g);
run_lints!(cx, check_variant_post, early_passes, v, g);
})
}
fn visit_ty(&mut self, t: &ast::Ty) {
run_lints!(self, check_ty, early_passes, t);
ast_visit::walk_ty(self, t);
}
fn visit_ident(&mut self, sp: Span, id: ast::Ident) {
run_lints!(self, check_ident, early_passes, sp, id);
}
fn visit_mod(&mut self, m: &ast::Mod, s: Span, n: ast::NodeId) {
run_lints!(self, check_mod, early_passes, m, s, n);
ast_visit::walk_mod(self, m);
}
fn visit_local(&mut self, l: &ast::Local) {
run_lints!(self, check_local, early_passes, l);
ast_visit::walk_local(self, l);
}
fn visit_block(&mut self, b: &ast::Block) {
run_lints!(self, check_block, early_passes, b);
ast_visit::walk_block(self, b);
}
fn visit_arm(&mut self, a: &ast::Arm) {
run_lints!(self, check_arm, early_passes, a);
ast_visit::walk_arm(self, a);
}
fn visit_decl(&mut self, d: &ast::Decl) {
run_lints!(self, check_decl, early_passes, d);
ast_visit::walk_decl(self, d);
}
fn visit_expr_post(&mut self, e: &ast::Expr) {
run_lints!(self, check_expr_post, early_passes, e);
}
fn visit_generics(&mut self, g: &ast::Generics) {
run_lints!(self, check_generics, early_passes, g);
ast_visit::walk_generics(self, g);
}
fn visit_trait_item(&mut self, trait_item: &ast::TraitItem) {
self.with_lint_attrs(&trait_item.attrs, |cx| {
run_lints!(cx, check_trait_item, early_passes, trait_item);
cx.visit_ids(|v| v.visit_trait_item(trait_item));
ast_visit::walk_trait_item(cx, trait_item);
});
}
fn visit_impl_item(&mut self, impl_item: &ast::ImplItem) {
self.with_lint_attrs(&impl_item.attrs, |cx| {
run_lints!(cx, check_impl_item, early_passes, impl_item);
cx.visit_ids(|v| v.visit_impl_item(impl_item));
ast_visit::walk_impl_item(cx, impl_item);
});
}
fn visit_opt_lifetime_ref(&mut self, sp: Span, lt: &Option<ast::Lifetime>) {
run_lints!(self, check_opt_lifetime_ref, early_passes, sp, lt);
}
fn visit_lifetime_ref(&mut self, lt: &ast::Lifetime) {
run_lints!(self, check_lifetime_ref, early_passes, lt);
}
fn visit_lifetime_def(&mut self, lt: &ast::LifetimeDef) {
run_lints!(self, check_lifetime_def, early_passes, lt);
}
fn visit_explicit_self(&mut self, es: &ast::ExplicitSelf) {
run_lints!(self, check_explicit_self, early_passes, es);
ast_visit::walk_explicit_self(self, es);
}
fn visit_path(&mut self, p: &ast::Path, id: ast::NodeId) {
run_lints!(self, check_path, early_passes, p, id);
ast_visit::walk_path(self, p);
}
fn visit_attribute(&mut self, attr: &ast::Attribute) {
run_lints!(self, check_attribute, early_passes, attr);
}
}
// Output any lints that were previously added to the session.
impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> {
impl<'a, 'tcx> IdVisitingOperation for LateContext<'a, 'tcx> {
fn visit_id(&mut self, id: ast::NodeId) {
match self.tcx.sess.lints.borrow_mut().remove(&id) {
match self.sess().lints.borrow_mut().remove(&id) {
None => {}
Some(lints) => {
for (lint_id, span, msg) in lints {
self.span_lint(lint_id.lint, span, &msg[..])
}
}
}
}
}
impl<'a> IdVisitingOperation for EarlyContext<'a> {
fn visit_id(&mut self, id: ast::NodeId) {
match self.sess.lints.borrow_mut().remove(&id) {
None => {}
Some(lints) => {
for (lint_id, span, msg) in lints {
@ -661,7 +946,7 @@ impl<'a, 'tcx> IdVisitingOperation for Context<'a, 'tcx> {
}
}
// This lint pass is defined here because it touches parts of the `Context`
// This lint pass is defined here because it touches parts of the `LateContext`
// that we don't want to expose. It records the lint level at certain AST
// nodes, so that the variant size difference check in trans can call
// `raw_emit_lint`.
@ -672,8 +957,10 @@ impl LintPass for GatherNodeLevels {
fn get_lints(&self) -> LintArray {
lint_array!()
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for GatherNodeLevels {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
hir::ItemEnum(..) => {
let lint_id = LintId::of(builtin::VARIANT_SIZE_DIFFERENCES);
@ -698,21 +985,21 @@ pub fn check_crate(tcx: &ty::ctxt,
krate: &hir::Crate,
exported_items: &ExportedItems) {
let mut cx = Context::new(tcx, krate, exported_items);
let mut cx = LateContext::new(tcx, krate, exported_items);
// Visit the whole crate.
cx.with_lint_attrs(&krate.attrs, |cx| {
cx.visit_id(ast::CRATE_NODE_ID);
cx.visit_ids(|v| {
v.visited_outermost = true;
visit::walk_crate(v, krate);
hir_visit::walk_crate(v, krate);
});
// since the root module isn't visited as an item (because it isn't an
// item), warn for it here.
run_lints!(cx, check_crate, krate);
run_lints!(cx, check_crate, late_passes, krate);
visit::walk_crate(cx, krate);
hir_visit::walk_crate(cx, krate);
});
// If we missed any lints added to the session, then there's a bug somewhere
@ -727,3 +1014,35 @@ pub fn check_crate(tcx: &ty::ctxt,
*tcx.node_lint_levels.borrow_mut() = cx.node_levels.into_inner();
}
pub fn check_ast_crate(sess: &Session, krate: &ast::Crate) {
let mut cx = EarlyContext::new(sess, krate);
// Visit the whole crate.
cx.with_lint_attrs(&krate.attrs, |cx| {
cx.visit_id(ast::CRATE_NODE_ID);
cx.visit_ids(|v| {
v.visited_outermost = true;
ast_visit::walk_crate(v, krate);
});
// since the root module isn't visited as an item (because it isn't an
// item), warn for it here.
run_lints!(cx, check_crate, early_passes, krate);
ast_visit::walk_crate(cx, krate);
});
// Put the lint store back in the session.
mem::replace(&mut *sess.lint_store.borrow_mut(), cx.lints);
// If we missed any lints added to the session, then there's a bug somewhere
// in the iteration code.
for (_, v) in sess.lints.borrow().iter() {
for &(lint, span, ref msg) in v {
sess.span_bug(span,
&format!("unprocessed lint {}: {}",
lint.as_str(), *msg))
}
}
}

138
src/librustc/lint/mod.rs
View file

@ -35,10 +35,12 @@ use std::hash;
use std::ascii::AsciiExt;
use syntax::codemap::Span;
use rustc_front::visit::FnKind;
use syntax::visit as ast_visit;
use syntax::ast;
use rustc_front::hir;
pub use lint::context::{Context, LintStore, raw_emit_lint, check_crate, gather_attrs,
pub use lint::context::{LateContext, EarlyContext, LintContext, LintStore,
raw_emit_lint, check_crate, check_ast_crate, gather_attrs,
GatherNodeLevels};
/// Specification of a single lint.
@ -109,14 +111,6 @@ macro_rules! lint_array { ($( $lint:expr ),*) => (
pub type LintArray = &'static [&'static &'static Lint];
/// Trait for types providing lint checks.
///
/// Each `check` method checks a single syntax node, and should not
/// invoke methods recursively (unlike `Visitor`). By default they
/// do nothing.
//
// FIXME: eliminate the duplication with `Visitor`. But this also
// contains a few lint-specific methods with no equivalent in `Visitor`.
pub trait LintPass {
/// Get descriptions of the lints this `LintPass` object can emit.
///
@ -125,51 +119,111 @@ pub trait LintPass {
/// parts of the compiler. If you want enforced access restrictions for your
/// `Lint`, make it a private `static` item in its own module.
fn get_lints(&self) -> LintArray;
}
fn check_crate(&mut self, _: &Context, _: &hir::Crate) { }
fn check_ident(&mut self, _: &Context, _: Span, _: ast::Ident) { }
fn check_mod(&mut self, _: &Context, _: &hir::Mod, _: Span, _: ast::NodeId) { }
fn check_foreign_item(&mut self, _: &Context, _: &hir::ForeignItem) { }
fn check_item(&mut self, _: &Context, _: &hir::Item) { }
fn check_local(&mut self, _: &Context, _: &hir::Local) { }
fn check_block(&mut self, _: &Context, _: &hir::Block) { }
fn check_stmt(&mut self, _: &Context, _: &hir::Stmt) { }
fn check_arm(&mut self, _: &Context, _: &hir::Arm) { }
fn check_pat(&mut self, _: &Context, _: &hir::Pat) { }
fn check_decl(&mut self, _: &Context, _: &hir::Decl) { }
fn check_expr(&mut self, _: &Context, _: &hir::Expr) { }
fn check_expr_post(&mut self, _: &Context, _: &hir::Expr) { }
fn check_ty(&mut self, _: &Context, _: &hir::Ty) { }
fn check_generics(&mut self, _: &Context, _: &hir::Generics) { }
fn check_fn(&mut self, _: &Context,
/// Trait for types providing lint checks.
///
/// Each `check` method checks a single syntax node, and should not
/// invoke methods recursively (unlike `Visitor`). By default they
/// do nothing.
//
// FIXME: eliminate the duplication with `Visitor`. But this also
// contains a few lint-specific methods with no equivalent in `Visitor`.
pub trait LateLintPass: LintPass {
fn check_ident(&mut self, _: &LateContext, _: Span, _: ast::Ident) { }
fn check_crate(&mut self, _: &LateContext, _: &hir::Crate) { }
fn check_mod(&mut self, _: &LateContext, _: &hir::Mod, _: Span, _: ast::NodeId) { }
fn check_foreign_item(&mut self, _: &LateContext, _: &hir::ForeignItem) { }
fn check_item(&mut self, _: &LateContext, _: &hir::Item) { }
fn check_local(&mut self, _: &LateContext, _: &hir::Local) { }
fn check_block(&mut self, _: &LateContext, _: &hir::Block) { }
fn check_stmt(&mut self, _: &LateContext, _: &hir::Stmt) { }
fn check_arm(&mut self, _: &LateContext, _: &hir::Arm) { }
fn check_pat(&mut self, _: &LateContext, _: &hir::Pat) { }
fn check_decl(&mut self, _: &LateContext, _: &hir::Decl) { }
fn check_expr(&mut self, _: &LateContext, _: &hir::Expr) { }
fn check_expr_post(&mut self, _: &LateContext, _: &hir::Expr) { }
fn check_ty(&mut self, _: &LateContext, _: &hir::Ty) { }
fn check_generics(&mut self, _: &LateContext, _: &hir::Generics) { }
fn check_fn(&mut self, _: &LateContext,
_: FnKind, _: &hir::FnDecl, _: &hir::Block, _: Span, _: ast::NodeId) { }
fn check_trait_item(&mut self, _: &Context, _: &hir::TraitItem) { }
fn check_impl_item(&mut self, _: &Context, _: &hir::ImplItem) { }
fn check_struct_def(&mut self, _: &Context,
fn check_trait_item(&mut self, _: &LateContext, _: &hir::TraitItem) { }
fn check_impl_item(&mut self, _: &LateContext, _: &hir::ImplItem) { }
fn check_struct_def(&mut self, _: &LateContext,
_: &hir::StructDef, _: ast::Ident, _: &hir::Generics, _: ast::NodeId) { }
fn check_struct_def_post(&mut self, _: &Context,
fn check_struct_def_post(&mut self, _: &LateContext,
_: &hir::StructDef, _: ast::Ident, _: &hir::Generics, _: ast::NodeId) { }
fn check_struct_field(&mut self, _: &Context, _: &hir::StructField) { }
fn check_variant(&mut self, _: &Context, _: &hir::Variant, _: &hir::Generics) { }
fn check_variant_post(&mut self, _: &Context, _: &hir::Variant, _: &hir::Generics) { }
fn check_opt_lifetime_ref(&mut self, _: &Context, _: Span, _: &Option<hir::Lifetime>) { }
fn check_lifetime_ref(&mut self, _: &Context, _: &hir::Lifetime) { }
fn check_lifetime_def(&mut self, _: &Context, _: &hir::LifetimeDef) { }
fn check_explicit_self(&mut self, _: &Context, _: &hir::ExplicitSelf) { }
fn check_mac(&mut self, _: &Context, _: &ast::Mac) { }
fn check_path(&mut self, _: &Context, _: &hir::Path, _: ast::NodeId) { }
fn check_attribute(&mut self, _: &Context, _: &ast::Attribute) { }
fn check_struct_field(&mut self, _: &LateContext, _: &hir::StructField) { }
fn check_variant(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) { }
fn check_variant_post(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) { }
fn check_opt_lifetime_ref(&mut self, _: &LateContext, _: Span, _: &Option<hir::Lifetime>) { }
fn check_lifetime_ref(&mut self, _: &LateContext, _: &hir::Lifetime) { }
fn check_lifetime_def(&mut self, _: &LateContext, _: &hir::LifetimeDef) { }
fn check_explicit_self(&mut self, _: &LateContext, _: &hir::ExplicitSelf) { }
// Note that you shouldn't implement both check_mac and check_ast_mac,
// because then your lint will be called twice. Prefer check_ast_mac.
fn check_mac(&mut self, _: &LateContext, _: &ast::Mac) { }
fn check_path(&mut self, _: &LateContext, _: &hir::Path, _: ast::NodeId) { }
fn check_attribute(&mut self, _: &LateContext, _: &ast::Attribute) { }
/// Called when entering a syntax node that can have lint attributes such
/// as `#[allow(...)]`. Called with *all* the attributes of that node.
fn enter_lint_attrs(&mut self, _: &Context, _: &[ast::Attribute]) { }
fn enter_lint_attrs(&mut self, _: &LateContext, _: &[ast::Attribute]) { }
/// Counterpart to `enter_lint_attrs`.
fn exit_lint_attrs(&mut self, _: &Context, _: &[ast::Attribute]) { }
fn exit_lint_attrs(&mut self, _: &LateContext, _: &[ast::Attribute]) { }
}
pub trait EarlyLintPass: LintPass {
fn check_ident(&mut self, _: &EarlyContext, _: Span, _: ast::Ident) { }
fn check_crate(&mut self, _: &EarlyContext, _: &ast::Crate) { }
fn check_mod(&mut self, _: &EarlyContext, _: &ast::Mod, _: Span, _: ast::NodeId) { }
fn check_foreign_item(&mut self, _: &EarlyContext, _: &ast::ForeignItem) { }
fn check_item(&mut self, _: &EarlyContext, _: &ast::Item) { }
fn check_local(&mut self, _: &EarlyContext, _: &ast::Local) { }
fn check_block(&mut self, _: &EarlyContext, _: &ast::Block) { }
fn check_stmt(&mut self, _: &EarlyContext, _: &ast::Stmt) { }
fn check_arm(&mut self, _: &EarlyContext, _: &ast::Arm) { }
fn check_pat(&mut self, _: &EarlyContext, _: &ast::Pat) { }
fn check_decl(&mut self, _: &EarlyContext, _: &ast::Decl) { }
fn check_expr(&mut self, _: &EarlyContext, _: &ast::Expr) { }
fn check_expr_post(&mut self, _: &EarlyContext, _: &ast::Expr) { }
fn check_ty(&mut self, _: &EarlyContext, _: &ast::Ty) { }
fn check_generics(&mut self, _: &EarlyContext, _: &ast::Generics) { }
fn check_fn(&mut self, _: &EarlyContext,
_: ast_visit::FnKind, _: &ast::FnDecl, _: &ast::Block, _: Span, _: ast::NodeId) { }
fn check_trait_item(&mut self, _: &EarlyContext, _: &ast::TraitItem) { }
fn check_impl_item(&mut self, _: &EarlyContext, _: &ast::ImplItem) { }
fn check_struct_def(&mut self, _: &EarlyContext,
_: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { }
fn check_struct_def_post(&mut self, _: &EarlyContext,
_: &ast::StructDef, _: ast::Ident, _: &ast::Generics, _: ast::NodeId) { }
fn check_struct_field(&mut self, _: &EarlyContext, _: &ast::StructField) { }
fn check_variant(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { }
fn check_variant_post(&mut self, _: &EarlyContext, _: &ast::Variant, _: &ast::Generics) { }
fn check_opt_lifetime_ref(&mut self,
_: &EarlyContext,
_: Span,
_: &Option<ast::Lifetime>) { }
fn check_lifetime_ref(&mut self, _: &EarlyContext, _: &ast::Lifetime) { }
fn check_lifetime_def(&mut self, _: &EarlyContext, _: &ast::LifetimeDef) { }
fn check_explicit_self(&mut self, _: &EarlyContext, _: &ast::ExplicitSelf) { }
fn check_mac(&mut self, _: &EarlyContext, _: &ast::Mac) { }
fn check_path(&mut self, _: &EarlyContext, _: &ast::Path, _: ast::NodeId) { }
fn check_attribute(&mut self, _: &EarlyContext, _: &ast::Attribute) { }
/// Called when entering a syntax node that can have lint attributes such
/// as `#[allow(...)]`. Called with *all* the attributes of that node.
fn enter_lint_attrs(&mut self, _: &EarlyContext, _: &[ast::Attribute]) { }
/// Counterpart to `enter_lint_attrs`.
fn exit_lint_attrs(&mut self, _: &EarlyContext, _: &[ast::Attribute]) { }
}
/// A lint pass boxed up as a trait object.
pub type LintPassObject = Box<LintPass + 'static>;
pub type EarlyLintPassObject = Box<EarlyLintPass + 'static>;
pub type LateLintPassObject = Box<LateLintPass + 'static>;
/// Identifies a lint known to the compiler.
#[derive(Clone, Copy)]

1
src/librustc/middle/cfg/construct.rs
View file

@ -354,7 +354,6 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
hir::ExprAddrOf(_, ref e) |
hir::ExprCast(ref e, _) |
hir::ExprUnary(_, ref e) |
hir::ExprParen(ref e) |
hir::ExprField(ref e, _) |
hir::ExprTupField(ref e, _) => {
self.straightline(expr, pred, Some(&**e).into_iter())

2
src/librustc/middle/check_const.rs
View file

@ -678,7 +678,6 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
let mut callee = &**callee;
loop {
callee = match callee.node {
hir::ExprParen(ref inner) => &**inner,
hir::ExprBlock(ref block) => match block.expr {
Some(ref tail) => &**tail,
None => break
@ -763,7 +762,6 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>,
hir::ExprField(..) |
hir::ExprTupField(..) |
hir::ExprVec(_) |
hir::ExprParen(..) |
hir::ExprTup(..) => {}
// Conditional control flow (possible to implement).

1
src/librustc/middle/const_eval.rs
View file

@ -996,7 +996,6 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>,
hir::ExprLit(ref lit) => {
lit_to_const(&**lit, ety)
}
hir::ExprParen(ref e) => try!(eval_const_expr_partial(tcx, &**e, ty_hint)),
hir::ExprBlock(ref block) => {
match block.expr {
Some(ref expr) => try!(eval_const_expr_partial(tcx, &**expr, ty_hint)),

7
src/librustc/middle/expr_use_visitor.rs
View file

@ -362,9 +362,6 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
let cmt = return_if_err!(self.mc.cat_expr(expr));
self.delegate.borrow(expr.id, expr.span, cmt, r, bk, cause);
// Note: Unlike consume, we can ignore ExprParen. cat_expr
// already skips over them, and walk will uncover any
// attachments or whatever.
self.walk_expr(expr)
}
@ -378,10 +375,6 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> {
self.walk_adjustment(expr);
match expr.node {
hir::ExprParen(ref subexpr) => {
self.walk_expr(&**subexpr)
}
hir::ExprPath(..) => { }
hir::ExprUnary(hir::UnDeref, ref base) => { // *base

7
src/librustc/middle/liveness.rs
View file

@ -495,7 +495,7 @@ fn visit_expr(ir: &mut IrMaps, expr: &Expr) {
hir::ExprAgain(_) | hir::ExprLit(_) | hir::ExprRet(..) |
hir::ExprBlock(..) | hir::ExprAssign(..) | hir::ExprAssignOp(..) |
hir::ExprStruct(..) | hir::ExprRepeat(..) |
hir::ExprParen(..) | hir::ExprInlineAsm(..) | hir::ExprBox(..) |
hir::ExprInlineAsm(..) | hir::ExprBox(..) |
hir::ExprRange(..) => {
visit::walk_expr(ir, expr);
}
@ -1161,8 +1161,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
hir::ExprBox(None, ref e) |
hir::ExprAddrOf(_, ref e) |
hir::ExprCast(ref e, _) |
hir::ExprUnary(_, ref e) |
hir::ExprParen(ref e) => {
hir::ExprUnary(_, ref e) => {
self.propagate_through_expr(&**e, succ)
}
@ -1435,7 +1434,7 @@ fn check_expr(this: &mut Liveness, expr: &Expr) {
hir::ExprCast(..) | hir::ExprUnary(..) | hir::ExprRet(..) |
hir::ExprBreak(..) | hir::ExprAgain(..) | hir::ExprLit(_) |
hir::ExprBlock(..) | hir::ExprAddrOf(..) |
hir::ExprStruct(..) | hir::ExprRepeat(..) | hir::ExprParen(..) |
hir::ExprStruct(..) | hir::ExprRepeat(..) |
hir::ExprClosure(..) | hir::ExprPath(..) | hir::ExprBox(..) |
hir::ExprRange(..) => {
visit::walk_expr(this, expr);

4
src/librustc/middle/mem_categorization.rs
View file

@ -519,10 +519,6 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> {
self.cat_def(expr.id, expr.span, expr_ty, def)
}
hir::ExprParen(ref e) => {
self.cat_expr(&**e)
}
hir::ExprAddrOf(..) | hir::ExprCall(..) |
hir::ExprAssign(..) | hir::ExprAssignOp(..) |
hir::ExprClosure(..) | hir::ExprRet(..) |

6
src/librustc/middle/region.rs
View file

@ -997,8 +997,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &hir::Local) {
hir::ExprUnary(hir::UnUniq, ref subexpr) => {
record_rvalue_scope_if_borrow_expr(visitor, &**subexpr, blk_id);
}
hir::ExprCast(ref subexpr, _) |
hir::ExprParen(ref subexpr) => {
hir::ExprCast(ref subexpr, _) => {
record_rvalue_scope_if_borrow_expr(visitor, &**subexpr, blk_id)
}
hir::ExprBlock(ref block) => {
@ -1047,8 +1046,7 @@ fn resolve_local(visitor: &mut RegionResolutionVisitor, local: &hir::Local) {
hir::ExprUnary(hir::UnDeref, ref subexpr) |
hir::ExprField(ref subexpr, _) |
hir::ExprTupField(ref subexpr, _) |
hir::ExprIndex(ref subexpr, _) |
hir::ExprParen(ref subexpr) => {
hir::ExprIndex(ref subexpr, _) => {
expr = &**subexpr;
}
_ => {

2
src/librustc/middle/ty/mod.rs
View file

@ -2089,8 +2089,6 @@ impl<'tcx> ctxt<'tcx> {
hir::ExprCast(..) => {
false
}
hir::ExprParen(ref e) => self.expr_is_lval(e),
}
}

19
src/librustc/plugin/registry.rs
View file

@ -10,7 +10,7 @@
//! Used by plugin crates to tell `rustc` about the plugins they provide.
use lint::{LintPassObject, LintId, Lint};
use lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint};
use session::Session;
use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT};
@ -48,7 +48,10 @@ pub struct Registry<'a> {
pub syntax_exts: Vec<NamedSyntaxExtension>,
#[doc(hidden)]
pub lint_passes: Vec<LintPassObject>,
pub early_lint_passes: Vec<EarlyLintPassObject>,
#[doc(hidden)]
pub late_lint_passes: Vec<LateLintPassObject>,
#[doc(hidden)]
pub lint_groups: HashMap<&'static str, Vec<LintId>>,
@ -68,7 +71,8 @@ impl<'a> Registry<'a> {
args_hidden: None,
krate_span: krate.span,
syntax_exts: vec!(),
lint_passes: vec!(),
early_lint_passes: vec!(),
late_lint_passes: vec!(),
lint_groups: HashMap::new(),
llvm_passes: vec!(),
attributes: vec!(),
@ -89,7 +93,6 @@ impl<'a> Registry<'a> {
/// Register a syntax extension of any kind.
///
/// This is the most general hook into `libsyntax`'s expansion behavior.
#[allow(deprecated)]
pub fn register_syntax_extension(&mut self, name: ast::Name, extension: SyntaxExtension) {
self.syntax_exts.push((name, match extension {
NormalTT(ext, _, allow_internal_unstable) => {
@ -118,10 +121,14 @@ impl<'a> Registry<'a> {
}
/// Register a compiler lint pass.
pub fn register_lint_pass(&mut self, lint_pass: LintPassObject) {
self.lint_passes.push(lint_pass);
pub fn register_early_lint_pass(&mut self, lint_pass: EarlyLintPassObject) {
self.early_lint_passes.push(lint_pass);
}
/// Register a compiler lint pass.
pub fn register_late_lint_pass(&mut self, lint_pass: LateLintPassObject) {
self.late_lint_passes.push(lint_pass);
}
/// Register a lint group.
pub fn register_lint_group(&mut self, name: &'static str, to: Vec<&'static Lint>) {
self.lint_groups.insert(name, to.into_iter().map(|x| LintId::of(x)).collect());

2
src/librustc_back/svh.rs
View file

@ -249,7 +249,6 @@ mod svh_visitor {
SawExprInlineAsm(&'a hir::InlineAsm),
SawExprStruct,
SawExprRepeat,
SawExprParen,
}
fn saw_expr<'a>(node: &'a Expr_) -> SawExprComponent<'a> {
@ -283,7 +282,6 @@ mod svh_visitor {
ExprInlineAsm(ref asm) => SawExprInlineAsm(asm),
ExprStruct(..) => SawExprStruct,
ExprRepeat(..) => SawExprRepeat,
ExprParen(..) => SawExprParen,
}
}

16
src/librustc_driver/driver.rs
View file

@ -129,10 +129,12 @@ pub fn compile_input(sess: Session,
&ast_map.krate(),
&id[..]));
time(sess.time_passes(), "early lint checks", || {
lint::check_ast_crate(&sess, &expanded_crate)
});
phase_3_run_analysis_passes(sess,
ast_map,
&expanded_crate,
&arenas,
id,
control.make_glob_map,
@ -480,13 +482,16 @@ pub fn phase_2_configure_and_expand(sess: &Session,
}
});
let Registry { syntax_exts, lint_passes, lint_groups,
let Registry { syntax_exts, early_lint_passes, late_lint_passes, lint_groups,
llvm_passes, attributes, .. } = registry;
{
let mut ls = sess.lint_store.borrow_mut();
for pass in lint_passes {
ls.register_pass(Some(sess), true, pass);
for pass in early_lint_passes {
ls.register_early_pass(Some(sess), true, pass);
}
for pass in late_lint_passes {
ls.register_late_pass(Some(sess), true, pass);
}
for (name, to) in lint_groups {
@ -641,7 +646,6 @@ pub fn make_map<'ast>(sess: &Session,
/// structures carrying the results of the analysis.
pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session,
ast_map: front::map::Map<'tcx>,
ast_crate: &ast::Crate,
arenas: &'tcx ty::CtxtArenas<'tcx>,
name: String,
make_glob_map: resolve::MakeGlobMap,
@ -765,7 +769,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: Session,
&tcx.sess, lib_features_used));
time(time_passes, "lint checking", ||
lint::check_crate(tcx, &lower_crate(ast_crate), &exported_items));
lint::check_crate(tcx, krate, &exported_items));
// The above three passes generate errors w/o aborting
tcx.sess.abort_if_errors();

6
src/librustc_driver/pretty.rs
View file

@ -157,7 +157,6 @@ impl PpSourceMode {
fn call_with_pp_support_hir<'tcx, A, B, F>(&self,
sess: Session,
ast_map: &hir_map::Map<'tcx>,
ast_crate: &ast::Crate,
arenas: &'tcx ty::CtxtArenas<'tcx>,
id: String,
payload: B,
@ -180,7 +179,6 @@ impl PpSourceMode {
PpmTyped => {
driver::phase_3_run_analysis_passes(sess,
ast_map.clone(),
ast_crate,
arenas,
id,
resolve::MakeGlobMap::No,
@ -715,7 +713,7 @@ pub fn pretty_print_input(sess: Session,
(PpmHir(s), None) => {
let out: &mut Write = &mut out;
s.call_with_pp_support_hir(
sess, &ast_map.unwrap(), &krate, &arenas, id, box out, |annotation, out, krate| {
sess, &ast_map.unwrap(), &arenas, id, box out, |annotation, out, krate| {
debug!("pretty printing source code {:?}", s);
let sess = annotation.sess();
pprust_hir::print_crate(sess.codemap(),
@ -733,7 +731,6 @@ pub fn pretty_print_input(sess: Session,
let out: &mut Write = &mut out;
s.call_with_pp_support_hir(sess,
&ast_map.unwrap(),
&krate,
&arenas,
id,
(out,uii),
@ -782,7 +779,6 @@ pub fn pretty_print_input(sess: Session,
let variants = gather_flowgraph_variants(&sess);
driver::phase_3_run_analysis_passes(sess,
ast_map,
&krate,
&arenas,
id,
resolve::MakeGlobMap::No,

1
src/librustc_front/fold.rs
View file

@ -1164,7 +1164,6 @@ pub fn noop_fold_expr<T: Folder>(Expr {id, node, span}: Expr, folder: &mut T) ->
fields.move_map(|x| folder.fold_field(x)),
maybe_expr.map(|x| folder.fold_expr(x)))
},
ExprParen(ex) => ExprParen(folder.fold_expr(ex))
},
span: folder.new_span(span)
}

3
src/librustc_front/hir.rs
View file

@ -703,9 +703,6 @@ pub enum Expr_ {
/// For example, `[1u8; 5]`. The first expression is the element
/// to be repeated; the second is the number of times to repeat it.
ExprRepeat(P<Expr>, P<Expr>),
/// No-op: used solely so we can pretty-print faithfully
ExprParen(P<Expr>)
}
/// The explicit Self type in a "qualified path". The actual

4
src/librustc_front/lowering.rs
View file

@ -810,7 +810,9 @@ pub fn lower_expr(e: &Expr) -> P<hir::Expr> {
fields.iter().map(|x| lower_field(x)).collect(),
maybe_expr.as_ref().map(|x| lower_expr(x)))
},
ExprParen(ref ex) => hir::ExprParen(lower_expr(ex)),
ExprParen(ref ex) => {
return lower_expr(ex);
}
ExprIfLet(..) |
ExprWhileLet(..) |
ExprForLoop(..) |

5
src/librustc_front/print/pprust.rs
View file

@ -1556,11 +1556,6 @@ impl<'a> State<'a> {
try!(self.pclose());
}
hir::ExprParen(ref e) => {
try!(self.popen());
try!(self.print_expr(&**e));
try!(self.pclose());
}
}
try!(self.ann.post(self, NodeExpr(expr)));
self.end()

3
src/librustc_front/visit.rs
View file

@ -814,9 +814,6 @@ pub fn walk_expr<'v, V: Visitor<'v>>(visitor: &mut V, expression: &'v Expr) {
ExprRet(ref optional_expression) => {
walk_expr_opt(visitor, optional_expression)
}
ExprParen(ref subexpression) => {
visitor.visit_expr(&**subexpression)
}
ExprInlineAsm(ref ia) => {
for input in &ia.inputs {
let (_, ref input) = *input;

278
src/librustc_lint/builtin.rs
View file

@ -38,7 +38,8 @@ use middle::const_eval::{eval_const_expr_partial, ConstVal};
use middle::const_eval::EvalHint::ExprTypeChecked;
use rustc::front::map as hir_map;
use util::nodemap::{FnvHashMap, FnvHashSet, NodeSet};
use lint::{Level, Context, LintPass, LintArray, Lint};
use lint::{Level, LateContext, EarlyContext, LintContext, LintArray, Lint};
use lint::{LintPass, EarlyLintPass, LateLintPass};
use std::collections::HashSet;
use std::collections::hash_map::Entry::{Occupied, Vacant};
@ -72,8 +73,10 @@ impl LintPass for WhileTrue {
fn get_lints(&self) -> LintArray {
lint_array!(WHILE_TRUE)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for WhileTrue {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
if let hir::ExprWhile(ref cond, _, _) = e.node {
if let hir::ExprLit(ref lit) = cond.node {
if let ast::LitBool(true) = lit.node {
@ -121,8 +124,10 @@ impl LintPass for TypeLimits {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_COMPARISONS, OVERFLOWING_LITERALS, EXCEEDING_BITSHIFTS)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for TypeLimits {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
match e.node {
hir::ExprUnary(hir::UnNeg, ref expr) => {
match expr.node {
@ -154,9 +159,6 @@ impl LintPass for TypeLimits {
self.negated_expr_id = expr.id;
}
},
hir::ExprParen(ref expr) if self.negated_expr_id == e.id => {
self.negated_expr_id = expr.id;
},
hir::ExprBinary(binop, ref l, ref r) => {
if is_comparison(binop) && !check_limits(cx.tcx, binop, &**l, &**r) {
cx.span_lint(UNUSED_COMPARISONS, e.span,
@ -377,7 +379,7 @@ impl LintPass for TypeLimits {
}
}
fn check_unsigned_negation_feature(cx: &Context, span: Span) {
fn check_unsigned_negation_feature(cx: &LateContext, span: Span) {
if !cx.sess().features.borrow().negate_unsigned {
// FIXME(#27141): change this to syntax::feature_gate::emit_feature_err…
cx.sess().span_warn(span,
@ -398,7 +400,7 @@ declare_lint! {
}
struct ImproperCTypesVisitor<'a, 'tcx: 'a> {
cx: &'a Context<'a, 'tcx>
cx: &'a LateContext<'a, 'tcx>
}
enum FfiResult {
@ -702,14 +704,16 @@ impl LintPass for ImproperCTypes {
fn get_lints(&self) -> LintArray {
lint_array!(IMPROPER_CTYPES)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
fn check_ty(cx: &Context, ty: &hir::Ty) {
impl LateLintPass for ImproperCTypes {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
fn check_ty(cx: &LateContext, ty: &hir::Ty) {
let mut vis = ImproperCTypesVisitor { cx: cx };
vis.visit_ty(ty);
}
fn check_foreign_fn(cx: &Context, decl: &hir::FnDecl) {
fn check_foreign_fn(cx: &LateContext, decl: &hir::FnDecl) {
for input in &decl.inputs {
check_ty(cx, &*input.ty);
}
@ -747,7 +751,7 @@ declare_lint! {
pub struct BoxPointers;
impl BoxPointers {
fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>,
fn check_heap_type<'a, 'tcx>(&self, cx: &LateContext<'a, 'tcx>,
span: Span, ty: Ty<'tcx>) {
for leaf_ty in ty.walk() {
if let ty::TyBox(_) = leaf_ty.sty {
@ -762,8 +766,10 @@ impl LintPass for BoxPointers {
fn get_lints(&self) -> LintArray {
lint_array!(BOX_POINTERS)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for BoxPointers {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
hir::ItemFn(..) |
hir::ItemTy(..) |
@ -786,7 +792,7 @@ impl LintPass for BoxPointers {
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
let ty = cx.tcx.node_id_to_type(e.id);
self.check_heap_type(cx, e.span, ty);
}
@ -799,7 +805,7 @@ declare_lint! {
}
struct RawPtrDeriveVisitor<'a, 'tcx: 'a> {
cx: &'a Context<'a, 'tcx>
cx: &'a LateContext<'a, 'tcx>
}
impl<'a, 'tcx, 'v> Visitor<'v> for RawPtrDeriveVisitor<'a, 'tcx> {
@ -831,8 +837,10 @@ impl LintPass for RawPointerDerive {
fn get_lints(&self) -> LintArray {
lint_array!(RAW_POINTER_DERIVE)
}
}
fn check_item(&mut self, cx: &Context, item: &hir::Item) {
impl LateLintPass for RawPointerDerive {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
if !attr::contains_name(&item.attrs, "automatically_derived") {
return;
}
@ -887,8 +895,10 @@ impl LintPass for UnusedAttributes {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_ATTRIBUTES)
}
}
fn check_attribute(&mut self, cx: &Context, attr: &ast::Attribute) {
impl LateLintPass for UnusedAttributes {
fn check_attribute(&mut self, cx: &LateContext, attr: &ast::Attribute) {
// Note that check_name() marks the attribute as used if it matches.
for &(ref name, ty, _) in KNOWN_ATTRIBUTES {
match ty {
@ -947,8 +957,10 @@ impl LintPass for PathStatements {
fn get_lints(&self) -> LintArray {
lint_array!(PATH_STATEMENTS)
}
}
fn check_stmt(&mut self, cx: &Context, s: &hir::Stmt) {
impl LateLintPass for PathStatements {
fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) {
match s.node {
hir::StmtSemi(ref expr, _) => {
match expr.node {
@ -981,8 +993,10 @@ impl LintPass for UnusedResults {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_MUST_USE, UNUSED_RESULTS)
}
}
fn check_stmt(&mut self, cx: &Context, s: &hir::Stmt) {
impl LateLintPass for UnusedResults {
fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) {
let expr = match s.node {
hir::StmtSemi(ref expr, _) => &**expr,
_ => return
@ -1015,7 +1029,7 @@ impl LintPass for UnusedResults {
cx.span_lint(UNUSED_RESULTS, s.span, "unused result");
}
fn check_must_use(cx: &Context, attrs: &[ast::Attribute], sp: Span) -> bool {
fn check_must_use(cx: &LateContext, attrs: &[ast::Attribute], sp: Span) -> bool {
for attr in attrs {
if attr.check_name("must_use") {
let mut msg = "unused result which must be used".to_string();
@ -1046,7 +1060,7 @@ declare_lint! {
pub struct NonCamelCaseTypes;
impl NonCamelCaseTypes {
fn check_case(&self, cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
fn check_case(&self, cx: &LateContext, sort: &str, ident: ast::Ident, span: Span) {
fn is_camel_case(ident: ast::Ident) -> bool {
let ident = ident.name.as_str();
if ident.is_empty() {
@ -1087,8 +1101,10 @@ impl LintPass for NonCamelCaseTypes {
fn get_lints(&self) -> LintArray {
lint_array!(NON_CAMEL_CASE_TYPES)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for NonCamelCaseTypes {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
let extern_repr_count = it.attrs.iter().filter(|attr| {
attr::find_repr_attrs(cx.tcx.sess.diagnostic(), attr).iter()
.any(|r| r == &attr::ReprExtern)
@ -1119,7 +1135,7 @@ impl LintPass for NonCamelCaseTypes {
}
}
fn check_generics(&mut self, cx: &Context, it: &hir::Generics) {
fn check_generics(&mut self, cx: &LateContext, it: &hir::Generics) {
for gen in it.ty_params.iter() {
self.check_case(cx, "type parameter", gen.ident, gen.span);
}
@ -1127,21 +1143,21 @@ impl LintPass for NonCamelCaseTypes {
}
#[derive(PartialEq)]
enum MethodContext {
enum MethodLateContext {
TraitDefaultImpl,
TraitImpl,
PlainImpl
}
fn method_context(cx: &Context, id: ast::NodeId, span: Span) -> MethodContext {
fn method_context(cx: &LateContext, id: ast::NodeId, span: Span) -> MethodLateContext {
match cx.tcx.impl_or_trait_items.borrow().get(&DefId::local(id)) {
None => cx.sess().span_bug(span, "missing method descriptor?!"),
Some(item) => match item.container() {
ty::TraitContainer(..) => MethodContext::TraitDefaultImpl,
ty::TraitContainer(..) => MethodLateContext::TraitDefaultImpl,
ty::ImplContainer(cid) => {
match cx.tcx.impl_trait_ref(cid) {
Some(_) => MethodContext::TraitImpl,
None => MethodContext::PlainImpl
Some(_) => MethodLateContext::TraitImpl,
None => MethodLateContext::PlainImpl
}
}
}
@ -1190,7 +1206,7 @@ impl NonSnakeCase {
words.join("_")
}
fn check_snake_case(&self, cx: &Context, sort: &str, name: &str, span: Option<Span>) {
fn check_snake_case(&self, cx: &LateContext, sort: &str, name: &str, span: Option<Span>) {
fn is_snake_case(ident: &str) -> bool {
if ident.is_empty() {
return true;
@ -1233,8 +1249,10 @@ impl LintPass for NonSnakeCase {
fn get_lints(&self) -> LintArray {
lint_array!(NON_SNAKE_CASE)
}
}
fn check_crate(&mut self, cx: &Context, cr: &hir::Crate) {
impl LateLintPass for NonSnakeCase {
fn check_crate(&mut self, cx: &LateContext, cr: &hir::Crate) {
let attr_crate_name = cr.attrs.iter().find(|at| at.check_name("crate_name"))
.and_then(|at| at.value_str().map(|s| (at, s)));
if let Some(ref name) = cx.tcx.sess.opts.crate_name {
@ -1244,15 +1262,15 @@ impl LintPass for NonSnakeCase {
}
}
fn check_fn(&mut self, cx: &Context,
fn check_fn(&mut self, cx: &LateContext,
fk: FnKind, _: &hir::FnDecl,
_: &hir::Block, span: Span, id: ast::NodeId) {
match fk {
FnKind::Method(ident, _, _) => match method_context(cx, id, span) {
MethodContext::PlainImpl => {
MethodLateContext::PlainImpl => {
self.check_snake_case(cx, "method", &ident.name.as_str(), Some(span))
},
MethodContext::TraitDefaultImpl => {
MethodLateContext::TraitDefaultImpl => {
self.check_snake_case(cx, "trait method", &ident.name.as_str(), Some(span))
},
_ => (),
@ -1264,25 +1282,25 @@ impl LintPass for NonSnakeCase {
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
if let hir::ItemMod(_) = it.node {
self.check_snake_case(cx, "module", &it.ident.name.as_str(), Some(it.span));
}
}
fn check_trait_item(&mut self, cx: &Context, trait_item: &hir::TraitItem) {
fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) {
if let hir::MethodTraitItem(_, None) = trait_item.node {
self.check_snake_case(cx, "trait method", &trait_item.ident.name.as_str(),
Some(trait_item.span));
}
}
fn check_lifetime_def(&mut self, cx: &Context, t: &hir::LifetimeDef) {
fn check_lifetime_def(&mut self, cx: &LateContext, t: &hir::LifetimeDef) {
self.check_snake_case(cx, "lifetime", &t.lifetime.name.as_str(),
Some(t.lifetime.span));
}
fn check_pat(&mut self, cx: &Context, p: &hir::Pat) {
fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
if let &hir::PatIdent(_, ref path1, _) = &p.node {
let def = cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def());
if let Some(def::DefLocal(_)) = def {
@ -1291,7 +1309,7 @@ impl LintPass for NonSnakeCase {
}
}
fn check_struct_def(&mut self, cx: &Context, s: &hir::StructDef,
fn check_struct_def(&mut self, cx: &LateContext, s: &hir::StructDef,
_: ast::Ident, _: &hir::Generics, _: ast::NodeId) {
for sf in &s.fields {
if let hir::StructField_ { kind: hir::NamedField(ident, _), .. } = sf.node {
@ -1312,7 +1330,7 @@ declare_lint! {
pub struct NonUpperCaseGlobals;
impl NonUpperCaseGlobals {
fn check_upper_case(cx: &Context, sort: &str, ident: ast::Ident, span: Span) {
fn check_upper_case(cx: &LateContext, sort: &str, ident: ast::Ident, span: Span) {
let s = ident.name.as_str();
if s.chars().any(|c| c.is_lowercase()) {
@ -1334,8 +1352,10 @@ impl LintPass for NonUpperCaseGlobals {
fn get_lints(&self) -> LintArray {
lint_array!(NON_UPPER_CASE_GLOBALS)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for NonUpperCaseGlobals {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
// only check static constants
hir::ItemStatic(_, hir::MutImmutable, _) => {
@ -1348,7 +1368,7 @@ impl LintPass for NonUpperCaseGlobals {
}
}
fn check_trait_item(&mut self, cx: &Context, ti: &hir::TraitItem) {
fn check_trait_item(&mut self, cx: &LateContext, ti: &hir::TraitItem) {
match ti.node {
hir::ConstTraitItem(..) => {
NonUpperCaseGlobals::check_upper_case(cx, "associated constant",
@ -1358,7 +1378,7 @@ impl LintPass for NonUpperCaseGlobals {
}
}
fn check_impl_item(&mut self, cx: &Context, ii: &hir::ImplItem) {
fn check_impl_item(&mut self, cx: &LateContext, ii: &hir::ImplItem) {
match ii.node {
hir::ConstImplItem(..) => {
NonUpperCaseGlobals::check_upper_case(cx, "associated constant",
@ -1368,7 +1388,7 @@ impl LintPass for NonUpperCaseGlobals {
}
}
fn check_pat(&mut self, cx: &Context, p: &hir::Pat) {
fn check_pat(&mut self, cx: &LateContext, p: &hir::Pat) {
// Lint for constants that look like binding identifiers (#7526)
match (&p.node, cx.tcx.def_map.borrow().get(&p.id).map(|d| d.full_def())) {
(&hir::PatIdent(_, ref path1, _), Some(def::DefConst(..))) => {
@ -1390,9 +1410,9 @@ declare_lint! {
pub struct UnusedParens;
impl UnusedParens {
fn check_unused_parens_core(&self, cx: &Context, value: &hir::Expr, msg: &str,
fn check_unused_parens_core(&self, cx: &EarlyContext, value: &ast::Expr, msg: &str,
struct_lit_needs_parens: bool) {
if let hir::ExprParen(ref inner) = value.node {
if let ast::ExprParen(ref inner) = value.node {
let necessary = struct_lit_needs_parens && contains_exterior_struct_lit(&**inner);
if !necessary {
cx.span_lint(UNUSED_PARENS, value.span,
@ -1405,27 +1425,27 @@ impl UnusedParens {
/// delimiters, e.g. `X { y: 1 }`, `X { y: 1 }.method()`, `foo
/// == X { y: 1 }` and `X { y: 1 } == foo` all do, but `(X {
/// y: 1 }) == foo` does not.
fn contains_exterior_struct_lit(value: &hir::Expr) -> bool {
fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
match value.node {
hir::ExprStruct(..) => true,
ast::ExprStruct(..) => true,
hir::ExprAssign(ref lhs, ref rhs) |
hir::ExprAssignOp(_, ref lhs, ref rhs) |
hir::ExprBinary(_, ref lhs, ref rhs) => {
ast::ExprAssign(ref lhs, ref rhs) |
ast::ExprAssignOp(_, ref lhs, ref rhs) |
ast::ExprBinary(_, ref lhs, ref rhs) => {
// X { y: 1 } + X { y: 2 }
contains_exterior_struct_lit(&**lhs) ||
contains_exterior_struct_lit(&**rhs)
}
hir::ExprUnary(_, ref x) |
hir::ExprCast(ref x, _) |
hir::ExprField(ref x, _) |
hir::ExprTupField(ref x, _) |
hir::ExprIndex(ref x, _) => {
ast::ExprUnary(_, ref x) |
ast::ExprCast(ref x, _) |
ast::ExprField(ref x, _) |
ast::ExprTupField(ref x, _) |
ast::ExprIndex(ref x, _) => {
// &X { y: 1 }, X { y: 1 }.y
contains_exterior_struct_lit(&**x)
}
hir::ExprMethodCall(_, _, ref exprs) => {
ast::ExprMethodCall(_, _, ref exprs) => {
// X { y: 1 }.bar(...)
contains_exterior_struct_lit(&*exprs[0])
}
@ -1440,29 +1460,31 @@ impl LintPass for UnusedParens {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_PARENS)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl EarlyLintPass for UnusedParens {
fn check_expr(&mut self, cx: &EarlyContext, e: &ast::Expr) {
let (value, msg, struct_lit_needs_parens) = match e.node {
hir::ExprIf(ref cond, _, _) => (cond, "`if` condition", true),
hir::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
hir::ExprMatch(ref head, _, source) => match source {
hir::MatchSource::Normal => (head, "`match` head expression", true),
hir::MatchSource::IfLetDesugar { .. } => (head, "`if let` head expression", true),
hir::MatchSource::WhileLetDesugar => (head, "`while let` head expression", true),
hir::MatchSource::ForLoopDesugar => (head, "`for` head expression", true),
ast::ExprIf(ref cond, _, _) => (cond, "`if` condition", true),
ast::ExprWhile(ref cond, _, _) => (cond, "`while` condition", true),
ast::ExprMatch(ref head, _, source) => match source {
ast::MatchSource::Normal => (head, "`match` head expression", true),
ast::MatchSource::IfLetDesugar { .. } => (head, "`if let` head expression", true),
ast::MatchSource::WhileLetDesugar => (head, "`while let` head expression", true),
ast::MatchSource::ForLoopDesugar => (head, "`for` head expression", true),
},
hir::ExprRet(Some(ref value)) => (value, "`return` value", false),
hir::ExprAssign(_, ref value) => (value, "assigned value", false),
hir::ExprAssignOp(_, _, ref value) => (value, "assigned value", false),
ast::ExprRet(Some(ref value)) => (value, "`return` value", false),
ast::ExprAssign(_, ref value) => (value, "assigned value", false),
ast::ExprAssignOp(_, _, ref value) => (value, "assigned value", false),
_ => return
};
self.check_unused_parens_core(cx, &**value, msg, struct_lit_needs_parens);
}
fn check_stmt(&mut self, cx: &Context, s: &hir::Stmt) {
fn check_stmt(&mut self, cx: &EarlyContext, s: &ast::Stmt) {
let (value, msg) = match s.node {
hir::StmtDecl(ref decl, _) => match decl.node {
hir::DeclLocal(ref local) => match local.init {
ast::StmtDecl(ref decl, _) => match decl.node {
ast::DeclLocal(ref local) => match local.init {
Some(ref value) => (value, "assigned value"),
None => return
},
@ -1487,8 +1509,10 @@ impl LintPass for UnusedImportBraces {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_IMPORT_BRACES)
}
}
fn check_item(&mut self, cx: &Context, item: &hir::Item) {
impl LateLintPass for UnusedImportBraces {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
if let hir::ItemUse(ref view_path) = item.node {
if let hir::ViewPathList(_, ref items) = view_path.node {
if items.len() == 1 {
@ -1517,8 +1541,10 @@ impl LintPass for NonShorthandFieldPatterns {
fn get_lints(&self) -> LintArray {
lint_array!(NON_SHORTHAND_FIELD_PATTERNS)
}
}
fn check_pat(&mut self, cx: &Context, pat: &hir::Pat) {
impl LateLintPass for NonShorthandFieldPatterns {
fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) {
let def_map = cx.tcx.def_map.borrow();
if let hir::PatStruct(_, ref v, _) = pat.node {
let field_pats = v.iter().filter(|fieldpat| {
@ -1556,8 +1582,10 @@ impl LintPass for UnusedUnsafe {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_UNSAFE)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for UnusedUnsafe {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
if let hir::ExprBlock(ref blk) = e.node {
// Don't warn about generated blocks, that'll just pollute the output.
if blk.rules == hir::UnsafeBlock(hir::UserProvided) &&
@ -1581,8 +1609,10 @@ impl LintPass for UnsafeCode {
fn get_lints(&self) -> LintArray {
lint_array!(UNSAFE_CODE)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for UnsafeCode {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
if let hir::ExprBlock(ref blk) = e.node {
// Don't warn about generated blocks, that'll just pollute the output.
if blk.rules == hir::UnsafeBlock(hir::UserProvided) {
@ -1591,7 +1621,7 @@ impl LintPass for UnsafeCode {
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
hir::ItemTrait(hir::Unsafety::Unsafe, _, _, _) =>
cx.span_lint(UNSAFE_CODE, it.span, "declaration of an `unsafe` trait"),
@ -1603,7 +1633,7 @@ impl LintPass for UnsafeCode {
}
}
fn check_fn(&mut self, cx: &Context, fk: FnKind, _: &hir::FnDecl,
fn check_fn(&mut self, cx: &LateContext, fk: FnKind, _: &hir::FnDecl,
_: &hir::Block, span: Span, _: ast::NodeId) {
match fk {
FnKind::ItemFn(_, _, hir::Unsafety::Unsafe, _, _, _) =>
@ -1619,7 +1649,7 @@ impl LintPass for UnsafeCode {
}
}
fn check_trait_item(&mut self, cx: &Context, trait_item: &hir::TraitItem) {
fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) {
if let hir::MethodTraitItem(ref sig, None) = trait_item.node {
if sig.unsafety == hir::Unsafety::Unsafe {
cx.span_lint(UNSAFE_CODE, trait_item.span,
@ -1639,7 +1669,7 @@ declare_lint! {
pub struct UnusedMut;
impl UnusedMut {
fn check_unused_mut_pat(&self, cx: &Context, pats: &[P<hir::Pat>]) {
fn check_unused_mut_pat(&self, cx: &LateContext, pats: &[P<hir::Pat>]) {
// collect all mutable pattern and group their NodeIDs by their Identifier to
// avoid false warnings in match arms with multiple patterns
@ -1672,8 +1702,10 @@ impl LintPass for UnusedMut {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_MUT)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for UnusedMut {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
if let hir::ExprMatch(_, ref arms, _) = e.node {
for a in arms {
self.check_unused_mut_pat(cx, &a.pats)
@ -1681,7 +1713,7 @@ impl LintPass for UnusedMut {
}
}
fn check_stmt(&mut self, cx: &Context, s: &hir::Stmt) {
fn check_stmt(&mut self, cx: &LateContext, s: &hir::Stmt) {
if let hir::StmtDecl(ref d, _) = s.node {
if let hir::DeclLocal(ref l) = d.node {
self.check_unused_mut_pat(cx, slice::ref_slice(&l.pat));
@ -1689,7 +1721,7 @@ impl LintPass for UnusedMut {
}
}
fn check_fn(&mut self, cx: &Context,
fn check_fn(&mut self, cx: &LateContext,
_: FnKind, decl: &hir::FnDecl,
_: &hir::Block, _: Span, _: ast::NodeId) {
for a in &decl.inputs {
@ -1711,8 +1743,10 @@ impl LintPass for UnusedAllocation {
fn get_lints(&self) -> LintArray {
lint_array!(UNUSED_ALLOCATION)
}
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
impl LateLintPass for UnusedAllocation {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
match e.node {
hir::ExprUnary(hir::UnUniq, _) => (),
_ => return
@ -1774,7 +1808,7 @@ impl MissingDoc {
}
fn check_missing_docs_attrs(&self,
cx: &Context,
cx: &LateContext,
id: Option<ast::NodeId>,
attrs: &[ast::Attribute],
sp: Span,
@ -1816,8 +1850,10 @@ impl LintPass for MissingDoc {
fn get_lints(&self) -> LintArray {
lint_array!(MISSING_DOCS)
}
}
fn enter_lint_attrs(&mut self, _: &Context, attrs: &[ast::Attribute]) {
impl LateLintPass for MissingDoc {
fn enter_lint_attrs(&mut self, _: &LateContext, attrs: &[ast::Attribute]) {
let doc_hidden = self.doc_hidden() || attrs.iter().any(|attr| {
attr.check_name("doc") && match attr.meta_item_list() {
None => false,
@ -1827,26 +1863,26 @@ impl LintPass for MissingDoc {
self.doc_hidden_stack.push(doc_hidden);
}
fn exit_lint_attrs(&mut self, _: &Context, _: &[ast::Attribute]) {
fn exit_lint_attrs(&mut self, _: &LateContext, _: &[ast::Attribute]) {
self.doc_hidden_stack.pop().expect("empty doc_hidden_stack");
}
fn check_struct_def(&mut self, _: &Context, _: &hir::StructDef,
fn check_struct_def(&mut self, _: &LateContext, _: &hir::StructDef,
_: ast::Ident, _: &hir::Generics, id: ast::NodeId) {
self.struct_def_stack.push(id);
}
fn check_struct_def_post(&mut self, _: &Context, _: &hir::StructDef,
fn check_struct_def_post(&mut self, _: &LateContext, _: &hir::StructDef,
_: ast::Ident, _: &hir::Generics, id: ast::NodeId) {
let popped = self.struct_def_stack.pop().expect("empty struct_def_stack");
assert!(popped == id);
}
fn check_crate(&mut self, cx: &Context, krate: &hir::Crate) {
fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) {
self.check_missing_docs_attrs(cx, None, &krate.attrs, krate.span, "crate");
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
let desc = match it.node {
hir::ItemFn(..) => "a function",
hir::ItemMod(..) => "a module",
@ -1886,7 +1922,7 @@ impl LintPass for MissingDoc {
self.check_missing_docs_attrs(cx, Some(it.id), &it.attrs, it.span, desc);
}
fn check_trait_item(&mut self, cx: &Context, trait_item: &hir::TraitItem) {
fn check_trait_item(&mut self, cx: &LateContext, trait_item: &hir::TraitItem) {
if self.private_traits.contains(&trait_item.id) { return }
let desc = match trait_item.node {
@ -1900,9 +1936,9 @@ impl LintPass for MissingDoc {
trait_item.span, desc);
}
fn check_impl_item(&mut self, cx: &Context, impl_item: &hir::ImplItem) {
fn check_impl_item(&mut self, cx: &LateContext, impl_item: &hir::ImplItem) {
// If the method is an impl for a trait, don't doc.
if method_context(cx, impl_item.id, impl_item.span) == MethodContext::TraitImpl {
if method_context(cx, impl_item.id, impl_item.span) == MethodLateContext::TraitImpl {
return;
}
@ -1916,7 +1952,7 @@ impl LintPass for MissingDoc {
impl_item.span, desc);
}
fn check_struct_field(&mut self, cx: &Context, sf: &hir::StructField) {
fn check_struct_field(&mut self, cx: &LateContext, sf: &hir::StructField) {
if let hir::NamedField(_, vis) = sf.node.kind {
if vis == hir::Public || self.in_variant {
let cur_struct_def = *self.struct_def_stack.last()
@ -1928,13 +1964,13 @@ impl LintPass for MissingDoc {
}
}
fn check_variant(&mut self, cx: &Context, v: &hir::Variant, _: &hir::Generics) {
fn check_variant(&mut self, cx: &LateContext, v: &hir::Variant, _: &hir::Generics) {
self.check_missing_docs_attrs(cx, Some(v.node.id), &v.node.attrs, v.span, "a variant");
assert!(!self.in_variant);
self.in_variant = true;
}
fn check_variant_post(&mut self, _: &Context, _: &hir::Variant, _: &hir::Generics) {
fn check_variant_post(&mut self, _: &LateContext, _: &hir::Variant, _: &hir::Generics) {
assert!(self.in_variant);
self.in_variant = false;
}
@ -1953,8 +1989,10 @@ impl LintPass for MissingCopyImplementations {
fn get_lints(&self) -> LintArray {
lint_array!(MISSING_COPY_IMPLEMENTATIONS)
}
}
fn check_item(&mut self, cx: &Context, item: &hir::Item) {
impl LateLintPass for MissingCopyImplementations {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
if !cx.exported_items.contains(&item.id) {
return;
}
@ -2015,8 +2053,10 @@ impl LintPass for MissingDebugImplementations {
fn get_lints(&self) -> LintArray {
lint_array!(MISSING_DEBUG_IMPLEMENTATIONS)
}
}
fn check_item(&mut self, cx: &Context, item: &hir::Item) {
impl LateLintPass for MissingDebugImplementations {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
if !cx.exported_items.contains(&item.id) {
return;
}
@ -2066,7 +2106,7 @@ declare_lint! {
pub struct Stability;
impl Stability {
fn lint(&self, cx: &Context, _id: DefId,
fn lint(&self, cx: &LateContext, _id: DefId,
span: Span, stability: &Option<&attr::Stability>) {
// Deprecated attributes apply in-crate and cross-crate.
let (lint, label) = match *stability {
@ -2077,7 +2117,7 @@ impl Stability {
output(cx, span, stability, lint, label);
fn output(cx: &Context, span: Span, stability: &Option<&attr::Stability>,
fn output(cx: &LateContext, span: Span, stability: &Option<&attr::Stability>,
lint: &'static Lint, label: &'static str) {
let msg = match *stability {
Some(&attr::Stability { reason: Some(ref s), .. }) => {
@ -2109,29 +2149,31 @@ impl LintPass for Stability {
fn get_lints(&self) -> LintArray {
lint_array!(DEPRECATED)
}
}
fn check_item(&mut self, cx: &Context, item: &hir::Item) {
impl LateLintPass for Stability {
fn check_item(&mut self, cx: &LateContext, item: &hir::Item) {
stability::check_item(cx.tcx, item, false,
&mut |id, sp, stab|
self.lint(cx, id, sp,
&stab.map(|s| hir_to_ast_stability(s)).as_ref()));
}
fn check_expr(&mut self, cx: &Context, e: &hir::Expr) {
fn check_expr(&mut self, cx: &LateContext, e: &hir::Expr) {
stability::check_expr(cx.tcx, e,
&mut |id, sp, stab|
self.lint(cx, id, sp,
&stab.map(|s| hir_to_ast_stability(s)).as_ref()));
}
fn check_path(&mut self, cx: &Context, path: &hir::Path, id: ast::NodeId) {
fn check_path(&mut self, cx: &LateContext, path: &hir::Path, id: ast::NodeId) {
stability::check_path(cx.tcx, path, id,
&mut |id, sp, stab|
self.lint(cx, id, sp,
&stab.map(|s| hir_to_ast_stability(s)).as_ref()));
}
fn check_pat(&mut self, cx: &Context, pat: &hir::Pat) {
fn check_pat(&mut self, cx: &LateContext, pat: &hir::Pat) {
stability::check_pat(cx.tcx, pat,
&mut |id, sp, stab|
self.lint(cx, id, sp,
@ -2153,8 +2195,10 @@ impl LintPass for UnconditionalRecursion {
fn get_lints(&self) -> LintArray {
lint_array![UNCONDITIONAL_RECURSION]
}
}
fn check_fn(&mut self, cx: &Context, fn_kind: FnKind, _: &hir::FnDecl,
impl LateLintPass for UnconditionalRecursion {
fn check_fn(&mut self, cx: &LateContext, fn_kind: FnKind, _: &hir::FnDecl,
blk: &hir::Block, sp: Span, id: ast::NodeId) {
type F = for<'tcx> fn(&ty::ctxt<'tcx>,
ast::NodeId, ast::NodeId, ast::Ident, ast::NodeId) -> bool;
@ -2400,8 +2444,10 @@ impl LintPass for PluginAsLibrary {
fn get_lints(&self) -> LintArray {
lint_array![PLUGIN_AS_LIBRARY]
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for PluginAsLibrary {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
if cx.sess().plugin_registrar_fn.get().is_some() {
// We're compiling a plugin; it's fine to link other plugins.
return;
@ -2456,8 +2502,10 @@ impl LintPass for InvalidNoMangleItems {
PRIVATE_NO_MANGLE_STATICS,
NO_MANGLE_CONST_ITEMS)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for InvalidNoMangleItems {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match it.node {
hir::ItemFn(..) => {
if attr::contains_name(&it.attrs, "no_mangle") &&
@ -2502,8 +2550,10 @@ impl LintPass for MutableTransmutes {
fn get_lints(&self) -> LintArray {
lint_array!(MUTABLE_TRANSMUTES)
}
}
fn check_expr(&mut self, cx: &Context, expr: &hir::Expr) {
impl LateLintPass for MutableTransmutes {
fn check_expr(&mut self, cx: &LateContext, expr: &hir::Expr) {
use syntax::abi::RustIntrinsic;
let msg = "mutating transmuted &mut T from &T may cause undefined behavior,\
@ -2518,7 +2568,7 @@ impl LintPass for MutableTransmutes {
_ => ()
}
fn get_transmute_from_to<'a, 'tcx>(cx: &Context<'a, 'tcx>, expr: &hir::Expr)
fn get_transmute_from_to<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &hir::Expr)
-> Option<(&'tcx ty::TypeVariants<'tcx>, &'tcx ty::TypeVariants<'tcx>)> {
match expr.node {
hir::ExprPath(..) => (),
@ -2542,7 +2592,7 @@ impl LintPass for MutableTransmutes {
None
}
fn def_id_is_transmute(cx: &Context, def_id: DefId) -> bool {
fn def_id_is_transmute(cx: &LateContext, def_id: DefId) -> bool {
match cx.tcx.lookup_item_type(def_id).ty.sty {
ty::TyBareFn(_, ref bfty) if bfty.abi == RustIntrinsic => (),
_ => return false
@ -2569,7 +2619,10 @@ impl LintPass for UnstableFeatures {
fn get_lints(&self) -> LintArray {
lint_array!(UNSTABLE_FEATURES)
}
fn check_attribute(&mut self, ctx: &Context, attr: &ast::Attribute) {
}
impl LateLintPass for UnstableFeatures {
fn check_attribute(&mut self, ctx: &LateContext, attr: &ast::Attribute) {
if attr::contains_name(&[attr.node.value.clone()], "feature") {
if let Some(items) = attr.node.value.meta_item_list() {
for item in items {
@ -2595,7 +2648,10 @@ impl LintPass for DropWithReprExtern {
fn get_lints(&self) -> LintArray {
lint_array!(DROP_WITH_REPR_EXTERN)
}
fn check_crate(&mut self, ctx: &Context, _: &hir::Crate) {
}
impl LateLintPass for DropWithReprExtern {
fn check_crate(&mut self, ctx: &LateContext, _: &hir::Crate) {
for dtor_did in ctx.tcx.destructors.borrow().iter() {
let (drop_impl_did, dtor_self_type) =
if dtor_did.is_local() {

19
src/librustc_lint/lib.rs
View file

@ -67,7 +67,15 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
macro_rules! add_builtin {
($sess:ident, $($name:ident),*,) => (
{$(
store.register_pass($sess, false, box builtin::$name);
store.register_late_pass($sess, false, box builtin::$name);
)*}
)
}
macro_rules! add_early_builtin {
($sess:ident, $($name:ident),*,) => (
{$(
store.register_early_pass($sess, false, box builtin::$name);
)*}
)
}
@ -75,7 +83,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
macro_rules! add_builtin_with_new {
($sess:ident, $($name:ident),*,) => (
{$(
store.register_pass($sess, false, box builtin::$name::new());
store.register_late_pass($sess, false, box builtin::$name::new());
)*}
)
}
@ -86,6 +94,10 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
)
}
add_early_builtin!(sess,
UnusedParens,
);
add_builtin!(sess,
HardwiredLints,
WhileTrue,
@ -97,7 +109,6 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
NonCamelCaseTypes,
NonSnakeCase,
NonUpperCaseGlobals,
UnusedParens,
UnusedImportBraces,
NonShorthandFieldPatterns,
UnusedUnsafe,
@ -130,7 +141,7 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) {
UNUSED_UNSAFE, PATH_STATEMENTS);
// We have one lint pass defined specially
store.register_pass(sess, false, box lint::GatherNodeLevels);
store.register_late_pass(sess, false, box lint::GatherNodeLevels);
// Insert temporary renamings for a one-time deprecation
store.register_renamed("raw_pointer_deriving", "raw_pointer_derive");

3
src/librustc_mir/build/expr/as_constant.rs
View file

@ -33,9 +33,6 @@ impl<H:Hair> Builder<H> {
ExprKind::Scope { extent: _, value } => {
return this.as_constant(value);
}
ExprKind::Paren { arg } => {
return this.as_constant(arg);
}
ExprKind::Literal { literal } => {
ConstantKind::Literal(literal)
}

3
src/librustc_mir/build/expr/as_lvalue.rs
View file

@ -43,9 +43,6 @@ impl<H:Hair> Builder<H> {
this.as_lvalue(block, value)
})
}
ExprKind::Paren { arg } => {
this.as_lvalue(block, arg)
}
ExprKind::Field { lhs, name } => {
let lvalue = unpack!(block = this.as_lvalue(block, lhs));
let lvalue = lvalue.field(name);

14
src/librustc_mir/build/expr/as_operand.rs
View file

@ -39,16 +39,10 @@ impl<H:Hair> Builder<H> {
block, expr);
let this = self;
match expr.kind {
ExprKind::Scope { extent, value } => {
return this.in_scope(extent, block, |this| {
this.as_operand(block, value)
});
}
ExprKind::Paren { arg } => {
return this.as_operand(block, arg);
}
_ => { }
if let ExprKind::Scope { extent, value } = expr.kind {
return this.in_scope(extent, block, |this| {
this.as_operand(block, value)
});
}
let category = Category::of(&expr.kind).unwrap();

3
src/librustc_mir/build/expr/as_rvalue.rs
View file

@ -46,9 +46,6 @@ impl<H:Hair> Builder<H> {
this.as_rvalue(block, value)
})
}
ExprKind::Paren { arg } => {
this.as_rvalue(block, arg)
}
ExprKind::InlineAsm { asm } => {
block.and(Rvalue::InlineAsm(asm))
}

14
src/librustc_mir/build/expr/as_temp.rs
View file

@ -37,16 +37,10 @@ impl<H:Hair> Builder<H> {
block, expr);
let this = self;
match expr.kind {
ExprKind::Scope { extent, value } => {
return this.in_scope(extent, block, |this| {
this.as_temp(block, value)
});
}
ExprKind::Paren { arg } => {
return this.as_temp(block, arg);
}
_ => { }
if let ExprKind::Scope { extent, value } = expr.kind {
return this.in_scope(extent, block, |this| {
this.as_temp(block, value)
});
}
let expr_ty = expr.ty.clone();

4
src/librustc_mir/build/expr/category.rs
View file

@ -43,9 +43,7 @@ pub enum RvalueFunc {
impl Category {
pub fn of<H:Hair>(ek: &ExprKind<H>) -> Option<Category> {
match *ek {
ExprKind::Scope { .. } |
ExprKind::Paren { .. } =>
None,
ExprKind::Scope { .. } => None,
ExprKind::Field { .. } |
ExprKind::Deref { .. } |

3
src/librustc_mir/build/expr/into.rs
View file

@ -40,9 +40,6 @@ impl<H:Hair> Builder<H> {
this.into(destination, block, value)
})
}
ExprKind::Paren { arg } => {
this.into(destination, block, arg)
}
ExprKind::Block { body: ast_block } => {
this.ast_block(destination, block, ast_block)
}

1
src/librustc_mir/hair.rs
View file

@ -171,7 +171,6 @@ pub struct Expr<H:Hair> {
#[derive(Clone, Debug)]
pub enum ExprKind<H:Hair> {
Scope { extent: H::CodeExtent, value: ExprRef<H> },
Paren { arg: ExprRef<H> }, // ugh. should be able to remove this!
Box { place: Option<ExprRef<H>>, value: ExprRef<H> },
Call { fun: ExprRef<H>, args: Vec<ExprRef<H>> },
Deref { arg: ExprRef<H> }, // NOT overloaded!

2
src/librustc_mir/tcx/expr.rs
View file

@ -267,8 +267,6 @@ impl<'a,'tcx:'a> Mirror<Cx<'a,'tcx>> for &'tcx hir::Expr {
// Now comes the rote stuff:
hir::ExprParen(ref p) =>
ExprKind::Paren { arg: p.to_ref() },
hir::ExprRepeat(ref v, ref c) =>
ExprKind::Repeat { value: v.to_ref(), count: c.to_ref() },
hir::ExprRet(ref v) =>

3
src/librustc_trans/trans/consts.rs
View file

@ -703,7 +703,6 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
let mut cur = sub;
loop {
match cur.node {
hir::ExprParen(ref sub) => cur = sub,
hir::ExprBlock(ref blk) => {
if let Some(ref sub) = blk.expr {
cur = sub;
@ -830,7 +829,6 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
let mut callee = &**callee;
loop {
callee = match callee.node {
hir::ExprParen(ref inner) => &**inner,
hir::ExprBlock(ref block) => match block.expr {
Some(ref tail) => &**tail,
None => break,
@ -870,7 +868,6 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
const_fn_call(cx, MethodCallKey(method_call),
method_did, &arg_vals, param_substs)
},
hir::ExprParen(ref e) => const_expr(cx, &**e, param_substs, fn_args).0,
hir::ExprBlock(ref block) => {
match block.expr {
Some(ref expr) => const_expr(cx, &**expr, param_substs, fn_args).0,

3
src/librustc_trans/trans/debuginfo/create_scope_map.rs
View file

@ -322,8 +322,7 @@ fn walk_expr(cx: &CrateContext,
hir::ExprCast(ref sub_exp, _) |
hir::ExprAddrOf(_, ref sub_exp) |
hir::ExprField(ref sub_exp, _) |
hir::ExprTupField(ref sub_exp, _) |
hir::ExprParen(ref sub_exp) =>
hir::ExprTupField(ref sub_exp, _) =>
walk_expr(cx, &**sub_exp, scope_stack, scope_map),
hir::ExprBox(ref place, ref sub_expr) => {

11
src/librustc_trans/trans/expr.rs
View file

@ -630,9 +630,6 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
let _icx = push_ctxt("trans_datum_unadjusted");
match expr.node {
hir::ExprParen(ref e) => {
trans(bcx, &**e)
}
hir::ExprPath(..) => {
trans_def(bcx, expr, bcx.def(expr.id))
}
@ -934,9 +931,6 @@ fn trans_rvalue_stmt_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
match expr.node {
hir::ExprParen(ref e) => {
trans_into(bcx, &**e, Ignore)
}
hir::ExprBreak(label_opt) => {
controlflow::trans_break(bcx, expr, label_opt.map(|l| l.node))
}
@ -1050,9 +1044,6 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
debuginfo::set_source_location(bcx.fcx, expr.id, expr.span);
match expr.node {
hir::ExprParen(ref e) => {
trans_into(bcx, &**e, dest)
}
hir::ExprPath(..) => {
trans_def_dps_unadjusted(bcx, expr, bcx.def(expr.id), dest)
}
@ -2750,7 +2741,5 @@ fn expr_kind(tcx: &ty::ctxt, expr: &hir::Expr) -> ExprKind {
ExprKind::RvalueDps
}
}
hir::ExprParen(ref e) => expr_kind(tcx, &**e),
}
}

1
src/librustc_typeck/check/method/confirm.rs
View file

@ -468,7 +468,6 @@ impl<'a,'tcx> ConfirmContext<'a,'tcx> {
loop {
let last = exprs[exprs.len() - 1];
match last.node {
hir::ExprParen(ref expr) |
hir::ExprField(ref expr, _) |
hir::ExprTupField(ref expr, _) |
hir::ExprIndex(ref expr, _) |

7
src/librustc_typeck/check/mod.rs
View file

@ -3444,13 +3444,6 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>,
}
fcx.write_ty(id, fcx.infcx().next_diverging_ty_var());
}
hir::ExprParen(ref a) => {
check_expr_with_expectation_and_lvalue_pref(fcx,
&**a,
expected,
lvalue_pref);
fcx.write_ty(id, fcx.expr_ty(&**a));
}
hir::ExprAssign(ref lhs, ref rhs) => {
check_expr_with_lvalue_pref(fcx, &**lhs, PreferMutLvalue);

1
src/librustdoc/core.rs
View file

@ -141,7 +141,6 @@ pub fn run_core(search_paths: SearchPaths, cfgs: Vec<String>, externs: Externs,
driver::phase_3_run_analysis_passes(sess,
hir_map,
&krate,
&arenas,
name,
resolve::MakeGlobMap::No,

8
src/test/auxiliary/lint_for_crate.rs
View file

@ -17,7 +17,7 @@
extern crate rustc_front;
extern crate syntax;
use rustc::lint::{Context, LintPass, LintPassObject, LintArray};
use rustc::lint::{LateContext, LintContext, LintPass, LateLintPass, LateLintPassObject, LintArray};
use rustc::plugin::Registry;
use rustc_front::hir;
use syntax::attr;
@ -30,8 +30,10 @@ impl LintPass for Pass {
fn get_lints(&self) -> LintArray {
lint_array!(CRATE_NOT_OKAY)
}
}
fn check_crate(&mut self, cx: &Context, krate: &hir::Crate) {
impl LateLintPass for Pass {
fn check_crate(&mut self, cx: &LateContext, krate: &hir::Crate) {
if !attr::contains_name(&krate.attrs, "crate_okay") {
cx.span_lint(CRATE_NOT_OKAY, krate.span,
"crate is not marked with #![crate_okay]");
@ -41,5 +43,5 @@ impl LintPass for Pass {
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_lint_pass(box Pass as LintPassObject);
reg.register_late_lint_pass(box Pass as LateLintPassObject);
}

8
src/test/auxiliary/lint_group_plugin_test.rs
View file

@ -20,7 +20,7 @@ extern crate rustc_front;
extern crate rustc;
use rustc_front::hir;
use rustc::lint::{Context, LintPass, LintPassObject, LintArray};
use rustc::lint::{LateContext, LintContext, LintPass, LateLintPass, LateLintPassObject, LintArray};
use rustc::plugin::Registry;
declare_lint!(TEST_LINT, Warn, "Warn about items named 'lintme'");
@ -33,8 +33,10 @@ impl LintPass for Pass {
fn get_lints(&self) -> LintArray {
lint_array!(TEST_LINT, PLEASE_LINT)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl LateLintPass for Pass {
fn check_item(&mut self, cx: &LateContext, it: &hir::Item) {
match &*it.ident.name.as_str() {
"lintme" => cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'"),
"pleaselintme" => cx.span_lint(PLEASE_LINT, it.span, "item is named 'pleaselintme'"),
@ -45,6 +47,6 @@ impl LintPass for Pass {
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_lint_pass(box Pass as LintPassObject);
reg.register_late_lint_pass(box Pass as LateLintPassObject);
reg.register_lint_group("lint_me", vec![TEST_LINT, PLEASE_LINT]);
}

13
src/test/auxiliary/lint_plugin_test.rs
View file

@ -13,15 +13,16 @@
#![feature(plugin_registrar)]
#![feature(box_syntax, rustc_private)]
extern crate rustc_front;
extern crate syntax;
// Load rustc as a plugin to get macros
#[macro_use]
extern crate rustc;
use rustc::lint::{Context, LintPass, LintPassObject, LintArray};
use rustc::lint::{EarlyContext, LintContext, LintPass, EarlyLintPass,
EarlyLintPassObject, LintArray};
use rustc::plugin::Registry;
use rustc_front::hir;
use syntax::ast;
declare_lint!(TEST_LINT, Warn, "Warn about items named 'lintme'");
struct Pass;
@ -30,8 +31,10 @@ impl LintPass for Pass {
fn get_lints(&self) -> LintArray {
lint_array!(TEST_LINT)
}
}
fn check_item(&mut self, cx: &Context, it: &hir::Item) {
impl EarlyLintPass for Pass {
fn check_item(&mut self, cx: &EarlyContext, it: &ast::Item) {
if it.ident.name == "lintme" {
cx.span_lint(TEST_LINT, it.span, "item is named 'lintme'");
}
@ -40,5 +43,5 @@ impl LintPass for Pass {
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
reg.register_lint_pass(box Pass as LintPassObject);
reg.register_early_lint_pass(box Pass as EarlyLintPassObject);
}

1
src/test/compile-fail/autoderef-full-lval.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(unknown_features)]
#![feature(box_syntax)]
struct clam {

1
src/test/compile-fail/borrow-tuple-fields.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(unknown_features)]
#![feature(box_syntax)]
struct Foo(Box<isize>, isize);

2
src/test/compile-fail/cast-as-bool.rs
View file

@ -9,7 +9,7 @@
// except according to those terms.
fn main() {
let u = (5 as bool);
let u = 5 as bool;
//~^ ERROR cannot cast as `bool`
//~^^ HELP compare with zero instead
}

1
src/test/compile-fail/dropck_arr_cycle_checked.rs
View file

@ -19,7 +19,6 @@ use std::cell::Cell;
use id::Id;
mod s {
#![allow(unstable)]
use std::sync::atomic::{AtomicUsize, Ordering};
static S_COUNT: AtomicUsize = AtomicUsize::new(0);

2
src/test/compile-fail/dropck_tarena_cycle_checked.rs
View file

@ -16,7 +16,6 @@
// which is a reduction of this code to more directly show the reason
// for the error message we see here.)
#![allow(unstable)]
#![feature(const_fn)]
extern crate arena;
@ -26,7 +25,6 @@ use std::cell::Cell;
use id::Id;
mod s {
#![allow(unstable)]
use std::sync::atomic::{AtomicUsize, Ordering};
static S_COUNT: AtomicUsize = AtomicUsize::new(0);

2
src/test/compile-fail/dropck_tarena_unsound_drop.rs
View file

@ -19,8 +19,6 @@
// (Also compare against dropck_tarena_cycle_checked.rs, from which
// this was reduced to better understand its error message.)
#![allow(unstable)]
extern crate arena;
use arena::TypedArena;

1
src/test/compile-fail/dropck_vec_cycle_checked.rs
View file

@ -18,7 +18,6 @@ use std::cell::Cell;
use id::Id;
mod s {
#![allow(unstable)]
use std::sync::atomic::{AtomicUsize, Ordering};
static S_COUNT: AtomicUsize = AtomicUsize::new(0);

2
src/test/compile-fail/for-loop-hygiene.rs
View file

@ -11,8 +11,6 @@
// for-loops are expanded in the front end, and use an `iter` ident in their expansion. Check that
// `iter` is not accessible inside the for loop.
#![allow(unstable)]
fn main() {
for _ in 0..10 {
iter.next(); //~ error: unresolved name `iter`

2
src/test/compile-fail/issue-17283.rs
View file

@ -11,6 +11,8 @@
// Test that the parser does not attempt to parse struct literals
// within assignments in if expressions.
#![allow(unused_parens)]
struct Foo {
foo: usize
}

4
src/test/compile-fail/issue-23046.rs
View file

@ -24,7 +24,7 @@ pub fn let_<'var, VAR, F: for<'v: 'var> Fn(Expr<'v, VAR>) -> Expr<'v, VAR>>
}
fn main() {
let ex = (|x| {
let ex = |x| {
let_(add(x,x), |y| { //~ ERROR unable to infer enough type information about `_`
let_(add(x, x), |x|x)})});
let_(add(x, x), |x|x)})};
}

2
src/test/compile-fail/issue-23729.rs
View file

@ -26,7 +26,7 @@ fn main() {
self.pos += 1;
Some(next_val)
} else {
let next_val = (self.mem[0] + self.mem[1]);
let next_val = self.mem[0] + self.mem[1];
self.mem[0] = self.mem[1];
self.mem[1] = next_val;
Some(next_val)

1
src/test/compile-fail/lint-visible-private-types.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![deny(visible_private_types)]
#![allow(dead_code)]
#![crate_type="lib"]

2
src/test/compile-fail/loop-does-not-diverge.rs
View file

@ -18,5 +18,5 @@ fn forever() -> ! {
}
fn main() {
if (1 == 2) { forever(); }
if 1 == 2 { forever(); }
}

1
src/test/compile-fail/variance-trait-bounds.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![deny(bivariance)]
#![allow(dead_code)]
#![feature(rustc_attrs)]

1
src/test/compile-fail/variance-types.rs
View file

@ -8,7 +8,6 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![deny(bivariance)]
#![allow(dead_code)]
#![feature(rustc_attrs)]

1
src/test/compile-fail/vec-must-not-hide-type-from-dropck.rs
View file

@ -29,7 +29,6 @@ use std::cell::Cell;
use id::Id;
mod s {
#![allow(unstable)]
use std::sync::atomic::{AtomicUsize, Ordering};
static S_COUNT: AtomicUsize = AtomicUsize::new(0);

7
src/test/pretty/issue-4264.pp
View file

@ -27,10 +27,9 @@ pub fn bar() {
let _: [(); (1 as usize)] = ([(() as ())] as [(); 1]);
let _ =
(((&((([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3])) as [i32; 3])
as &[i32; 3]) as *const _ as *const [i32; 3]) as
*const [i32; (3 as usize)] as *const [i32; 3]);
(((&([(1 as i32), (2 as i32), (3 as i32)] as [i32; 3]) as &[i32; 3])
as *const _ as *const [i32; 3]) as *const [i32; (3 as usize)] as
*const [i32; 3]);

2
src/test/run-make/execution-engine/test.rs
View file

@ -228,7 +228,7 @@ fn compile_program(input: &str, sysroot: PathBuf)
let ast_map = driver::make_map(&sess, &mut hir_forest);
driver::phase_3_run_analysis_passes(
sess, ast_map, &krate, &arenas, id, MakeGlobMap::No, |tcx, analysis| {
sess, ast_map, &arenas, id, MakeGlobMap::No, |tcx, analysis| {
let trans = driver::phase_4_translate_to_llvm(tcx, analysis);