Skip to content

Commit 191cde0

Browse files
borsbors
committed
Auto merge of rust-lang#42053 - nikomatsakis:beta, r=eddyb
Beta backport various arielb1 patches Backport of the following PRs: - rust-lang#41651 - rust-lang#41828 cc @arielb1 @rust-lang/compiler
2 parents f5b3def + 0afe53e commit 191cde0

File tree

10 files changed

+298
-232
lines changed

10 files changed

+298
-232
lines changed

‎src/librustc_typeck/check/autoderef.rs

+7-34
Original file line numberDiff line numberDiff line change
@@ -10,15 +10,15 @@
1010

1111
use astconv::AstConv;
1212

13-
use super::FnCtxt;
13+
use super::{FnCtxt, LvalueOp};
1414

1515
use check::coercion::AsCoercionSite;
1616
use rustc::infer::InferOk;
1717
use rustc::traits;
1818
use rustc::ty::{self, Ty, TraitRef};
1919
use rustc::ty::{ToPredicate, TypeFoldable};
2020
use rustc::ty::{MethodCall, MethodCallee};
21-
use rustc::ty::{LvaluePreference, NoPreference, PreferMutLvalue};
21+
use rustc::ty::{LvaluePreference, NoPreference};
2222
use rustc::hir;
2323

2424
use syntax_pos::Span;
@@ -213,39 +213,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
213213
span: Span,
214214
base_expr: Option<&hir::Expr>,
215215
base_ty: Ty<'tcx>,
216-
lvalue_pref: LvaluePreference)
216+
pref: LvaluePreference)
217217
-> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
218-
debug!("try_overloaded_deref({:?},{:?},{:?},{:?})",
219-
span,
220-
base_expr,
221-
base_ty,
222-
lvalue_pref);
223-
// Try DerefMut first, if preferred.
224-
let method = match (lvalue_pref, self.tcx.lang_items.deref_mut_trait()) {
225-
(PreferMutLvalue, Some(trait_did)) => {
226-
self.lookup_method_in_trait(span,
227-
base_expr,
228-
Symbol::intern("deref_mut"),
229-
trait_did,
230-
base_ty,
231-
None)
232-
}
233-
_ => None,
234-
};
235-
236-
// Otherwise, fall back to Deref.
237-
let method = match (method, self.tcx.lang_items.deref_trait()) {
238-
(None, Some(trait_did)) => {
239-
self.lookup_method_in_trait(span,
240-
base_expr,
241-
Symbol::intern("deref"),
242-
trait_did,
243-
base_ty,
244-
None)
245-
}
246-
(method, _) => method,
247-
};
218+
let rcvr = base_expr.map(|base_expr| super::AdjustedRcvr {
219+
rcvr_expr: base_expr, autoderefs: 0, unsize: false
220+
});
248221

249-
method
222+
self.try_overloaded_lvalue_op(span, rcvr, base_ty, &[], pref, LvalueOp::Deref)
250223
}
251224
}

‎src/librustc_typeck/check/callee.rs

+5-3
Original file line numberDiff line numberDiff line change
@@ -165,11 +165,13 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
165165
};
166166

