}
ast::ExprIndex(ref l, ref r) |
- ast::ExprBinary(_, ref l, ref r) if self.is_method_call(expr) => {
+ ast::ExprBinary(_, ref l, ref r) if self.tcx.is_method_call(expr.id) => {
self.call(expr, pred, &**l, Some(&**r).into_iter())
}
self.straightline(expr, pred, fields)
}
- ast::ExprUnary(_, ref e) if self.is_method_call(expr) => {
+ ast::ExprUnary(_, ref e) if self.tcx.is_method_call(expr.id) => {
self.call(expr, pred, &**e, None::<ast::Expr>.iter())
}
}
}
}
-
- fn is_method_call(&self, expr: &ast::Expr) -> bool {
- let method_call = ty::MethodCall::expr(expr.id);
- self.tcx.tables.borrow().method_map.contains_key(&method_call)
- }
}
self.tables.borrow().method_map.contains_key(&MethodCall::expr(expr_id))
}
+ pub fn is_overloaded_autoderef(&self, expr_id: ast::NodeId, autoderefs: u32) -> bool {
+ self.tables.borrow().method_map.contains_key(&MethodCall::autoderef(expr_id,
+ autoderefs))
+ }
+
pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarCapture> {
Some(self.tables.borrow().upvar_capture_map.get(&upvar_id).unwrap().clone())
}
match datum.ty.sty {
// Don't skip a conversion from Box<T> to &T, etc.
ty::TyRef(..) => {
- let method_call = MethodCall::autoderef(expr.id, 0);
- if bcx.tcx().tables.borrow().method_map.contains_key(&method_call) {
+ if bcx.tcx().is_overloaded_autoderef(expr.id, 0) {
// Don't skip an overloaded deref.
0
} else {
// The only overloaded operator that is translated to a datum
// is an overloaded deref, since it is always yields a `&T`.
// Otherwise, we should be in the RvalueDpsExpr path.
- assert!(
- op == ast::UnDeref ||
- !ccx.tcx().tables.borrow().method_map.contains_key(&method_call));
+ assert!(op == ast::UnDeref || !ccx.tcx().is_method_call(expr.id));
let un_ty = expr_ty(bcx, expr);
let ccx = bcx.ccx();
// if overloaded, would be RvalueDpsExpr
- assert!(!ccx.tcx().tables.borrow().method_map.contains_key(&MethodCall::expr(expr.id)));
+ assert!(!ccx.tcx().is_method_call(expr.id));
match op.node {
ast::BiAnd => {
debug!("trans_assign_op(expr={:?})", expr);
// User-defined operator methods cannot be used with `+=` etc right now
- assert!(!bcx.tcx().tables.borrow().method_map.contains_key(&MethodCall::expr(expr.id)));
+ assert!(!bcx.tcx().is_method_call(expr.id));
// Evaluate LHS (destination), which should be an lvalue
let dst_datum = unpack_datum!(bcx, trans_to_lvalue(bcx, dst, "assign_op"));
}
fn expr_kind(tcx: &ty::ctxt, expr: &ast::Expr) -> ExprKind {
- if tcx.tables.borrow().method_map.contains_key(&MethodCall::expr(expr.id)) {
+ if tcx.is_method_call(expr.id) {
// Overloaded operations are generally calls, and hence they are
// generated via DPS, but there are a few exceptions:
return match expr.node {
type_must_outlive(rcx, infer::ExprTypeIsNotInScope(expr_ty, expr.span),
expr_ty, ty::ReScope(CodeExtent::from_node_id(expr.id)));
- let method_call = MethodCall::expr(expr.id);
- let has_method_map = rcx.fcx.inh.tables.borrow().method_map.contains_key(&method_call);
+ let has_method_map = rcx.fcx.infcx().is_method_call(expr.id);
// Check any autoderefs or autorefs that appear.
let adjustment = rcx.fcx.inh.tables.borrow().adjustments.get(&expr.id).map(|a| a.clone());