Rustup to 1.9.0-nightly (bf5da36 2016-04-06)

src/approx_const.rs

@@ -1,5 +1,5 @@
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use std::f64::consts as f64;
 use syntax::ast::{Lit, LitKind, FloatTy};
 use utils::span_lint;

src/array_indexing.rs

@@ -4,7 +4,7 @@ use rustc::ty::TyArray;
 use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
 use rustc_const_math::ConstInt;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::ast::RangeLimits;
 use utils;
 

src/attrs.rs

@@ -2,7 +2,7 @@
 
 use reexport::*;
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use semver::Version;
 use syntax::ast::{Attribute, Lit, LitKind, MetaItemKind};
 use syntax::attr::*;

src/bit_mask.rs

@@ -1,8 +1,7 @@
+use rustc::hir::*;
+use rustc::hir::def::{Def, PathResolution};
 use rustc::lint::*;
-use rustc::middle::def::{Def, PathResolution};
 use rustc_const_eval::lookup_const_by_id;
-use rustc_front::hir::*;
-use rustc_front::util::is_comparison_binop;
 use syntax::ast::LitKind;
 use syntax::codemap::Span;
 use utils::span_lint;
@@ -91,7 +90,7 @@ impl LintPass for BitMask {
 impl LateLintPass for BitMask {
     fn check_expr(&mut self, cx: &LateContext, e: &Expr) {
         if let ExprBinary(ref cmp, ref left, ref right) = e.node {
-            if is_comparison_binop(cmp.node) {
+            if cmp.node.is_comparison() {
                 fetch_int_literal(cx, right).map_or_else(|| {
                                                              fetch_int_literal(cx, left).map_or((), |cmp_val| {
                                                                  check_compare(cx,

src/blacklisted_name.rs

@@ -1,5 +1,5 @@
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use utils::span_lint;
 
 /// **What it does:** This lints about usage of blacklisted names.

src/block_in_if_condition.rs

@@ -1,6 +1,6 @@
 use rustc::lint::{LateLintPass, LateContext, LintArray, LintPass};
-use rustc_front::hir::*;
-use rustc_front::intravisit::{Visitor, walk_expr};
+use rustc::hir::*;
+use rustc::hir::intravisit::{Visitor, walk_expr};
 use utils::*;
 
 /// **What it does:** This lint checks for `if` conditions that use blocks to contain an expression.

src/booleans.rs

@@ -1,6 +1,6 @@
 use rustc::lint::{LintArray, LateLintPass, LateContext, LintPass};
-use rustc_front::hir::*;
-use rustc_front::intravisit::*;
+use rustc::hir::*;
+use rustc::hir::intravisit::*;
 use syntax::ast::{LitKind, DUMMY_NODE_ID};
 use syntax::codemap::{DUMMY_SP, dummy_spanned};
 use utils::{span_lint_and_then, in_macro, snippet_opt, SpanlessEq};

src/collapsible_if.rs

@@ -13,7 +13,7 @@
 //! This lint is **warn** by default
 
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use std::borrow::Cow;
 use syntax::codemap::Spanned;
 

src/consts.rs

@@ -1,10 +1,10 @@
 #![allow(cast_possible_truncation)]
 
 use rustc::lint::LateContext;
-use rustc::middle::def::{Def, PathResolution};
+use rustc::hir::def::{Def, PathResolution};
 use rustc_const_eval::lookup_const_by_id;
 use rustc_const_math::{ConstInt, ConstUsize, ConstIsize};
-use rustc_front::hir::*;
+use rustc::hir::*;
 use std::cmp::Ordering::{self, Equal};
 use std::cmp::PartialOrd;
 use std::hash::{Hash, Hasher};

src/copies.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
 use rustc::ty;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry;
 use syntax::parse::token::InternedString;

src/cyclomatic_complexity.rs

@@ -3,8 +3,8 @@
 use rustc::lint::*;
 use rustc::cfg::CFG;
 use rustc::ty;
-use rustc_front::hir::*;
-use rustc_front::intravisit::{Visitor, walk_expr};
+use rustc::hir::*;
+use rustc::hir::intravisit::{Visitor, walk_expr};
 use syntax::ast::Attribute;
 use syntax::attr::*;
 use syntax::codemap::Span;

src/derive.rs

@@ -3,7 +3,7 @@ use rustc::ty::subst::Subst;
 use rustc::ty::TypeVariants;
 use rustc::ty::fast_reject::simplify_type;
 use rustc::ty;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::ast::{Attribute, MetaItemKind};
 use syntax::codemap::Span;
 use utils::{CLONE_TRAIT_PATH, HASH_PATH};

src/drop_ref.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
 use rustc::ty;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::codemap::Span;
 use utils::DROP_PATH;
 use utils::{match_def_path, span_note_and_lint};

src/entry.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
-use rustc_front::hir::*;
-use rustc_front::intravisit::{Visitor, walk_expr, walk_block};
+use rustc::hir::*;
+use rustc::hir::intravisit::{Visitor, walk_expr, walk_block};
 use syntax::codemap::Span;
 use utils::SpanlessEq;
 use utils::{BTREEMAP_PATH, HASHMAP_PATH};

src/enum_clike.rs

@@ -3,7 +3,7 @@
 use rustc::lint::*;
 use rustc::middle::const_val::ConstVal;
 use rustc_const_math::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::attr::*;
 use utils::span_lint;
 

src/enum_glob_use.rs

@@ -1,10 +1,10 @@
 //! lint on `use`ing all variants of an enum
 
-use rustc::front::map::Node::NodeItem;
+use rustc::hir::*;
+use rustc::hir::def::Def;
+use rustc::hir::map::Node::NodeItem;
 use rustc::lint::{LateLintPass, LintPass, LateContext, LintArray, LintContext};
-use rustc::middle::def::Def;
 use rustc::middle::cstore::DefLike;
-use rustc_front::hir::*;
 use syntax::ast::NodeId;
 use syntax::codemap::Span;
 use utils::span_lint;

src/eq_op.rs

@@ -1,6 +1,5 @@
+use rustc::hir::*;
 use rustc::lint::*;
-use rustc_front::hir::*;
-use rustc_front::util as ast_util;
 use utils::{SpanlessEq, span_lint};
 
 /// **What it does:** This lint checks for equal operands to comparison, logical and bitwise,
@@ -34,7 +33,7 @@ impl LateLintPass for EqOp {
                 span_lint(cx,
                           EQ_OP,
                           e.span,
-                          &format!("equal expressions as operands to `{}`", ast_util::binop_to_string(op.node)));
+                          &format!("equal expressions as operands to `{}`", op.node.as_str()));
             }
         }
     }

src/escape.rs

@@ -1,14 +1,14 @@
-use rustc::front::map::Node::{NodeExpr, NodeStmt};
+use rustc::hir::*;
+use rustc::hir::intravisit as visit;
+use rustc::hir::map::Node::{NodeExpr, NodeStmt};
+use rustc::infer;
 use rustc::lint::*;
 use rustc::middle::expr_use_visitor::*;
-use rustc::infer;
 use rustc::middle::mem_categorization::{cmt, Categorization};
 use rustc::traits::ProjectionMode;
 use rustc::ty::adjustment::AutoAdjustment;
 use rustc::ty;
 use rustc::util::nodemap::NodeSet;
-use rustc_front::hir::*;
-use rustc_front::intravisit as visit;
 use syntax::ast::NodeId;
 use syntax::codemap::Span;
 use utils::span_lint;

src/eta_reduction.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
 use rustc::ty;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use utils::{snippet_opt, span_lint_and_then, is_adjusted};
 
 #[allow(missing_copy_implementations)]

src/format.rs

@@ -1,7 +1,7 @@
-use rustc::front::map::Node::NodeItem;
+use rustc::hir::map::Node::NodeItem;
 use rustc::lint::*;
 use rustc::ty::TypeVariants;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::ast::LitKind;
 use utils::{DISPLAY_FMT_METHOD_PATH, FMT_ARGUMENTS_NEWV1_PATH, STRING_PATH};
 use utils::{is_expn_of, match_path, match_type, span_lint, walk_ptrs_ty};

src/functions.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
-use rustc_front::hir;
-use rustc_front::intravisit;
+use rustc::hir;
+use rustc::hir::intravisit;
 use syntax::ast;
 use syntax::codemap::Span;
 use utils::span_lint;
@@ -45,7 +45,7 @@ impl LintPass for Functions {
 
 impl LateLintPass for Functions {
     fn check_fn(&mut self, cx: &LateContext, _: intravisit::FnKind, decl: &hir::FnDecl, _: &hir::Block, span: Span, nodeid: ast::NodeId) {
-        use rustc::front::map::Node::*;
+        use rustc::hir::map::Node::*;
 
         if let Some(NodeItem(ref item)) = cx.tcx.map.find(cx.tcx.map.get_parent_node(nodeid)) {
             match item.node {

src/identity_op.rs

@@ -1,6 +1,6 @@
 use consts::{constant_simple, Constant};
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::codemap::Span;
 use utils::{span_lint, snippet, in_macro};
 use rustc_const_math::ConstInt;

src/len_zero.rs

@@ -1,7 +1,7 @@
 use rustc::lint::*;
-use rustc::middle::def_id::DefId;
+use rustc::hir::def_id::DefId;
 use rustc::ty::{self, MethodTraitItemId, ImplOrTraitItemId};
-use rustc_front::hir::*;
+use rustc::hir::*;
 use syntax::ast::{Lit, LitKind, Name};
 use syntax::codemap::{Span, Spanned};
 use syntax::ptr::P;
@@ -111,6 +111,8 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItem]) {
     if !impl_items.iter().any(|i| is_named_self(i, "is_empty")) {
         for i in impl_items {
             if is_named_self(i, "len") {
+                let ty = cx.tcx.node_id_to_type(item.id);
+
                 let s = i.span;
                 span_lint(cx,
                           LEN_WITHOUT_IS_EMPTY,
@@ -121,7 +123,7 @@ fn check_impl_items(cx: &LateContext, item: &Item, impl_items: &[ImplItem]) {
                           },
                           &format!("item `{}` has a `.len(_: &Self)` method, but no `.is_empty(_: &Self)` method. \
                                     Consider adding one",
-                                   item.name));
+                                   ty));
                 return;
             }
         }

src/lib.rs

@@ -19,8 +19,6 @@ fn main() {
 extern crate syntax;
 #[macro_use]
 extern crate rustc;
-#[macro_use]
-extern crate rustc_front;
 
 extern crate toml;
 

src/lifetimes.rs

@@ -1,8 +1,8 @@
 use reexport::*;
 use rustc::lint::*;
-use rustc::middle::def::Def;
-use rustc_front::hir::*;
-use rustc_front::intravisit::{Visitor, walk_ty, walk_ty_param_bound, walk_fn_decl, walk_generics};
+use rustc::hir::def::Def;
+use rustc::hir::*;
+use rustc::hir::intravisit::{Visitor, walk_ty, walk_ty_param_bound, walk_fn_decl, walk_generics};
 use std::collections::{HashSet, HashMap};
 use syntax::codemap::Span;
 use utils::{in_external_macro, span_lint};

src/loops.rs

@@ -1,14 +1,14 @@
 use reexport::*;
-use rustc::front::map::Node::NodeBlock;
+use rustc::hir::*;
+use rustc::hir::def::Def;
+use rustc::hir::intravisit::{Visitor, walk_expr, walk_block, walk_decl};
+use rustc::hir::map::Node::NodeBlock;
 use rustc::lint::*;
 use rustc::middle::const_val::ConstVal;
-use rustc::middle::def::Def;
 use rustc::middle::region::CodeExtent;
 use rustc::ty;
 use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
-use rustc_front::hir::*;
-use rustc_front::intravisit::{Visitor, walk_expr, walk_block, walk_decl};
 use std::borrow::Cow;
 use std::collections::HashMap;
 use syntax::ast;

src/map_clone.rs

@@ -1,5 +1,5 @@
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use utils::{CLONE_PATH, OPTION_PATH};
 use utils::{is_adjusted, match_path, match_trait_method, match_type, snippet, span_help_and_lint, walk_ptrs_ty,
             walk_ptrs_ty_depth};

src/matches.rs

@@ -1,10 +1,10 @@
+use rustc::hir::*;
 use rustc::lint::*;
 use rustc::middle::const_val::ConstVal;
 use rustc::ty;
 use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
 use rustc_const_math::ConstInt;
-use rustc_front::hir::*;
 use std::cmp::Ordering;
 use syntax::ast::LitKind;
 use syntax::codemap::Span;

src/methods.rs

@@ -1,11 +1,11 @@
+use rustc::hir::*;
 use rustc::lint::*;
 use rustc::middle::const_val::ConstVal;
 use rustc::middle::cstore::CrateStore;
 use rustc::ty::subst::{Subst, TypeSpace};
 use rustc::ty;
 use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
-use rustc_front::hir::*;
 use std::borrow::Cow;
 use std::fmt;
 use syntax::codemap::Span;

src/minmax.rs

@@ -1,6 +1,6 @@
 use consts::{Constant, constant_simple};
 use rustc::lint::*;
-use rustc_front::hir::*;
+use rustc::hir::*;
 use std::cmp::{PartialOrd, Ordering};
 use syntax::ptr::P;
 use utils::{match_def_path, span_lint};

src/misc.rs

@@ -1,12 +1,11 @@
 use reexport::*;
+use rustc::hir::*;
+use rustc::hir::intravisit::FnKind;
 use rustc::lint::*;
 use rustc::middle::const_val::ConstVal;
 use rustc::ty;
 use rustc_const_eval::EvalHint::ExprTypeChecked;
 use rustc_const_eval::eval_const_expr_partial;
-use rustc_front::hir::*;
-use rustc_front::intravisit::FnKind;
-use rustc_front::util::{is_comparison_binop, binop_to_string};
 use syntax::codemap::{Span, Spanned, ExpnFormat};
 use syntax::ptr::P;
 use utils::{get_item_name, match_path, snippet, get_parent_expr, span_lint};
@@ -105,7 +104,7 @@ impl LintPass for CmpNan {
 impl LateLintPass for CmpNan {
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if let ExprBinary(ref cmp, ref left, ref right) = expr.node {
-            if is_comparison_binop(cmp.node) {
+            if cmp.node.is_comparison() {
                 if let ExprPath(_, ref path) = left.node {
                     check_nan(cx, path, expr.span);
                 }
@@ -170,7 +169,7 @@ impl LateLintPass for FloatCmp {
                           &format!("{}-comparison of f32 or f64 detected. Consider changing this to `({} - {}).abs() < \
                                     epsilon` for some suitable value of epsilon. \
                                     std::f32::EPSILON and std::f64::EPSILON are available.",
-                                   binop_to_string(op),
+                                   op.as_str(),
                                    snippet(cx, left.span, ".."),
                                    snippet(cx, right.span, "..")));
             }
@@ -217,7 +216,7 @@ impl LintPass for CmpOwned {
 impl LateLintPass for CmpOwned {
     fn check_expr(&mut self, cx: &LateContext, expr: &Expr) {
         if let ExprBinary(ref cmp, ref left, ref right) = expr.node {
-            if is_comparison_binop(cmp.node) {
+            if cmp.node.is_comparison() {
                 check_to_owned(cx, left, right, true, cmp.span);
                 check_to_owned(cx, right, left, false, cmp.span)
             }

src/mut_mut.rs

@@ -1,6 +1,6 @@
 use rustc::lint::*;
 use rustc::ty::{TypeAndMut, TyRef};
-use rustc_front::hir::*;
+use rustc::hir::*;
 use utils::{in_external_macro, span_lint};
 
 /// **What it does:** This lint checks for instances of `mut mut` references.