Some rustups

clippy_lints/src/matches.rs

@@ -713,16 +713,18 @@ fn all_ranges<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, arms: &'tcx [Arm<'_>]) -> Ve
             } = *arm
             {
                 if let PatKind::Range(ref lhs, ref rhs, ref range_end) = pat.kind {
-                    let lhs = constant(cx, cx.tables, lhs)?.0;
-                    let rhs = constant(cx, cx.tables, rhs)?.0;
-                    let rhs = match *range_end {
-                        RangeEnd::Included => Bound::Included(rhs),
-                        RangeEnd::Excluded => Bound::Excluded(rhs),
-                    };
-                    return Some(SpannedRange {
-                        span: pat.span,
-                        node: (lhs, rhs),
-                    });
+                    if let (Some(l), Some(r)) = (lhs, rhs) {
+                        let lhs = constant(cx, cx.tables, l)?.0;
+                        let rhs = constant(cx, cx.tables, r)?.0;
+                        let rhs = match *range_end {
+                            RangeEnd::Included => Bound::Included(rhs),
+                            RangeEnd::Excluded => Bound::Excluded(rhs),
+                        };
+                        return Some(SpannedRange {
+                            span: pat.span,
+                            node: (lhs, rhs),
+                        });
+                    }
                 }
 
                 if let PatKind::Lit(ref value) = pat.kind {

clippy_lints/src/needless_pass_by_value.rs

@@ -11,7 +11,7 @@ use rustc::traits;
 use rustc::traits::misc::can_type_implement_copy;
 use rustc::ty::{self, RegionKind, TypeFoldable};
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::*;
 use rustc_session::declare_tool_lint;
@@ -20,7 +20,6 @@ use rustc_target::spec::abi::Abi;
 use rustc_typeck::expr_use_visitor as euv;
 use std::borrow::Cow;
 use syntax::ast::Attribute;
-use syntax::errors::DiagnosticBuilder;
 
 declare_clippy_lint! {
     /// **What it does:** Checks for functions taking arguments by value, but not

clippy_lints/src/types.rs

@@ -10,7 +10,7 @@ use rustc::lint::{in_external_macro, LateContext, LateLintPass, LintArray, LintC
 use rustc::ty::layout::LayoutOf;
 use rustc::ty::{self, InferTy, Ty, TyCtxt, TypeckTables};
 use rustc::{declare_lint_pass, impl_lint_pass};
-use rustc_errors::Applicability;
+use rustc_errors::{Applicability, DiagnosticBuilder};
 use rustc_hir as hir;
 use rustc_hir::intravisit::{walk_body, walk_expr, walk_ty, FnKind, NestedVisitorMap, Visitor};
 use rustc_hir::*;
@@ -21,7 +21,6 @@ use rustc_span::symbol::{sym, Symbol};
 use rustc_target::spec::abi::Abi;
 use rustc_typeck::hir_ty_to_ty;
 use syntax::ast::{FloatTy, IntTy, LitFloatType, LitIntType, LitKind, UintTy};
-use syntax::errors::DiagnosticBuilder;
 
 use crate::consts::{constant, Constant};
 use crate::utils::paths;

clippy_lints/src/utils/author.rs

@@ -617,9 +617,13 @@ impl<'tcx> Visitor<'tcx> for PrintVisitor {
                     start_pat, end_pat, end_kind, current
                 );
                 self.current = start_pat;
-                self.visit_expr(start);
+                if let Some(expr) = start {
+                    self.visit_expr(expr);
+                }
                 self.current = end_pat;
-                self.visit_expr(end);
+                if let Some(expr) = end {
+                    self.visit_expr(expr);
+                }
             },
             PatKind::Slice(ref start, ref middle, ref end) => {
                 let start_pat = self.next("start");

clippy_lints/src/utils/diagnostics.rs

@@ -1,11 +1,10 @@
 //! Clippy wrappers around rustc's diagnostic functions.
 
 use rustc::lint::{LateContext, Lint, LintContext};
-use rustc_errors::{Applicability, CodeSuggestion, Substitution, SubstitutionPart, SuggestionStyle};
+use rustc_errors::{Applicability, CodeSuggestion, DiagnosticBuilder, Substitution, SubstitutionPart, SuggestionStyle};
 use rustc_hir::HirId;
 use rustc_span::source_map::{MultiSpan, Span};
 use std::env;
-use syntax::errors::DiagnosticBuilder;
 
 /// Wrapper around `DiagnosticBuilder` that adds a link to Clippy documentation for the emitted lint
 struct DiagnosticWrapper<'a>(DiagnosticBuilder<'a>);

clippy_lints/src/utils/hir_utils.rs

@@ -195,7 +195,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
                 ls == rs && over(l, r, |l, r| self.eq_pat(l, r))
             },
             (&PatKind::Range(ref ls, ref le, ref li), &PatKind::Range(ref rs, ref re, ref ri)) => {
-                self.eq_expr(ls, rs) && self.eq_expr(le, re) && (*li == *ri)
+                if let (Some(ls), Some(rs), Some(le), Some(re)) = (ls, rs, le, re) {
+                    return self.eq_expr(ls, rs) && self.eq_expr(le, re) && (*li == *ri);
+                }
+                false
             },
             (&PatKind::Ref(ref le, ref lm), &PatKind::Ref(ref re, ref rm)) => lm == rm && self.eq_pat(le, re),
             (&PatKind::Slice(ref ls, ref li, ref le), &PatKind::Slice(ref rs, ref ri, ref re)) => {

clippy_lints/src/utils/inspector.rs

@@ -483,8 +483,12 @@ fn print_pat(cx: &LateContext<'_, '_>, pat: &hir::Pat<'_>, indent: usize) {
         },
         hir::PatKind::Range(ref l, ref r, ref range_end) => {
             println!("{}Range", ind);
-            print_expr(cx, l, indent + 1);
-            print_expr(cx, r, indent + 1);
+            if let Some(expr) = l {
+                print_expr(cx, expr, indent + 1);
+            }
+            if let Some(expr) = r {
+                print_expr(cx, expr, indent + 1);
+            }
             match *range_end {
                 hir::RangeEnd::Included => println!("{} end included", ind),
                 hir::RangeEnd::Excluded => println!("{} end excluded", ind),