From 3f4a489f8fc73138cde77bcf10497d5f209d3b3a Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Mon, 29 Jan 2018 00:55:39 +0200 Subject: [PATCH] rustc_typeck: rename `LvalueOp` to `PlaceOp`. --- src/librustc_typeck/check/autoderef.rs | 4 +-- src/librustc_typeck/check/method/confirm.rs | 32 ++++++++++----------- src/librustc_typeck/check/mod.rs | 26 ++++++++--------- 3 files changed, 31 insertions(+), 31 deletions(-) diff --git a/src/librustc_typeck/check/autoderef.rs b/src/librustc_typeck/check/autoderef.rs index 5353d4cc672b..1d7c533178f0 100644 --- a/src/librustc_typeck/check/autoderef.rs +++ b/src/librustc_typeck/check/autoderef.rs @@ -10,7 +10,7 @@ use astconv::AstConv; -use super::{FnCtxt, LvalueOp, Needs}; +use super::{FnCtxt, PlaceOp, Needs}; use super::method::MethodCallee; use rustc::infer::InferOk; @@ -239,6 +239,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { base_ty: Ty<'tcx>, needs: Needs) -> Option>> { - self.try_overloaded_lvalue_op(span, base_ty, &[], needs, LvalueOp::Deref) + self.try_overloaded_place_op(span, base_ty, &[], needs, PlaceOp::Deref) } } diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs index 691ce18c7382..71c1326b4123 100644 --- a/src/librustc_typeck/check/method/confirm.rs +++ b/src/librustc_typeck/check/method/confirm.rs @@ -11,7 +11,7 @@ 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; @@ -438,7 +438,7 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> { 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, @@ -470,28 +470,28 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> { 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 } @@ -499,24 +499,24 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> { .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 @@ -529,7 +529,7 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> { 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, diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 4ccc88f9b159..8a54240c1e77 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -424,7 +424,7 @@ impl UnsafetyState { } #[derive(Debug, Copy, Clone)] -pub enum LvalueOp { +pub enum PlaceOp { Deref, Index } @@ -2293,8 +2293,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // 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"); @@ -2329,36 +2329,36 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { None } - fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option, Symbol) { + fn resolve_place_op(&self, op: PlaceOp, is_mut: bool) -> (Option, 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>> { - 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)) @@ -2367,7 +2367,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { }; // 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))