How to NOT solve rust-lang#2788

mati865 · mati865 · commit c5de91c80b99 · 2018-05-23T11:57:52.000+02:00
Seriously this workaround is terrible, don't merge it
diff --git a/clippy_lints/src/assign_ops.rs b/clippy_lints/src/assign_ops.rs
@@ -174,7 +174,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for AssignOps {
                             op.node,
                             cx,
                             ty,
-                            rty,
+                            rty.into(),
                             Add: BiAdd,
                             Sub: BiSub,
                             Mul: BiMul,
diff --git a/clippy_lints/src/consts.rs b/clippy_lints/src/consts.rs
@@ -429,9 +429,9 @@ pub fn miri_to_const<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, result: &ty::Const<'
             ty::TyRef(_, tam, _) => match tam.sty {
                 ty::TyStr => {
                     let alloc = tcx
-                        .interpret_interner
-                        .get_alloc(ptr.alloc_id)
-                        .unwrap();
+                        .alloc_map
+                        .lock()
+                        .unwrap_memory(ptr.alloc_id);
                     let offset = ptr.offset.bytes() as usize;
                     let n = n as usize;
                     String::from_utf8(alloc.bytes[offset..(offset + n)].to_owned()).ok().map(Constant::Str)
diff --git a/clippy_lints/src/enum_clike.rs b/clippy_lints/src/enum_clike.rs
@@ -50,9 +50,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnportableVariant {
         if let ItemEnum(ref def, _) = item.node {
             for var in &def.variants {
                 let variant = &var.node;
-                if let Some(body_id) = variant.disr_expr {
+                if let Some(ref anon_const) = variant.disr_expr {
                     let param_env = ty::ParamEnv::empty();
-                    let did = cx.tcx.hir.body_owner_def_id(body_id);
+                    let did = cx.tcx.hir.body_owner_def_id(anon_const.body);
                     let substs = Substs::identity_for_item(cx.tcx.global_tcx(), did);
                     let instance = ty::Instance::new(did, substs);
                     let cid = GlobalId {
diff --git a/clippy_lints/src/eq_op.rs b/clippy_lints/src/eq_op.rs
@@ -90,7 +90,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                         let lcpy = is_copy(cx, lty);
                         let rcpy = is_copy(cx, rty);
                         // either operator autorefs or both args are copyable
-                        if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty]) {
+                        if (requires_ref || (lcpy && rcpy)) && implements_trait(cx, lty, trait_id, &[rty.into()]) {
                             span_lint_and_then(
                                 cx,
                                 OP_REF,
@@ -106,12 +106,12 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                                     );
                                 },
                             )
-                        } else if lcpy && !rcpy && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)]) {
+                        } else if lcpy && !rcpy && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right).into()]) {
                             span_lint_and_then(cx, OP_REF, e.span, "needlessly taken reference of left operand", |db| {
                                 let lsnip = snippet(cx, l.span, "...").to_string();
                                 db.span_suggestion(left.span, "use the left value directly", lsnip);
                             })
-                        } else if !lcpy && rcpy && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty]) {
+                        } else if !lcpy && rcpy && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty.into()]) {
                             span_lint_and_then(
                                 cx,
                                 OP_REF,
@@ -128,7 +128,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                     (&ExprAddrOf(_, ref l), _) => {
                         let lty = cx.tables.expr_ty(l);
                         let lcpy = is_copy(cx, lty);
-                        if (requires_ref || lcpy) && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right)]) {
+                        if (requires_ref || lcpy) && implements_trait(cx, lty, trait_id, &[cx.tables.expr_ty(right).into()]) {
                             span_lint_and_then(cx, OP_REF, e.span, "needlessly taken reference of left operand", |db| {
                                 let lsnip = snippet(cx, l.span, "...").to_string();
                                 db.span_suggestion(left.span, "use the left value directly", lsnip);
@@ -139,7 +139,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for EqOp {
                     (_, &ExprAddrOf(_, ref r)) => {
                         let rty = cx.tables.expr_ty(r);
                         let rcpy = is_copy(cx, rty);
-                        if (requires_ref || rcpy) && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty]) {
+                        if (requires_ref || rcpy) && implements_trait(cx, cx.tables.expr_ty(left), trait_id, &[rty.into()]) {
                             span_lint_and_then(cx, OP_REF, e.span, "taken reference of right operand", |db| {
                                 let rsnip = snippet(cx, r.span, "...").to_string();
                                 db.span_suggestion(right.span, "use the right value directly", rsnip);
diff --git a/clippy_lints/src/misc.rs b/clippy_lints/src/misc.rs
@@ -495,13 +495,13 @@ fn check_to_owned(cx: &LateContext, expr: &Expr, other: &Expr) {
     // *arg impls PartialEq<other>
     if !arg_ty
         .builtin_deref(true)
-        .map_or(false, |tam| implements_trait(cx, tam.ty, partial_eq_trait_id, &[other_ty]))
+        .map_or(false, |tam| implements_trait(cx, tam.ty, partial_eq_trait_id, &[other_ty.into()]))
         // arg impls PartialEq<*other>
         && !other_ty
         .builtin_deref(true)
-        .map_or(false, |tam| implements_trait(cx, arg_ty, partial_eq_trait_id, &[tam.ty]))
+        .map_or(false, |tam| implements_trait(cx, arg_ty, partial_eq_trait_id, &[tam.ty.into()]))
         // arg impls PartialEq<other>
-        && !implements_trait(cx, arg_ty, partial_eq_trait_id, &[other_ty])
+        && !implements_trait(cx, arg_ty, partial_eq_trait_id, &[other_ty.into()])
     {
         return;
     }
diff --git a/clippy_lints/src/needless_pass_by_value.rs b/clippy_lints/src/needless_pass_by_value.rs
@@ -175,7 +175,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {
                             cx,
                             cx.tcx.mk_imm_ref(&RegionKind::ReErased, ty),
                             t.def_id(),
-                            &t.skip_binder().input_types().skip(1).collect::<Vec<_>>(),
+                            // What an ugly abomination
+                            &t.skip_binder().input_types().skip(1).collect::<Vec<_>>()
+                                .into_iter().map(|ty| ty.into()).collect::<Vec<_>>(),
                         )
                     }),
                 )
diff --git a/clippy_lints/src/shadow.rs b/clippy_lints/src/shadow.rs
@@ -348,15 +348,15 @@ fn check_expr<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, expr: &'tcx Expr, bindings:
 fn check_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: &'tcx Ty, bindings: &mut Vec<(Name, Span)>) {
     match ty.node {
         TySlice(ref sty) => check_ty(cx, sty, bindings),
-        TyArray(ref fty, body_id) => {
+        TyArray(ref fty, ref body_id) => {
             check_ty(cx, fty, bindings);
-            check_expr(cx, &cx.tcx.hir.body(body_id).value, bindings);
+            check_expr(cx, &cx.tcx.hir.body(body_id.body).value, bindings);
         },
         TyPtr(MutTy { ty: ref mty, .. }) | TyRptr(_, MutTy { ty: ref mty, .. }) => check_ty(cx, mty, bindings),
         TyTup(ref tup) => for t in tup {
             check_ty(cx, t, bindings)
         },
-        TyTypeof(body_id) => check_expr(cx, &cx.tcx.hir.body(body_id).value, bindings),
+        TyTypeof(ref body_id) => check_expr(cx, &cx.tcx.hir.body(body_id.body).value, bindings),
         _ => (),
     }
 }
diff --git a/clippy_lints/src/utils/hir_utils.rs b/clippy_lints/src/utils/hir_utils.rs
@@ -120,11 +120,11 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
             (&ExprMethodCall(ref l_path, _, ref l_args), &ExprMethodCall(ref r_path, _, ref r_args)) => {
                 !self.ignore_fn && l_path == r_path && self.eq_exprs(l_args, r_args)
             },
-            (&ExprRepeat(ref le, ll_id), &ExprRepeat(ref re, rl_id)) => {
-                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id));
-                let ll = celcx.expr(&self.cx.tcx.hir.body(ll_id).value);
-                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id));
-                let rl = celcx.expr(&self.cx.tcx.hir.body(rl_id).value);
+            (&ExprRepeat(ref le, ref ll_id), &ExprRepeat(ref re, ref rl_id)) => {
+                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id.body));
+                let ll = celcx.expr(&self.cx.tcx.hir.body(ll_id.body).value);
+                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id.body));
+                let rl = celcx.expr(&self.cx.tcx.hir.body(rl_id.body).value);
 
                 self.eq_expr(le, re) && ll == rl
             },
