needless borrows found in clippy

oli-obk · oli-obk · commit 6edc6a13d450 · 2016-05-09T13:07:55.000+02:00
diff --git a/src/array_indexing.rs b/src/array_indexing.rs
@@ -67,7 +67,7 @@ impl LateLintPass for ArrayIndexing {
                 let size = ConstInt::Infer(size as u64);
 
                 // Index is a constant uint
-                let const_index = eval_const_expr_partial(cx.tcx, &index, ExprTypeChecked, None);
+                let const_index = eval_const_expr_partial(cx.tcx, index, ExprTypeChecked, None);
                 if let Ok(ConstVal::Integral(const_index)) = const_index {
                     if size <= const_index {
                         utils::span_lint(cx, OUT_OF_BOUNDS_INDEXING, e.span, "const index is out of bounds");
diff --git a/src/block_in_if_condition.rs b/src/block_in_if_condition.rs
@@ -59,7 +59,7 @@ impl<'v> Visitor<'v> for ExVisitor<'v> {
                 }
             };
             if complex {
-                self.found_block = Some(&expr);
+                self.found_block = Some(expr);
                 return;
             }
         }
diff --git a/src/booleans.rs b/src/booleans.rs
@@ -221,7 +221,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {
                         s.push('(');
                     }
                 }
