assert_eq!(n, pick.autoderefs);
autoderef.unambiguous_final_ty();
- autoderef.finalize(LvaluePreference::NoPreference, Some(self.self_expr));
+ autoderef.finalize(LvaluePreference::NoPreference, &[self.self_expr]);
let target = pick.unsize.unwrap_or(autoderefd_ty);
let target = target.adjust_for_autoref(self.tcx, autoref);
// Write out the final adjustment.
- self.write_adjustment(self.self_expr.id, Adjustment {
+ self.apply_adjustment(self.self_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: pick.autoderefs,
autoref: autoref,
for (i, &expr) in exprs.iter().rev().enumerate() {
debug!("convert_lvalue_derefs_to_mutable: i={} expr={:?}", i, expr);
- // Count autoderefs.
+ // Count autoderefs. We don't need to fix up the autoref - the parent
+ // expression will fix them up for us.
let adjustment = self.tables.borrow().adjustments.get(&expr.id).cloned();
match adjustment {
Some(Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) => {
"expr was deref-able {} times but now isn't?",
autoderefs);
});
- autoderef.finalize(PreferMutLvalue, Some(expr));
+ autoderef.finalize(PreferMutLvalue, &[expr]);
}
}
Some(_) | None => {}
// expects. This is annoying and horrible. We
// ought to recode this routine so it doesn't
// (ab)use the normal type checking paths.
- let adj = self.tables.borrow().adjustments.get(&base_expr.id).cloned();
+ let adj = self.tables.borrow_mut().adjustments.remove(&base_expr.id);
let (autoderefs, unsize, adjusted_base_ty) = match adj {
Some(Adjustment {
kind: Adjust::DerefRef { autoderefs, autoref, unsize },
// a preference for mut
let method_call = ty::MethodCall::expr(expr.id);
if self.tables.borrow().method_map.contains_key(&method_call) {
+ self.tables.borrow_mut().adjustments.remove(&base_expr.id);
let method = self.try_overloaded_deref(expr.span,
Some(&base_expr),
self.node_ty(base_expr.id),