@@ -234,16 +234,16 @@ impl<'a, 'tcx: 'a> SpanlessEq<'a, 'tcx> {
     fn eq_ty(&mut self, left: &Ty, right: &Ty) -> bool {
         match (&left.node, &right.node) {
             (&TySlice(ref l_vec), &TySlice(ref r_vec)) => self.eq_ty(l_vec, r_vec),
-            (&TyArray(ref lt, ll_id), &TyArray(ref rt, rl_id)) => {
+            (&TyArray(ref lt, ref ll_id), &TyArray(ref rt, ref rl_id)) => {
                 let full_table = self.tables;
 
-                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id));
-                self.tables = self.cx.tcx.body_tables(ll_id);
-                let ll = celcx.expr(&self.cx.tcx.hir.body(ll_id).value);
+                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(ll_id.body));
+                self.tables = self.cx.tcx.body_tables(ll_id.body);
+                let ll = celcx.expr(&self.cx.tcx.hir.body(ll_id.body).value);
 
-                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id));
-                self.tables = self.cx.tcx.body_tables(rl_id);
-                let rl = celcx.expr(&self.cx.tcx.hir.body(rl_id).value);
+                let mut celcx = constant_context(self.cx, self.cx.tcx.body_tables(rl_id.body));
+                self.tables = self.cx.tcx.body_tables(rl_id.body);
+                let rl = celcx.expr(&self.cx.tcx.hir.body(rl_id.body).value);
 
                 let eq_ty = self.eq_ty(lt, rt);
                 self.tables = full_table;