167167
match self.lookup_method_in_trait_adjusted(call_expr.span,
168-
Some(&callee_expr),
168+
Some(super::AdjustedRcvr {
169+
rcvr_expr: callee_expr,
170+
autoderefs,
171+
unsize: false
172+
}),
169173
method_name,
170174
trait_def_id,
171-
autoderefs,
172-
false,
173175
adjusted_ty,
174176
None) {
175177
None => continue,

‎src/librustc_typeck/check/method/confirm.rs

+77-119
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@
1010

1111
use super::probe;
1212

13-
use check::{FnCtxt, callee};
13+
use check::{FnCtxt, LvalueOp, callee};
1414
use hir::def_id::DefId;
1515
use rustc::ty::subst::Substs;
1616
use rustc::traits;
@@ -433,137 +433,95 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
433433
for (i, &expr) in exprs.iter().rev().enumerate() {
434434
debug!("convert_lvalue_derefs_to_mutable: i={} expr={:?}", i, expr);
435435

436-
// Count autoderefs. We don't need to fix up the autoref - the parent
437-
// expression will fix them up for us.
438-
let adjustment = self.tables.borrow().adjustments.get(&expr.id).cloned();
439-
match adjustment {
440-
Some(Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) => {
441-
if autoderefs > 0 {
442-
let mut autoderef = self.autoderef(expr.span, self.node_ty(expr.id));
443-
autoderef.nth(autoderefs).unwrap_or_else(|| {
444-
span_bug!(expr.span,
445-
"expr was deref-able {} times but now isn't?",
446-
autoderefs);
447-
});
448-
autoderef.finalize(PreferMutLvalue, expr);
449-
}
450-
}
451-
Some(_) | None => {}
436+
// Fix up the autoderefs. Autorefs can only occur immediately preceding
437+
// overloaded lvalue ops, and will be fixed by them in order to get
438+
// the correct region.
439+
let autoderefs = match self.tables.borrow().adjustments.get(&expr.id) {
440+
Some(&Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) => autoderefs,
441+
Some(_) | None => 0
442+
};
443+
444+
if autoderefs > 0 {
445+
let mut autoderef = self.autoderef(expr.span, self.node_ty(expr.id));
446+
autoderef.nth(autoderefs).unwrap_or_else(|| {
447+
span_bug!(expr.span,
448+
"expr was deref-able {} times but now isn't?",
449+
autoderefs);
450+
});
451+
autoderef.finalize(PreferMutLvalue, expr);
452452
}
453453

454-
// Don't retry the first one or we might infinite loop!
455-
if i == 0 {
456-
continue;
457-
}
458454
match expr.node {
459455
hir::ExprIndex(ref base_expr, ref index_expr) => {
460-
// If this is an overloaded index, the
461-
// adjustment will include an extra layer of
462-
// autoref because the method is an &self/&mut
463-
// self method. We have to peel it off to get
464-
// the raw adjustment that `try_index_step`
465-
// expects. This is annoying and horrible. We
466-
// ought to recode this routine so it doesn't
467-
// (ab)use the normal type checking paths.
468-
let adj = self.tables.borrow_mut().adjustments.remove(&base_expr.id);
469-
let (autoderefs, unsize, adjusted_base_ty) = match adj {
470-
Some(Adjustment {
471-
kind: Adjust::DerefRef { autoderefs, autoref, unsize },
472-
target
473-
}) => {
474-
match autoref {
475-
None => {
476-
assert!(!unsize);
477-
}
478-
Some(AutoBorrow::Ref(..)) => {}
479-
Some(_) => {
480-
span_bug!(base_expr.span,
481-
"unexpected adjustment autoref {:?}",
482-
adj);
483-
}
484-
}
485-
486-
(autoderefs, unsize, if unsize {
487-
target.builtin_deref(false, NoPreference)
488-
.expect("fixup: AutoBorrow::Ref is not &T")
489-
.ty
490-
} else {
491-
let ty = self.node_ty(base_expr.id);
492-
let mut ty = self.shallow_resolve(ty);
493-
let mut method_type = |method_call: ty::MethodCall| {
494-
self.tables.borrow().method_map.get(&method_call).map(|m| {
495-
self.resolve_type_vars_if_possible(&m.ty)
496-
})
497-
};
498-
499-
if !ty.references_error() {
500-
for i in 0..autoderefs {
501-
ty = ty.adjust_for_autoderef(self.tcx,
502-
base_expr.id,
503-
base_expr.span,
504-
i as u32,
505-
&mut method_type);
506-
}
507-
}
508-
509-
ty
510-
})
511-
}
512-
None => (0, false, self.node_ty(base_expr.id)),
513-
Some(_) => {
514-
span_bug!(base_expr.span, "unexpected adjustment type");
515-
}
516-
};
517-
518456
let index_expr_ty = self.node_ty(index_expr.id);
519-
let adjusted_base_ty = self.resolve_type_vars_if_possible(&adjusted_base_ty);
520-
let index_expr_ty = self.resolve_type_vars_if_possible(&index_expr_ty);
521-
522-
let result = self.try_index_step(ty::MethodCall::expr(expr.id),
523-
expr,
524-
&base_expr,
525-
adjusted_base_ty,
526-
autoderefs,
527-
unsize,
528-
PreferMutLvalue,
529-
index_expr_ty);
530-
531-
if let Some((input_ty, return_ty)) = result {
532-
self.demand_suptype(index_expr.span, input_ty, index_expr_ty);
533-
534-
let expr_ty = self.node_ty(expr.id);
535-
self.demand_suptype(expr.span, expr_ty, return_ty);
536-
} else {
537-
// We could not perform a mutable index. Re-apply the
538-
// immutable index adjustments - borrowck will detect
539-
// this as an error.
540-
if let Some(adjustment) = adjustment {
541-
self.apply_adjustment(expr.id, adjustment);
542-
}
543-
self.tcx.sess.delay_span_bug(
544-
expr.span, "convert_lvalue_derefs_to_mutable failed");
545-
}
457+
self.convert_lvalue_op_to_mutable(
458+
LvalueOp::Index, expr, base_expr, &[index_expr_ty]);
546459
}
547460
hir::ExprUnary(hir::UnDeref, ref base_expr) => {
548-
// if this is an overloaded deref, then re-evaluate with
549-
// a preference for mut
550-
let method_call = ty::MethodCall::expr(expr.id);
551-
if self.tables.borrow().method_map.contains_key(&method_call) {
552-
self.tables.borrow_mut().adjustments.remove(&base_expr.id);
553-
let method = self.try_overloaded_deref(expr.span,
554-
Some(&base_expr),
555-
self.node_ty(base_expr.id),
556-
PreferMutLvalue);
557-
let ok = method.expect("re-trying deref failed");
558-
let method = self.register_infer_ok_obligations(ok);
559-
self.tables.borrow_mut().method_map.insert(method_call, method);
560-
}
461+
self.convert_lvalue_op_to_mutable(
462+
LvalueOp::Deref, expr, base_expr, &[]);
561463
}
562464
_ => {}
563465
}
564466
}
565467
}
566468

469+
fn convert_lvalue_op_to_mutable(&self,
470+
op: LvalueOp,
471+
expr: &hir::Expr,
472+
base_expr: &hir::Expr,
473+
arg_tys: &[Ty<'tcx>])
474+
{
475+
debug!("convert_lvalue_op_to_mutable({:?}, {:?}, {:?}, {:?})",
476+
op, expr, base_expr, arg_tys);
477+
let method_call = ty::MethodCall::expr(expr.id);
478+
if !self.tables.borrow().method_map.contains_key(&method_call) {
479+
debug!("convert_lvalue_op_to_mutable - builtin, nothing to do");
480+
return
481+
}
482+
483+
let base_ty = self.tables.borrow().adjustments.get(&base_expr.id)
484+
.map_or_else(|| self.node_ty(expr.id), |adj| adj.target);
485+
let base_ty = self.resolve_type_vars_if_possible(&base_ty);
486+
487+
// Need to deref because overloaded lvalue ops take self by-reference.
488+
let base_ty = base_ty.builtin_deref(false, NoPreference)
489+
.expect("lvalue op takes something that is not a ref")
490+
.ty;
491+
492+
let method = self.try_overloaded_lvalue_op(
493+
expr.span, None, base_ty, arg_tys, PreferMutLvalue, op);
494+
let ok = match method {
495+
Some(method) => method,
496+
None => return self.tcx.sess.delay_span_bug(expr.span, "re-trying op failed")
497+
};
498+
let method = self.register_infer_ok_obligations(ok);
499+
debug!("convert_lvalue_op_to_mutable: method={:?}", method);
500+
self.tables.borrow_mut().method_map.insert(method_call, method);
501+
502+
// Convert the autoref in the base expr to mutable with the correct
503+
// region and mutability.
504+
if let Some(&mut Adjustment {
505+
ref mut target, kind: Adjust::DerefRef {
506+
autoref: Some(AutoBorrow::Ref(ref mut r, ref mut mutbl)), ..
507+
}
508+
}) = self.tables.borrow_mut().adjustments.get_mut(&base_expr.id) {
509+
debug!("convert_lvalue_op_to_mutable: converting autoref of {:?}", target);
510+
511+
// extract method return type, which will be &mut T;
512+
// all LB regions should have been instantiated during method lookup
513+
let method_sig = self.tcx.no_late_bound_regions(&method.ty.fn_sig()).unwrap();
514+
515+
*target = method_sig.inputs()[0];
516+
if let ty::TyRef(r_, mt) = target.sty {
517+
*r = r_;
518+
*mutbl = mt.mutbl;
519+
} else {
520+
span_bug!(expr.span, "input to lvalue op is not a ref?");
521+
}
522+
}
523+
}
524+
567525
///////////////////////////////////////////////////////////////////////////
568526
// MISCELLANY
569527

‎src/librustc_typeck/check/method/mod.rs

+7-27
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@
1010

1111
//! Method lookup: the secret sauce of Rust. See `README.md`.
1212
13-
use check::FnCtxt;
13+
use check::{FnCtxt, AdjustedRcvr};
1414
use hir::def::Def;
1515
use hir::def_id::DefId;
1616
use rustc::ty::subst::Substs;
@@ -153,24 +153,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
153153
supplied_method_types))
154154
}
155155

