match def {
Def::Const(def_id) |
Def::AssociatedConst(def_id) => {
- let substs = self.tables
- .node_id_item_substs(id)
- .unwrap_or_else(|| self.tcx.intern_substs(&[]));
+ let substs = self.tables.node_substs(id);
let substs = if self.substs.is_empty() {
substs
} else {
if let Categorization::Local(lid) = cmt.cat {
if self.set.contains(&lid) {
- if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+ if let Some(&Adjust::Deref(ref overloaded)) =
self.tables
.adjustments
.get(&borrow_id)
.map(|a| &a.kind) {
if LoanCause::AutoRef == loan_cause {
// x.foo()
- if autoderefs == 0 {
+ if overloaded == 0 {
self.set.remove(&lid); // Used without autodereffing (i.e. x.clone())
}
} else {
}
} else if LoanCause::AddrOf == loan_cause {
// &x
- if let Some(&Adjust::DerefRef { autoderefs, .. }) =
+ if let Some(&Adjust::Deref(ref overloaded)) =
self.tables
.adjustments
.get(&self.tcx
.hir
.get_parent_node(borrow_id))
.map(|a| &a.kind) {
- if autoderefs <= 1 {
+ if overloaded <= 1 {
// foo(&x) where no extra autoreffing is happening
self.set.remove(&lid);
}
}
},
ExprMethodCall(..) => {
- let method_call = ty::MethodCall::expr(e.id);
let borrowed_table = self.cx.tables;
- let method_type = borrowed_table.method_map.get(&method_call).expect("This should never happen.");
- let result_ty = method_type.ty.fn_ret();
- if let ty::TyNever = self.cx.tcx.erase_late_bound_regions(&result_ty).sty {
+ if borrowed_table.expr_ty(e).is_never() {
self.report_diverging_sub_expr(e);
}
},
}
},
hir::ExprMethodCall(_, _, ref args) => {
- let method_call = ty::MethodCall::expr(expr.id);
- let base_type = self.cx.tables.method_map[&method_call].ty;
+ let def_id = self.cx.tables.type_dependent_defs[&expr.id].def_id();
+ let base_type = self.cx.tcx.type_of(def_id);
if type_is_unsafe_function(base_type) {
for arg in args {
{
let did = cx.tcx.hir.local_def_id(item.id.node_id);
let impl_ty = cx.tcx.type_of(did);
- impl_ty.fn_args().skip_binder().len() == 1
+ impl_ty.fn_sig().inputs().skip_binder().len() == 1
}
} else {
false
{
let did = cx.tcx.hir.local_def_id(item.id.node_id);
let impl_ty = cx.tcx.type_of(did);
- impl_ty.fn_args().skip_binder().len() == 1
+ impl_ty.fn_sig().inputs().skip_binder().len() == 1
}
} else {
false
lint_iter_method(cx, args, arg, &method_name);
}
} else if method_name == "into_iter" && match_trait_method(cx, arg, &paths::INTO_ITERATOR) {
- let method_call = ty::MethodCall::expr(arg.id);
- let fn_ty = cx.tables
- .method_map
- .get(&method_call)
- .map(|method_callee| method_callee.ty)
- .expect("method calls need an entry in the method map");
- let fn_arg_tys = fn_ty.fn_args();
+ let fn_ty = cx.tables.expr_ty(arg);
+ let fn_arg_tys = fn_ty.fn_sig().inputs();
assert_eq!(fn_arg_tys.skip_binder().len(), 1);
if fn_arg_tys.skip_binder()[0].is_region_ptr() {
lint_iter_method(cx, args, arg, &method_name);
use rustc::lint::*;
-use rustc::ty::{TypeAndMut, TypeVariants, MethodCall, TyS};
+use rustc::ty::{TypeAndMut, TypeVariants, TyS};
use rustc::hir::*;
use utils::span_lint;
}
},
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())
+ let method_type = borrowed_table.expr_ty(e);
+ check_arguments(cx, arguments, method_type, &name.node.as_str())
},
_ => (),
}
}
if let ExprAddrOf(MutImmutable, ref inner) = e.node {
if let ty::TyRef(..) = cx.tables.expr_ty(inner).sty {
- if let Some(&ty::adjustment::Adjust::DerefRef { autoderefs, autoref, .. }) =
+ if let Some(&ty::adjustment::Adjust::Deref(ref overloaded)) =
cx.tables.adjustments.get(&e.id).map(|a| &a.kind) {
if autoderefs > 1 && autoref.is_some() {
span_lint(cx,
/// Check if the method call given in `expr` belongs to given type.
pub fn match_impl_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool {
- let method_call = ty::MethodCall::expr(expr.id);
-
- let trt_id = cx.tables
- .method_map
- .get(&method_call)
- .and_then(|callee| cx.tcx.impl_of_method(callee.def_id));
+ let method_call = cx.tables.type_dependent_defs[&expr.id];
+ let trt_id = cx.tcx.impl_of_method(method_call.def_id());
if let Some(trt_id) = trt_id {
match_def_path(cx.tcx, trt_id, path)
} else {
/// Check if the method call given in `expr` belongs to given trait.
pub fn match_trait_method(cx: &LateContext, expr: &Expr, path: &[&str]) -> bool {
- let method_call = ty::MethodCall::expr(expr.id);
-
- let trt_id = cx.tables
- .method_map
- .get(&method_call)
- .and_then(|callee| cx.tcx.trait_of_item(callee.def_id));
+ let method_call = cx.tables.type_dependent_defs[&expr.id];
+ let trt_id = cx.tcx.trait_of_item(method_call.def_id());
if let Some(trt_id) = trt_id {
match_def_path(cx.tcx, trt_id, path)
} else {