@@ -474,13 +474,13 @@ impl<'a, 'tcx: 'a> SpanlessHash<'a, 'tcx> {
                 self.hash_name(&path.name);
                 self.hash_exprs(args);
             },
-            ExprRepeat(ref e, l_id) => {
+            ExprRepeat(ref e, ref l_id) => {
                 let c: fn(_, _) -> _ = ExprRepeat;
                 c.hash(&mut self.s);
                 self.hash_expr(e);
                 let full_table = self.tables;
-                self.tables = self.cx.tcx.body_tables(l_id);
-                self.hash_expr(&self.cx.tcx.hir.body(l_id).value);
+                self.tables = self.cx.tcx.body_tables(l_id.body);
+                self.hash_expr(&self.cx.tcx.hir.body(l_id.body).value);
                 self.tables = full_table;
             },
             ExprRet(ref e) => {
diff --git a/clippy_lints/src/utils/inspector.rs b/clippy_lints/src/utils/inspector.rs
@@ -330,12 +330,12 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {
                 print_expr(cx, base, indent + 1);
             }
         },
-        hir::ExprRepeat(ref val, body_id) => {
+        hir::ExprRepeat(ref val, ref anon_const) => {
             println!("{}Repeat", ind);
             println!("{}value:", ind);
             print_expr(cx, val, indent + 1);
             println!("{}repeat count:", ind);
-            print_expr(cx, &cx.tcx.hir.body(body_id).value, indent + 1);
+            print_expr(cx, &cx.tcx.hir.body(anon_const.body).value, indent + 1);
         },
     }
 }
diff --git a/clippy_lints/src/utils/mod.rs b/clippy_lints/src/utils/mod.rs
@@ -8,7 +8,7 @@ use rustc::hir::map::Node;
 use rustc::lint::{LateContext, Level, Lint, LintContext};
 use rustc::session::Session;
 use rustc::traits;
-use rustc::ty::{self, Ty, TyCtxt, layout::{self, IntegerExt}};
+use rustc::ty::{self, Ty, TyCtxt, layout::{self, IntegerExt}, subst::Kind};
 use rustc_errors::{Applicability, CodeSuggestion, Substitution, SubstitutionPart};
 use std::borrow::Cow;
 use std::env;
@@ -295,7 +295,7 @@ pub fn implements_trait<'a, 'tcx>(
     cx: &LateContext<'a, 'tcx>,
     ty: Ty<'tcx>,
     trait_id: DefId,
-    ty_params: &[Ty<'tcx>],
+    ty_params: &[Kind<'tcx>],
 ) -> bool {
     let ty = cx.tcx.erase_regions(&ty);
     let obligation =

Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,9 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NeedlessPassByValue {`
`175`	`175`	`cx,`
`176`	`176`	`cx.tcx.mk_imm_ref(&RegionKind::ReErased, ty),`
`177`	`177`	`t.def_id(),`
`178`		`- &t.skip_binder().input_types().skip(1).collect::<Vec<_>>(),`
	`178`	`+ // What an ugly abomination`
	`179`	`+ &t.skip_binder().input_types().skip(1).collect::<Vec<_>>()`
	`180`	`+ .into_iter().map(\|ty\| ty.into()).collect::<Vec<_>>(),`
`179`	`181`	`)`
`180`	`182`	`}),`
`181`	`183`	`)`
Original file line number	Diff line number	Diff line change
`@@ -330,12 +330,12 @@ fn print_expr(cx: &LateContext, expr: &hir::Expr, indent: usize) {`
`330`	`330`	`print_expr(cx, base, indent + 1);`
`331`	`331`	`}`
`332`	`332`	`},`
`333`		`- hir::ExprRepeat(ref val, body_id) => {`
	`333`	`+ hir::ExprRepeat(ref val, ref anon_const) => {`
`334`	`334`	`println!("{}Repeat", ind);`
`335`	`335`	`println!("{}value:", ind);`
`336`	`336`	`print_expr(cx, val, indent + 1);`
`337`	`337`	`println!("{}repeat count:", ind);`
`338`		`- print_expr(cx, &cx.tcx.hir.body(body_id).value, indent + 1);`
	`338`	`+ print_expr(cx, &cx.tcx.hir.body(anon_const.body).value, indent + 1);`
`339`	`339`	`},`
`340`	`340`	`}`
`341`	`341`	`}`