-                s.push_str(&snip(&terminals[n as usize]));
+                s.push_str(&snip(terminals[n as usize]));
                 if brackets {
                     if let ExprBinary(..) = terminals[n as usize].node {
                         s.push(')');
@@ -319,7 +319,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {
             }
             let mut improvements = Vec::new();
             'simplified: for suggestion in &simplified {
-                let simplified_stats = terminal_stats(&suggestion);
+                let simplified_stats = terminal_stats(suggestion);
                 let mut improvement = false;
                 for i in 0..32 {
                     // ignore any "simplifications" that end up requiring a terminal more often than in the original expression
diff --git a/src/consts.rs b/src/consts.rs
@@ -164,7 +164,7 @@ impl PartialOrd for Constant {
                 }
             }
             (&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),
-            (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(&r),
+            (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(r),
             (&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => {
                 match lv.partial_cmp(rv) {
                     Some(Equal) => Some(ls.cmp(rs)),
diff --git a/src/copies.rs b/src/copies.rs
@@ -142,7 +142,7 @@ fn lint_match_arms(cx: &LateContext, expr: &Expr) {
     };
 
     if let ExprMatch(_, ref arms, MatchSource::Normal) = expr.node {
-        if let Some((i, j)) = search_same(&arms, hash, eq) {
+        if let Some((i, j)) = search_same(arms, hash, eq) {
             span_note_and_lint(cx,
                                MATCH_SAME_ARMS,
                                j.body.span,
@@ -256,8 +256,8 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>
         match map.entry(hash(expr)) {
             Entry::Occupied(o) => {
                 for o in o.get() {
-                    if eq(&o, expr) {
-                        return Some((&o, expr));
+                    if eq(o, expr) {
+                        return Some((o, expr));
                     }
                 }
             }
diff --git a/src/cyclomatic_complexity.rs b/src/cyclomatic_complexity.rs
@@ -58,7 +58,7 @@ impl CyclomaticComplexity {
             divergence: 0,
             short_circuits: 0,
             returns: 0,
-            tcx: &cx.tcx,
+            tcx: cx.tcx,
         };
         helper.visit_block(block);
         let CCHelper { match_arms, divergence, short_circuits, returns, .. } = helper;
diff --git a/src/enum_variants.rs b/src/enum_variants.rs
@@ -68,9 +68,9 @@ impl EarlyLintPass for EnumVariantNames {
             for var in &def.variants {
                 let name = var2str(var);
 
-                let pre_match = partial_match(&pre, &name);
+                let pre_match = partial_match(pre, &name);
                 pre = &pre[..pre_match];
-                let pre_camel = camel_case_until(&pre);
+                let pre_camel = camel_case_until(pre);
                 pre = &pre[..pre_camel];
                 while let Some((next, last)) = name[pre.len()..].chars().zip(pre.chars().rev()).next() {
                     if next.is_lowercase() {
@@ -82,10 +82,10 @@ impl EarlyLintPass for EnumVariantNames {
                     }
                 }
 
-                let post_match = partial_rmatch(&post, &name);
+                let post_match = partial_rmatch(post, &name);
                 let post_end = post.len() - post_match;
                 post = &post[post_end..];
-                let post_camel = camel_case_from(&post);
+                let post_camel = camel_case_from(post);
                 post = &post[post_camel..];
             }
             let (what, value) = match (pre.is_empty(), post.is_empty()) {
diff --git a/src/len_zero.rs b/src/len_zero.rs
@@ -184,7 +184,7 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {
         })
     }
 
-    let ty = &walk_ptrs_ty(&cx.tcx.expr_ty(expr));
+    let ty = &walk_ptrs_ty(cx.tcx.expr_ty(expr));
     match ty.sty {
         ty::TyTrait(_) => {
             cx.tcx
diff --git a/src/lib.rs b/src/lib.rs
@@ -141,7 +141,7 @@ pub fn plugin_registrar(reg: &mut Registry) {
                 ("clippy.toml", false)
             };
 
-            let (conf, errors) = utils::conf::read_conf(&file_name, must_exist);
+            let (conf, errors) = utils::conf::read_conf(file_name, must_exist);
 
             // all conf errors are non-fatal, we just use the default conf in case of error
             for error in errors {
diff --git a/src/lifetimes.rs b/src/lifetimes.rs
@@ -46,7 +46,7 @@ impl LintPass for LifetimePass {
 impl LateLintPass for LifetimePass {
     fn check_item(&mut self, cx: &LateContext, item: &Item) {
         if let ItemFn(ref decl, _, _, _, ref generics, _) = item.node {
-            check_fn_inner(cx, decl, None, &generics, item.span);
+            check_fn_inner(cx, decl, None, generics, item.span);
         }
     }
 
@@ -102,7 +102,7 @@ fn check_fn_inner(cx: &LateContext, decl: &FnDecl, slf: Option<&ExplicitSelf>, g
                   span,
                   "explicit lifetimes given in parameter types where they could be elided");
     }
-    report_extra_lifetimes(cx, decl, &generics, slf);
+    report_extra_lifetimes(cx, decl, generics, slf);
 }
 
 fn could_use_elision<'a, T: Iterator<Item = &'a Lifetime>>(cx: &LateContext, func: &FnDecl, slf: Option<&ExplicitSelf>,
diff --git a/src/loops.rs b/src/loops.rs
@@ -328,7 +328,7 @@ fn check_for_loop(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &E
 /// Check for looping over a range and then indexing a sequence with it.
 /// The iteratee must be a range literal.
 fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, expr: &Expr) {
-    if let Some(UnsugaredRange { start: Some(ref start), ref end, .. }) = unsugar_range(&arg) {
+    if let Some(UnsugaredRange { start: Some(ref start), ref end, .. }) = unsugar_range(arg) {
         // the var must be a single name
         if let PatKind::Ident(_, ref ident, _) = pat.node {
             let mut visitor = VarVisitor {
@@ -363,7 +363,7 @@ fn check_for_loop_range(cx: &LateContext, pat: &Pat, arg: &Expr, body: &Expr, ex
                 };
 
                 let take: Cow<_> = if let Some(ref end) = *end {
-                    if is_len_call(&end, &indexed) {
+                    if is_len_call(end, &indexed) {
                         "".into()
                     } else {
                         format!(".take({})", snippet(cx, end.span, "..")).into()
@@ -422,10 +422,10 @@ fn is_len_call(expr: &Expr, var: &Name) -> bool {
 
 fn check_for_loop_reverse_range(cx: &LateContext, arg: &Expr, expr: &Expr) {
     // if this for loop is iterating over a two-sided range...
-    if let Some(UnsugaredRange { start: Some(ref start), end: Some(ref end), limits }) = unsugar_range(&arg) {
+    if let Some(UnsugaredRange { start: Some(ref start), end: Some(ref end), limits }) = unsugar_range(arg) {
         // ...and both sides are compile-time constant integers...
-        if let Ok(start_idx) = eval_const_expr_partial(&cx.tcx, start, ExprTypeChecked, None) {
-            if let Ok(end_idx) = eval_const_expr_partial(&cx.tcx, end, ExprTypeChecked, None) {
+        if let Ok(start_idx) = eval_const_expr_partial(cx.tcx, start, ExprTypeChecked, None) {
+            if let Ok(end_idx) = eval_const_expr_partial(cx.tcx, end, ExprTypeChecked, None) {
                 // ...and the start index is greater than the end index,
                 // this loop will never run. This is often confusing for developers
                 // who think that this will iterate from the larger value to the
diff --git a/src/matches.rs b/src/matches.rs
@@ -461,8 +461,8 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &
     let mut values = Vec::with_capacity(2 * ranges.len());
 
     for r in ranges {
-        values.push(Kind::Start(r.node.0, &r));
-        values.push(Kind::End(r.node.1, &r));
+        values.push(Kind::Start(r.node.0, r));
+        values.push(Kind::End(r.node.1, r));
     }
 
     values.sort();
@@ -475,7 +475,7 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &
                 }
             }
             (&Kind::End(a, _), &Kind::Start(b, _)) if a != b => (),
-            _ => return Some((&a.range(), &b.range())),
+            _ => return Some((a.range(), b.range())),
         }
     }
 
diff --git a/src/methods.rs b/src/methods.rs
@@ -365,7 +365,7 @@ impl LateLintPass for MethodsPass {
                     lint_cstring_as_ptr(cx, expr, &arglists[0][0], &arglists[1][0]);
                 }
 
-                lint_or_fun_call(cx, expr, &name.node.as_str(), &args);
+                lint_or_fun_call(cx, expr, &name.node.as_str(), args);
 
                 let self_ty = cx.tcx.expr_ty_adjusted(&args[0]);
                 if args.len() == 1 && name.node.as_str() == "clone" {
@@ -420,7 +420,7 @@ impl LateLintPass for MethodsPass {
 
                     // check conventions w.r.t. conversion method names and predicates
                     let ty = cx.tcx.lookup_item_type(cx.tcx.map.local_def_id(item.id)).ty;
-                    let is_copy = is_copy(cx, &ty, &item);
+                    let is_copy = is_copy(cx, ty, item);
                     for &(ref conv, self_kinds) in &CONVENTIONS {
                         if conv.check(&name.as_str()) &&
                            !self_kinds.iter().any(|k| k.matches(&sig.explicit_self.node, is_copy)) {
diff --git a/src/misc.rs b/src/misc.rs
@@ -424,7 +424,7 @@ fn is_used(cx: &LateContext, expr: &Expr) -> bool {
         match parent.node {
             ExprAssign(_, ref rhs) |
             ExprAssignOp(_, _, ref rhs) => **rhs == *expr,
-            _ => is_used(cx, &parent),
+            _ => is_used(cx, parent),
         }
     } else {
         true
diff --git a/src/mut_reference.rs b/src/mut_reference.rs
@@ -39,13 +39,13 @@ impl LateLintPass for UnnecessaryMutPassed {
                                                            If this happened, the compiler would have \
                                                            aborted the compilation long ago");
                 if let ExprPath(_, ref path) = fn_expr.node {
-                    check_arguments(cx, &arguments, function_type, &path.to_string());
+                    check_arguments(cx, arguments, function_type, &path.to_string());
                 }
             }
             ExprMethodCall(ref name, _, ref arguments) => {
                 let method_call = MethodCall::expr(e.id);
                 let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen.");
-                check_arguments(cx, &arguments, method_type.ty, &name.node.as_str())
+                check_arguments(cx, arguments, method_type.ty, &name.node.as_str())
             }
             _ => (),
         }
diff --git a/src/non_expressive_names.rs b/src/non_expressive_names.rs
@@ -249,7 +249,7 @@ impl EarlyLintPass for NonExpressiveNames {
                 let mut visitor = SimilarNamesLocalVisitor {
                     names: Vec::new(),
                     cx: cx,
-                    lint: &self,
+                    lint: self,
                     single_char_names: Vec::new(),
                 };
                 // initialize with function arguments
diff --git a/src/shadow.rs b/src/shadow.rs
@@ -278,7 +278,7 @@ fn check_expr(cx: &LateContext, expr: &Expr, bindings: &mut Vec<(Name, Span)>) {
             let len = bindings.len();
             for ref arm in arms {
                 for ref pat in &arm.pats {
-                    check_pat(cx, &pat, &Some(&**init), pat.span, bindings);
+                    check_pat(cx, pat, &Some(&**init), pat.span, bindings);
                     // This is ugly, but needed to get the right type
                     if let Some(ref guard) = arm.guard {
                         check_expr(cx, guard, bindings);
diff --git a/src/types.rs b/src/types.rs
@@ -910,7 +910,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:
         if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {
             if rel == Rel::Eq || rel == Rel::Ne {
                 if norm_rhs_val < lb || norm_rhs_val > ub {
-                    err_upcast_comparison(cx, &span, lhs, rel == Rel::Ne);
+                    err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);
                 }
             } else if match rel {
                 Rel::Lt => {
@@ -929,7 +929,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:
                 }
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, &span, lhs, true)
+                err_upcast_comparison(cx, span, lhs, true)
             } else if match rel {
                 Rel::Lt => {
                     if invert {
@@ -947,7 +947,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:
                 }
                 Rel::Eq | Rel::Ne => unreachable!(),
             } {
-                err_upcast_comparison(cx, &span, lhs, false)
+                err_upcast_comparison(cx, span, lhs, false)
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl<'v> Visitor<'v> for ExVisitor<'v> {`
`59`	`59`	`}`
`60`	`60`	`};`
`61`	`61`	`if complex {`
`62`		`- self.found_block = Some(&expr);`
	`62`	`+ self.found_block = Some(expr);`
`63`	`63`	`return;`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -221,7 +221,7 @@ fn suggest(cx: &LateContext, suggestion: &Bool, terminals: &[&Expr]) -> String {`
`221`	`221`	`s.push('(');`
`222`	`222`	`}`
`223`	`223`	`}`
`224`		`- s.push_str(&snip(&terminals[n as usize]));`
	`224`	`+ s.push_str(&snip(terminals[n as usize]));`
`225`	`225`	`if brackets {`
`226`	`226`	`if let ExprBinary(..) = terminals[n as usize].node {`
`227`	`227`	`s.push(')');`
`@@ -319,7 +319,7 @@ impl<'a, 'tcx> NonminimalBoolVisitor<'a, 'tcx> {`
`319`	`319`	`}`
`320`	`320`	`let mut improvements = Vec::new();`
`321`	`321`	`'simplified: for suggestion in &simplified {`
`322`		`- let simplified_stats = terminal_stats(&suggestion);`
	`322`	`+ let simplified_stats = terminal_stats(suggestion);`
`323`	`323`	`let mut improvement = false;`
`324`	`324`	`for i in 0..32 {`
`325`	`325`	`// ignore any "simplifications" that end up requiring a terminal more often than in the original expression`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ impl PartialOrd for Constant {`
`164`	`164`	`}`
`165`	`165`	`}`
`166`	`166`	`(&Constant::Bool(ref l), &Constant::Bool(ref r)) => Some(l.cmp(r)),`
`167`		`- (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(&r),`
	`167`	`+ (&Constant::Vec(ref l), &Constant::Vec(ref r)) => l.partial_cmp(r),`
`168`	`168`	`(&Constant::Repeat(ref lv, ref ls), &Constant::Repeat(ref rv, ref rs)) => {`
`169`	`169`	`match lv.partial_cmp(rv) {`
`170`	`170`	`Some(Equal) => Some(ls.cmp(rs)),`
Original file line number	Diff line number	Diff line change
`@@ -142,7 +142,7 @@ fn lint_match_arms(cx: &LateContext, expr: &Expr) {`
`142`	`142`	`};`
`143`	`143`
`144`	`144`	`if let ExprMatch(_, ref arms, MatchSource::Normal) = expr.node {`
`145`		`- if let Some((i, j)) = search_same(&arms, hash, eq) {`
	`145`	`+ if let Some((i, j)) = search_same(arms, hash, eq) {`
`146`	`146`	`span_note_and_lint(cx,`
`147`	`147`	`MATCH_SAME_ARMS,`
`148`	`148`	`j.body.span,`
`@@ -256,8 +256,8 @@ fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Option<(&T, &T)>`
`256`	`256`	`match map.entry(hash(expr)) {`
`257`	`257`	`Entry::Occupied(o) => {`
`258`	`258`	`for o in o.get() {`
`259`		`- if eq(&o, expr) {`
`260`		`- return Some((&o, expr));`
	`259`	`+ if eq(o, expr) {`
	`260`	`+ return Some((o, expr));`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`	`}`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ fn has_is_empty(cx: &LateContext, expr: &Expr) -> bool {`
`184`	`184`	`})`
`185`	`185`	`}`
`186`	`186`
`187`		`- let ty = &walk_ptrs_ty(&cx.tcx.expr_ty(expr));`
	`187`	`+ let ty = &walk_ptrs_ty(cx.tcx.expr_ty(expr));`
`188`	`188`	`match ty.sty {`
`189`	`189`	`ty::TyTrait(_) => {`
`190`	`190`	`cx.tcx`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ impl LintPass for LifetimePass {`
`46`	`46`	`impl LateLintPass for LifetimePass {`
`47`	`47`	`fn check_item(&mut self, cx: &LateContext, item: &Item) {`
`48`	`48`	`if let ItemFn(ref decl, _, _, _, ref generics, _) = item.node {`
`49`		`- check_fn_inner(cx, decl, None, &generics, item.span);`
	`49`	`+ check_fn_inner(cx, decl, None, generics, item.span);`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`@@ -102,7 +102,7 @@ fn check_fn_inner(cx: &LateContext, decl: &FnDecl, slf: Option<&ExplicitSelf>, g`
`102`	`102`	`span,`
`103`	`103`	`"explicit lifetimes given in parameter types where they could be elided");`
`104`	`104`	`}`
`105`		`- report_extra_lifetimes(cx, decl, &generics, slf);`
	`105`	`+ report_extra_lifetimes(cx, decl, generics, slf);`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`fn could_use_elision<'a, T: Iterator<Item = &'a Lifetime>>(cx: &LateContext, func: &FnDecl, slf: Option<&ExplicitSelf>,`
Original file line number	Diff line number	Diff line change
`@@ -461,8 +461,8 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &`
`461`	`461`	`let mut values = Vec::with_capacity(2 * ranges.len());`
`462`	`462`
`463`	`463`	`for r in ranges {`
`464`		`- values.push(Kind::Start(r.node.0, &r));`
`465`		`- values.push(Kind::End(r.node.1, &r));`
	`464`	`+ values.push(Kind::Start(r.node.0, r));`
	`465`	`+ values.push(Kind::End(r.node.1, r));`
`466`	`466`	`}`
`467`	`467`
`468`	`468`	`values.sort();`
`@@ -475,7 +475,7 @@ pub fn overlapping<T>(ranges: &[SpannedRange<T>]) -> Option<(&SpannedRange<T>, &`
`475`	`475`	`}`
`476`	`476`	`}`
`477`	`477`	`(&Kind::End(a, _), &Kind::Start(b, _)) if a != b => (),`
`478`		`- _ => return Some((&a.range(), &b.range())),`
	`478`	`+ _ => return Some((a.range(), b.range())),`
`479`	`479`	`}`
`480`	`480`	`}`
`481`	`481`
Original file line number	Diff line number	Diff line change
`@@ -424,7 +424,7 @@ fn is_used(cx: &LateContext, expr: &Expr) -> bool {`
`424`	`424`	`match parent.node {`
`425`	`425`	`ExprAssign(_, ref rhs) \|`
`426`	`426`	`ExprAssignOp(_, _, ref rhs) => *rhs == expr,`
`427`		`- _ => is_used(cx, &parent),`
	`427`	`+ _ => is_used(cx, parent),`
`428`	`428`	`}`
`429`	`429`	`} else {`
`430`	`430`	`true`
Original file line number	Diff line number	Diff line change
`@@ -39,13 +39,13 @@ impl LateLintPass for UnnecessaryMutPassed {`
`39`	`39`	`If this happened, the compiler would have \`
`40`	`40`	`aborted the compilation long ago");`
`41`	`41`	`if let ExprPath(_, ref path) = fn_expr.node {`
`42`		`- check_arguments(cx, &arguments, function_type, &path.to_string());`
	`42`	`+ check_arguments(cx, arguments, function_type, &path.to_string());`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`	`ExprMethodCall(ref name, _, ref arguments) => {`
`46`	`46`	`let method_call = MethodCall::expr(e.id);`
`47`	`47`	`let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen.");`
`48`		`- check_arguments(cx, &arguments, method_type.ty, &name.node.as_str())`
	`48`	`+ check_arguments(cx, arguments, method_type.ty, &name.node.as_str())`
`49`	`49`	`}`
`50`	`50`	`_ => (),`
`51`	`51`	`}`
Original file line number	Diff line number	Diff line change
`@@ -910,7 +910,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:`
`910`	`910`	`if let Some(norm_rhs_val) = node_as_const_fullint(cx, rhs) {`
`911`	`911`	`if rel == Rel::Eq \|\| rel == Rel::Ne {`
`912`	`912`	`if norm_rhs_val < lb \|\| norm_rhs_val > ub {`
`913`		`- err_upcast_comparison(cx, &span, lhs, rel == Rel::Ne);`
	`913`	`+ err_upcast_comparison(cx, span, lhs, rel == Rel::Ne);`
`914`	`914`	`}`
`915`	`915`	`} else if match rel {`
`916`	`916`	`Rel::Lt => {`
`@@ -929,7 +929,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:`
`929`	`929`	`}`
`930`	`930`	`Rel::Eq \| Rel::Ne => unreachable!(),`
`931`	`931`	`} {`
`932`		`- err_upcast_comparison(cx, &span, lhs, true)`
	`932`	`+ err_upcast_comparison(cx, span, lhs, true)`
`933`	`933`	`} else if match rel {`
`934`	`934`	`Rel::Lt => {`
`935`	`935`	`if invert {`
`@@ -947,7 +947,7 @@ fn upcast_comparison_bounds_err(cx: &LateContext, span: &Span, rel: comparisons:`
`947`	`947`	`}`
`948`	`948`	`Rel::Eq \| Rel::Ne => unreachable!(),`
`949`	`949`	`} {`
`950`		`- err_upcast_comparison(cx, &span, lhs, false)`
	`950`	`+ err_upcast_comparison(cx, span, lhs, false)`
`951`	`951`	`}`
`952`	`952`	`}`
`953`	`953`	`}`