Auto merge of #3675 - mikerite:fix-build-20190120, r=matthiaskrgr

Fix build 20190120

clippy_lints/src/attrs.rs

@@ -376,8 +376,9 @@ fn is_relevant_trait(tcx: TyCtxt<'_, '_, '_>, item: &TraitItem) -> bool {
 fn is_relevant_block(tcx: TyCtxt<'_, '_, '_>, tables: &ty::TypeckTables<'_>, block: &Block) -> bool {
  if let Some(stmt) = block.stmts.first() {
  match &stmt.node {
- StmtKind::Decl(_, _) => true,
- StmtKind::Expr(expr, _) | StmtKind::Semi(expr, _) => is_relevant_expr(tcx, tables, expr),
+ StmtKind::Local(_) => true,
+ StmtKind::Expr(expr) | StmtKind::Semi(expr) => is_relevant_expr(tcx, tables, expr),
+ _ => false,
  }
  } else {
  block.expr.as_ref().map_or(false, |e| is_relevant_expr(tcx, tables, e))

clippy_lints/src/consts.rs

@@ -14,6 +14,7 @@ use std::convert::TryInto;
 use std::hash::{Hash, Hasher};
 use syntax::ast::{FloatTy, LitKind};
 use syntax::ptr::P;
+use syntax_pos::symbol::Symbol;
 
 /// A `LitKind`-like enum to fold constant `Expr`s into.
 #[derive(Debug, Clone)]
@@ -38,6 +39,8 @@ pub enum Constant {
  Repeat(Box<Constant>, u64),
  /// a tuple of constants
  Tuple(Vec<Constant>),
+ /// a literal with syntax error
+ Err(Symbol),
 }
 
 impl PartialEq for Constant {
@@ -103,6 +106,9 @@ impl Hash for Constant {
  c.hash(state);
  l.hash(state);
  },
+ Constant::Err(ref s) => {
+ s.hash(state);
+ },
  }
  }
 }
@@ -155,6 +161,7 @@ pub fn lit_to_constant<'tcx>(lit: &LitKind, ty: Ty<'tcx>) -> Constant {
  _ => bug!(),
  },
  LitKind::Bool(b) => Constant::Bool(b),
+ LitKind::Err(s) => Constant::Err(s),
  }
 }
 

clippy_lints/src/escape.rs

