use super::{probe, MethodCallee};
use astconv::AstConv;
-use check::{FnCtxt, LvalueOp, callee, Needs};
+use check::{FnCtxt, PlaceOp, callee, Needs};
use hir::def_id::DefId;
use rustc::ty::subst::Substs;
use rustc::traits;
debug!("convert_lvalue_derefs_to_mutable: i={} expr={:?}", i, expr);
// Fix up the autoderefs. Autorefs can only occur immediately preceding
- // overloaded lvalue ops, and will be fixed by them in order to get
+ // overloaded place ops, and will be fixed by them in order to get
// the correct region.
let mut source = self.node_ty(expr.hir_id);
// Do not mutate adjustments in place, but rather take them,
match expr.node {
hir::ExprIndex(ref base_expr, ref index_expr) => {
let index_expr_ty = self.node_ty(index_expr.hir_id);
- self.convert_lvalue_op_to_mutable(
- LvalueOp::Index, expr, base_expr, &[index_expr_ty]);
+ self.convert_place_op_to_mutable(
+ PlaceOp::Index, expr, base_expr, &[index_expr_ty]);
}
hir::ExprUnary(hir::UnDeref, ref base_expr) => {
- self.convert_lvalue_op_to_mutable(
- LvalueOp::Deref, expr, base_expr, &[]);
+ self.convert_place_op_to_mutable(
+ PlaceOp::Deref, expr, base_expr, &[]);
}
_ => {}
}
}
}
- fn convert_lvalue_op_to_mutable(&self,
- op: LvalueOp,
+ fn convert_place_op_to_mutable(&self,
+ op: PlaceOp,
expr: &hir::Expr,
base_expr: &hir::Expr,
arg_tys: &[Ty<'tcx>])
{
- debug!("convert_lvalue_op_to_mutable({:?}, {:?}, {:?}, {:?})",
+ debug!("convert_place_op_to_mutable({:?}, {:?}, {:?}, {:?})",
op, expr, base_expr, arg_tys);
if !self.tables.borrow().is_method_call(expr) {
- debug!("convert_lvalue_op_to_mutable - builtin, nothing to do");
+ debug!("convert_place_op_to_mutable - builtin, nothing to do");
return
}
.map_or_else(|| self.node_ty(expr.hir_id), |adj| adj.target);
let base_ty = self.resolve_type_vars_if_possible(&base_ty);
- // Need to deref because overloaded lvalue ops take self by-reference.
+ // Need to deref because overloaded place ops take self by-reference.
let base_ty = base_ty.builtin_deref(false)
- .expect("lvalue op takes something that is not a ref")
+ .expect("place op takes something that is not a ref")
.ty;
- let method = self.try_overloaded_lvalue_op(
+ let method = self.try_overloaded_place_op(
expr.span, base_ty, arg_tys, Needs::MutPlace, op);
let method = match method {
Some(ok) => self.register_infer_ok_obligations(ok),
None => return self.tcx.sess.delay_span_bug(expr.span, "re-trying op failed")
};
- debug!("convert_lvalue_op_to_mutable: method={:?}", method);
+ debug!("convert_place_op_to_mutable: method={:?}", method);
self.write_method_call(expr.hir_id, method);
let (region, mutbl) = if let ty::TyRef(r, mt) = method.sig.inputs()[0].sty {
(r, mt.mutbl)
} else {
- span_bug!(expr.span, "input to lvalue op is not a ref?");
+ span_bug!(expr.span, "input to place op is not a ref?");
};
// Convert the autoref in the base expr to mutable with the correct
let mut source = base_expr_ty;
for adjustment in &mut adjustments[..] {
if let Adjust::Borrow(AutoBorrow::Ref(..)) = adjustment.kind {
- debug!("convert_lvalue_op_to_mutable: converting autoref {:?}", adjustment);
+ debug!("convert_place_op_to_mutable: converting autoref {:?}", adjustment);
adjustment.kind = Adjust::Borrow(AutoBorrow::Ref(region, mutbl));
adjustment.target = self.tcx.mk_ref(region, ty::TypeAndMut {
ty: source,
}
#[derive(Debug, Copy, Clone)]
-pub enum LvalueOp {
+pub enum PlaceOp {
Deref,
Index
}
// type from the method signature.
// If some lookup succeeded, install method in table
let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_expr.span));
- let method = self.try_overloaded_lvalue_op(
- expr.span, self_ty, &[input_ty], needs, LvalueOp::Index);
+ let method = self.try_overloaded_place_op(
+ expr.span, self_ty, &[input_ty], needs, PlaceOp::Index);
let result = method.map(|ok| {
debug!("try_index_step: success, using overloaded indexing");
None
}
- fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
+ fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option<DefId>, Symbol) {
let (tr, name) = match (op, is_mut) {
- (LvalueOp::Deref, false) =>
+ (PlaceOp::Deref, false) =>
(self.tcx.lang_items().deref_trait(), "deref"),
- (LvalueOp::Deref, true) =>
+ (PlaceOp::Deref, true) =>
(self.tcx.lang_items().deref_mut_trait(), "deref_mut"),
- (LvalueOp::Index, false) =>
+ (PlaceOp::Index, false) =>
(self.tcx.lang_items().index_trait(), "index"),
- (LvalueOp::Index, true) =>
+ (PlaceOp::Index, true) =>
(self.tcx.lang_items().index_mut_trait(), "index_mut"),
};
(tr, Symbol::intern(name))
}
- fn try_overloaded_lvalue_op(&self,
+ fn try_overloaded_place_op(&self,
span: Span,
base_ty: Ty<'tcx>,
arg_tys: &[Ty<'tcx>],
needs: Needs,
- op: LvalueOp)
+ op: PlaceOp)
-> Option<InferOk<'tcx, MethodCallee<'tcx>>>
{
- debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
+ debug!("try_overloaded_place_op({:?},{:?},{:?},{:?})",
span,
base_ty,
needs,
op);
// Try Mut first, if needed.
- let (mut_tr, mut_op) = self.resolve_lvalue_op(op, true);
+ let (mut_tr, mut_op) = self.resolve_place_op(op, true);
let method = match (needs, mut_tr) {
(Needs::MutPlace, Some(trait_did)) => {
self.lookup_method_in_trait(span, mut_op, trait_did, base_ty, Some(arg_tys))
};
// Otherwise, fall back to the immutable version.
- let (imm_tr, imm_op) = self.resolve_lvalue_op(op, false);
+ let (imm_tr, imm_op) = self.resolve_place_op(op, false);
let method = match (method, imm_tr) {
(None, Some(trait_did)) => {
self.lookup_method_in_trait(span, imm_op, trait_did, base_ty, Some(arg_tys))