156-
pub fn lookup_method_in_trait(&self,
157-
span: Span,
158-
self_expr: Option<&hir::Expr>,
159-
m_name: ast::Name,
160-
trait_def_id: DefId,
161-
self_ty: ty::Ty<'tcx>,
162-
opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
163-
-> Option<InferOk<'tcx, ty::MethodCallee<'tcx>>> {
164-
self.lookup_method_in_trait_adjusted(span,
165-
self_expr,
166-
m_name,
167-
trait_def_id,
168-
0,
169-
false,
170-
self_ty,
171-
opt_input_types)
172-
}
173-
174156
/// `lookup_in_trait_adjusted` is used for overloaded operators.
175157
/// It does a very narrow slice of what the normal probe/confirm path does.
176158
/// In particular, it doesn't really do any probing: it simply constructs
@@ -184,18 +166,16 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
184166
/// this method is basically the same as confirmation.
185167
pub fn lookup_method_in_trait_adjusted(&self,
186168
span: Span,
187-
self_expr: Option<&hir::Expr>,
169+
self_info: Option<AdjustedRcvr>,
188170
m_name: ast::Name,
189171
trait_def_id: DefId,
190-
autoderefs: usize,
191-
unsize: bool,
192172
self_ty: ty::Ty<'tcx>,
193173
opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
194174
-> Option<InferOk<'tcx, ty::MethodCallee<'tcx>>> {
195-
debug!("lookup_in_trait_adjusted(self_ty={:?}, self_expr={:?}, \
175+
debug!("lookup_in_trait_adjusted(self_ty={:?}, self_info={:?}, \
196176
m_name={}, trait_def_id={:?})",
197177
self_ty,
198-
self_expr,
178+
self_info,
199179
m_name,
200180
trait_def_id);
201181

@@ -288,10 +268,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
288268
obligations.push(traits::Obligation::new(cause, ty::Predicate::WellFormed(method_ty)));
289269

290270
// Insert any adjustments needed (always an autoref of some mutability).
291-
if let Some(self_expr) = self_expr {
271+
if let Some(AdjustedRcvr { rcvr_expr, autoderefs, unsize }) = self_info {
292272
debug!("lookup_in_trait_adjusted: inserting adjustment if needed \
293273
(self-id={}, autoderefs={}, unsize={}, fty={:?})",
294-
self_expr.id, autoderefs, unsize, original_method_ty);
274+
rcvr_expr.id, autoderefs, unsize, original_method_ty);
295275

296276
let original_sig = original_method_ty.fn_sig();
297277
let autoref = match (&original_sig.input(0).skip_binder().sty,
@@ -308,7 +288,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
308288
}
309289
};
310290

311-
self.apply_adjustment(self_expr.id, Adjustment {
291+
self.apply_adjustment(rcvr_expr.id, Adjustment {
312292
kind: Adjust::DerefRef {
313293
autoderefs: autoderefs,
314294
autoref: autoref,

0 commit comments

Comments
 (0)