@@ -120,18 +120,16 @@ impl<'a, 'tcx> Delegate<'tcx> for EscapeDelegate<'a, 'tcx> {
  if let Categorization::Rvalue(..) = cmt.cat {
  let id = map.hir_to_node_id(cmt.hir_id);
  if let Some(Node::Stmt(st)) = map.find(map.get_parent_node(id)) {
- if let StmtKind::Decl(ref decl, _) = st.node {
- if let DeclKind::Local(ref loc) = decl.node {
- if let Some(ref ex) = loc.init {
- if let ExprKind::Box(..) = ex.node {
- if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) {
- // let x = box (...)
- self.set.insert(consume_pat.id);
- }
- // TODO Box::new
- // TODO vec![]
- // TODO "foo".to_owned() and friends
+ if let StmtKind::Local(ref loc) = st.node {
+ if let Some(ref ex) = loc.init {
+ if let ExprKind::Box(..) = ex.node {
+ if is_non_trait_box(cmt.ty) && !self.is_large_box(cmt.ty) {
+ // let x = box (...)
+ self.set.insert(consume_pat.id);
  }
+ // TODO Box::new
+ // TODO vec![]
+ // TODO "foo".to_owned() and friends
  }
  }
  }

clippy_lints/src/eval_order_dependence.rs

@@ -89,14 +89,13 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EvalOrderDependence {
  }
  fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
  match stmt.node {
- StmtKind::Expr(ref e, _) | StmtKind::Semi(ref e, _) => DivergenceVisitor { cx }.maybe_walk_expr(e),
- StmtKind::Decl(ref d, _) => {
- if let DeclKind::Local(ref local) = d.node {
- if let Local { init: Some(ref e), .. } = **local {
- DivergenceVisitor { cx }.visit_expr(e);
- }
+ StmtKind::Local(ref local) => {
+ if let Local { init: Some(ref e), .. } = **local {
+ DivergenceVisitor { cx }.visit_expr(e);
  }
  },
+ StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => DivergenceVisitor { cx }.maybe_walk_expr(e),
+ StmtKind::Item(..) => {},
  }
  }
 }
@@ -269,18 +268,14 @@ fn check_expr<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, expr: &'tcx Expr) -> St
 
 fn check_stmt<'a, 'tcx>(vis: &mut ReadVisitor<'a, 'tcx>, stmt: &'tcx Stmt) -> StopEarly {
  match stmt.node {
- StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => check_expr(vis, expr),
- StmtKind::Decl(ref decl, _) => {
- // If the declaration is of a local variable, check its initializer
- // expression if it has one. Otherwise, keep going.
- let local = match decl.node {
- DeclKind::Local(ref local) => Some(local),
- _ => None,
- };
- local
- .and_then(|local| local.init.as_ref())
- .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr))
- },
+ StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => check_expr(vis, expr),
+ // If the declaration is of a local variable, check its initializer
+ // expression if it has one. Otherwise, keep going.
+ StmtKind::Local(ref local) => local
+ .init
+ .as_ref()
+ .map_or(StopEarly::KeepGoing, |expr| check_expr(vis, expr)),
+ _ => StopEarly::KeepGoing,
  }
 }
 

clippy_lints/src/let_if_seq.rs

@@ -68,10 +68,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
  while let Some(stmt) = it.next() {
  if_chain! {
  if let Some(expr) = it.peek();
- if let hir::StmtKind::Decl(ref decl, _) = stmt.node;
- if let hir::DeclKind::Local(ref decl) = decl.node;
- if let hir::PatKind::Binding(mode, canonical_id, ident, None) = decl.pat.node;
- if let hir::StmtKind::Expr(ref if_, _) = expr.node;
+ if let hir::StmtKind::Local(ref local) = stmt.node;
+ if let hir::PatKind::Binding(mode, canonical_id, ident, None) = local.pat.node;
+ if let hir::StmtKind::Expr(ref if_) = expr.node;
  if let hir::ExprKind::If(ref cond, ref then, ref else_) = if_.node;
  if !used_in_expr(cx, canonical_id, cond);
  if let hir::ExprKind::Block(ref then, _) = then.node;
@@ -84,15 +83,15 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
  if let hir::ExprKind::Block(ref else_, _) = else_.node {
  if let Some(default) = check_assign(cx, canonical_id, else_) {
  (else_.stmts.len() > 1, default)
- } else if let Some(ref default) = decl.init {
+ } else if let Some(ref default) = local.init {
  (true, &**default)
  } else {
  continue;
  }
  } else {
  continue;
  }
- } else if let Some(ref default) = decl.init {
+ } else if let Some(ref default) = local.init {
  (false, &**default)
  } else {
  continue;
@@ -169,7 +168,7 @@ fn check_assign<'a, 'tcx>(
  if_chain! {
  if block.expr.is_none();
  if let Some(expr) = block.stmts.iter().last();
- if let hir::StmtKind::Semi(ref expr, _) = expr.node;
+ if let hir::StmtKind::Semi(ref expr) = expr.node;
  if let hir::ExprKind::Assign(ref var, ref value) = expr.node;
  if let hir::ExprKind::Path(ref qpath) = var.node;
  if let Def::Local(local_id) = cx.tables.qpath_def(qpath, var.hir_id);

clippy_lints/src/loops.rs

@@ -3,7 +3,7 @@ use if_chain::if_chain;
 use itertools::Itertools;
 use rustc::hir::def::Def;
 use rustc::hir::def_id;
-use rustc::hir::intravisit::{walk_block, walk_decl, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
+use rustc::hir::intravisit::{walk_block, walk_expr, walk_pat, walk_stmt, NestedVisitorMap, Visitor};
 use rustc::hir::*;
 use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintContext, LintPass};
 use rustc::middle::region;
@@ -597,7 +597,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
  }
 
  fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
- if let StmtKind::Semi(ref expr, _) = stmt.node {
+ if let StmtKind::Semi(ref expr) = stmt.node {
  if let ExprKind::MethodCall(ref method, _, ref args) = expr.node {
  if args.len() == 1 && method.ident.name == "collect" && match_trait_method(cx, expr, &paths::ITERATOR) {
  span_lint(
@@ -668,13 +668,7 @@ fn never_loop_block(block: &Block, main_loop_id: NodeId) -> NeverLoopResult {
 fn stmt_to_expr(stmt: &Stmt) -> Option<&Expr> {
  match stmt.node {
  StmtKind::Semi(ref e, ..) | StmtKind::Expr(ref e, ..) => Some(e),
- StmtKind::Decl(ref d, ..) => decl_to_expr(d),
- }
-}
-
-fn decl_to_expr(decl: &Decl) -> Option<&Expr> {
- match decl.node {
- DeclKind::Local(ref local) => local.init.as_ref().map(|p| &**p),
+ StmtKind::Local(ref local) => local.init.as_ref().map(|p| &**p),
  _ => None,
  }
 }
@@ -942,8 +936,8 @@ fn get_indexed_assignments<'a, 'tcx>(
  stmts
  .iter()
  .map(|stmt| match stmt.node {
- StmtKind::Decl(..) => None,
- StmtKind::Expr(ref e, _node_id) | StmtKind::Semi(ref e, _node_id) => Some(get_assignment(cx, e, var)),
+ StmtKind::Local(..) | StmtKind::Item(..) => None,
+ StmtKind::Expr(ref e) | StmtKind::Semi(ref e) => Some(get_assignment(cx, e, var)),
  })
  .chain(expr.as_ref().into_iter().map(|e| Some(get_assignment(cx, &*e, var))))
  .filter_map(|op| op)
@@ -1976,13 +1970,9 @@ fn extract_expr_from_first_stmt(block: &Block) -> Option<&Expr> {
  if block.stmts.is_empty() {
  return None;
  }
- if let StmtKind::Decl(ref decl, _) = block.stmts[0].node {
- if let DeclKind::Local(ref local) = decl.node {
- if let Some(ref expr) = local.init {
- Some(expr)
- } else {
- None
- }
+ if let StmtKind::Local(ref local) = block.stmts[0].node {
+ if let Some(ref expr) = local.init {
+ Some(expr)
  } else {
  None
  }
@@ -1996,8 +1986,8 @@ fn extract_first_expr(block: &Block) -> Option<&Expr> {
  match block.expr {
  Some(ref expr) if block.stmts.is_empty() => Some(expr),
  None if !block.stmts.is_empty() => match block.stmts[0].node {
- StmtKind::Expr(ref expr, _) | StmtKind::Semi(ref expr, _) => Some(expr),
- StmtKind::Decl(..) => None,
+ StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => Some(expr),
+ StmtKind::Local(..) | StmtKind::Item(..) => None,
  },
  _ => None,
  }
@@ -2095,9 +2085,9 @@ struct InitializeVisitor<'a, 'tcx: 'a> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
- fn visit_decl(&mut self, decl: &'tcx Decl) {
+ fn visit_stmt(&mut self, stmt: &'tcx Stmt) {
  // Look for declarations of the variable
- if let DeclKind::Local(ref local) = decl.node {
+ if let StmtKind::Local(ref local) = stmt.node {
  if local.pat.id == self.var_id {
  if let PatKind::Binding(_, _, ident, _) = local.pat.node {
  self.name = Some(ident.name);
@@ -2114,7 +2104,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InitializeVisitor<'a, 'tcx> {
  }
  }
  }
- walk_decl(self, decl);
+ walk_stmt(self, stmt);
  }
 
  fn visit_expr(&mut self, expr: &'tcx Expr) {
@@ -2261,7 +2251,7 @@ struct LoopNestVisitor {
 
 impl<'tcx> Visitor<'tcx> for LoopNestVisitor {
  fn visit_stmt(&mut self, stmt: &'tcx Stmt) {
- if stmt.node.id() == self.id {
+ if stmt.id == self.id {
  self.nesting = LookFurther;
  } else if self.nesting == Unknown {
  walk_stmt(self, stmt);

clippy_lints/src/map_unit_fn.rs

@@ -131,9 +131,10 @@ fn reduce_unit_expression<'a>(cx: &LateContext<'_, '_>, expr: &'a hir::Expr) ->
  // If block only contains statements,
  // reduce `{ X; }` to `X` or `X;`
  match inner_stmt.node {
- hir::StmtKind::Decl(ref d, _) => Some(d.span),
- hir::StmtKind::Expr(ref e, _) => Some(e.span),
- hir::StmtKind::Semi(_, _) => Some(inner_stmt.span),
+ hir::StmtKind::Local(ref local) => Some(local.span),
+ hir::StmtKind::Expr(ref e) => Some(e.span),
+ hir::StmtKind::Semi(..) => Some(inner_stmt.span),
+ hir::StmtKind::Item(..) => None,
  }
  },
  _ => {
@@ -250,7 +251,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
  return;
  }
 
- if let hir::StmtKind::Semi(ref expr, _) = stmt.node {
+ if let hir::StmtKind::Semi(ref expr) = stmt.node {
  if let Some(arglists) = method_chain_args(expr, &["map"]) {
  lint_map_unit_fn(cx, stmt, expr, arglists[0]);
  }

clippy_lints/src/methods/mod.rs

@@ -1336,12 +1336,10 @@ fn lint_clone_on_copy(cx: &LateContext<'_, '_>, expr: &hir::Expr, arg: &hir::Exp
  _ => {},
  },
  hir::Node::Stmt(stmt) => {
- if let hir::StmtKind::Decl(ref decl, _) = stmt.node {
- if let hir::DeclKind::Local(ref loc) = decl.node {
- if let hir::PatKind::Ref(..) = loc.pat.node {
- // let ref y = *x borrows x, let ref y = x.clone() does not
- return;
- }
+ if let hir::StmtKind::Local(ref loc) = stmt.node {
+ if let hir::PatKind::Ref(..) = loc.pat.node {
+ // let ref y = *x borrows x, let ref y = x.clone() does not
+ return;
  }
  }
  },

clippy_lints/src/misc.rs

@@ -277,8 +277,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
 
  fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, s: &'tcx Stmt) {
  if_chain! {
- if let StmtKind::Decl(ref d, _) = s.node;
- if let DeclKind::Local(ref l) = d.node;
+ if let StmtKind::Local(ref l) = s.node;
  if let PatKind::Binding(an, _, i, None) = l.pat.node;
  if let Some(ref init) = l.init;
  then {
@@ -316,7 +315,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
  }
  };
  if_chain! {
- if let StmtKind::Semi(ref expr, _) = s.node;
+ if let StmtKind::Semi(ref expr) = s.node;
  if let ExprKind::Binary(ref binop, ref a, ref b) = expr.node;
  if binop.node == BinOpKind::And || binop.node == BinOpKind::Or;
  if let Some(sugg) = Sugg::hir_opt(cx, a);

clippy_lints/src/needless_bool.rs

@@ -267,7 +267,7 @@ fn fetch_bool_block(block: &Block) -> Expression {
  match (&*block.stmts, block.expr.as_ref()) {
  (&[], Some(e)) => fetch_bool_expr(&**e),
  (&[ref e], None) => {
- if let StmtKind::Semi(ref e, _) = e.node {
+ if let StmtKind::Semi(ref e) = e.node {
  if let ExprKind::Ret(_) = e.node {
  fetch_bool_expr(&**e)
  } else {

clippy_lints/src/needless_pass_by_value.rs

@@ -368,8 +368,7 @@ impl<'a, 'tcx> MovedVariablesCtxt<'a, 'tcx> {
  Node::Stmt(s) => {
  // `let <pat> = x;`
  if_chain! {
- if let StmtKind::Decl(ref decl, _) = s.node;
- if let DeclKind::Local(ref local) = decl.node;
+ if let StmtKind::Local(ref local) = s.node;
  then {
  self.spans_need_deref
  .entry(vid)

clippy_lints/src/no_effect.rs

@@ -104,7 +104,7 @@ impl LintPass for Pass {
 
 impl<'a, 'tcx> LateLintPass<'a, 'tcx> for Pass {
  fn check_stmt(&mut self, cx: &LateContext<'a, 'tcx>, stmt: &'tcx Stmt) {
- if let StmtKind::Semi(ref expr, _) = stmt.node {
+ if let StmtKind::Semi(ref expr) = stmt.node {
  if has_no_effect(cx, expr) {
  span_lint(cx, NO_EFFECT, stmt.span, "statement with no effect");
  } else if let Some(reduced) = reduce_expression(cx, expr) {

clippy_lints/src/question_mark.rs

@@ -139,7 +139,7 @@ impl Pass {
  if_chain! {
  if block.stmts.len() == 1;
  if let Some(expr) = block.stmts.iter().last();
- if let StmtKind::Semi(ref expr, _) = expr.node;
+ if let StmtKind::Semi(ref expr) = expr.node;
  if let ExprKind::Ret(ref ret_expr) = expr.node;
  if let &Some(ref ret_expr) = ret_expr;