nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-22 14:55:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

rustc: keep overloaded autoderef MethodCallee's in Adjust.

Browse Source
This commit is contained in:
Eduard-Mihai Burtescu 2017-05-17 00:54:04 +03:00
parent 9a53c3e904
commit b4988f0792
26 changed files with 513 additions and 700 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/librustc/cfg/construct.rs
View File

@ -412,8 +412,7 @@ impl<'a, 'tcx> CFGBuilder<'a, 'tcx> {
pred: CFGIndex,
func_or_rcvr: &hir::Expr,
args: I) -> CFGIndex {
let method_call = ty::MethodCall::expr(call_expr.id);
let fn_ty = match self.tables.method_map.get(&method_call) {
let fn_ty = match self.tables.method_map.get(&call_expr.id) {
Some(method) => method.ty,
None => self.tables.expr_ty_adjusted(func_or_rcvr),
};

15
src/librustc/ich/impls_ty.rs
View File

@ -102,7 +102,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::Ad
ty::adjustment::Adjust::UnsafeFnPointer |
ty::adjustment::Adjust::ClosureFnPointer |
ty::adjustment::Adjust::MutToConstPointer => {}
ty::adjustment::Adjust::DerefRef { autoderefs, ref autoref, unsize } => {
ty::adjustment::Adjust::DerefRef { ref autoderefs, ref autoref, unsize } => {
autoderefs.hash_stable(hcx, hasher);
autoref.hash_stable(hcx, hasher);
unsize.hash_stable(hcx, hasher);
@ -112,7 +112,6 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::Ad
}
impl_stable_hash_for!(struct ty::adjustment::Adjustment<'tcx> { kind, target });
impl_stable_hash_for!(struct ty::MethodCall { expr_id, autoderef });
impl_stable_hash_for!(struct ty::MethodCallee<'tcx> { def_id, ty, substs });
impl_stable_hash_for!(struct ty::UpvarId { var_id, closure_expr_id });
impl_stable_hash_for!(struct ty::UpvarBorrow<'tcx> { kind, region });
@ -626,17 +625,7 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeckTables<'
ich::hash_stable_nodemap(hcx, hasher, node_types);
ich::hash_stable_nodemap(hcx, hasher, item_substs);
ich::hash_stable_nodemap(hcx, hasher, adjustments);
ich::hash_stable_hashmap(hcx, hasher, method_map, |hcx, method_call| {
let ty::MethodCall {
expr_id,
autoderef
} = *method_call;
let def_id = hcx.tcx().hir.local_def_id(expr_id);
(hcx.def_path_hash(def_id), autoderef)
});
ich::hash_stable_nodemap(hcx, hasher, method_map);
ich::hash_stable_hashmap(hcx, hasher, upvar_capture_map, |hcx, up_var_id| {
let ty::UpvarId {
var_id,

40
src/librustc/infer/mod.rs
View File

@ -564,13 +564,14 @@ impl<'tcx, T> InferOk<'tcx, T> {
}
#[must_use = "once you start a snapshot, you should always consume it"]
pub struct CombinedSnapshot {
pub struct CombinedSnapshot<'a, 'tcx:'a> {
projection_cache_snapshot: traits::ProjectionCacheSnapshot,
type_snapshot: type_variable::Snapshot,
int_snapshot: unify::Snapshot<ty::IntVid>,
float_snapshot: unify::Snapshot<ty::FloatVid>,
region_vars_snapshot: RegionSnapshot,
was_in_snapshot: bool,
_in_progress_tables: Option<Ref<'a, ty::TypeckTables<'tcx>>>,
}
/// Helper trait for shortening the lifetimes inside a
@ -888,7 +889,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
result
}
fn start_snapshot(&self) -> CombinedSnapshot {
fn start_snapshot<'b>(&'b self) -> CombinedSnapshot<'b, 'tcx> {
debug!("start_snapshot()");
let in_snapshot = self.in_snapshot.get();
@ -901,6 +902,12 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
float_snapshot: self.float_unification_table.borrow_mut().snapshot(),
region_vars_snapshot: self.region_vars.start_snapshot(),
was_in_snapshot: in_snapshot,
// Borrow tables "in progress" (i.e. during typeck)
// to ban writes from within a snapshot to them.
_in_progress_tables: match self.tables {
InferTables::InProgress(ref tables) => tables.try_borrow().ok(),
_ => None
}
}
}
@ -911,7 +918,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
int_snapshot,
float_snapshot,
region_vars_snapshot,
was_in_snapshot } = snapshot;
was_in_snapshot,
_in_progress_tables } = snapshot;
self.in_snapshot.set(was_in_snapshot);
@ -938,7 +946,8 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
int_snapshot,
float_snapshot,
region_vars_snapshot,
was_in_snapshot } = snapshot;
was_in_snapshot,
_in_progress_tables } = snapshot;
self.in_snapshot.set(was_in_snapshot);
@ -1645,29 +1654,6 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
!traits::type_known_to_meet_bound(self, ty, copy_def_id, span)
}
pub fn node_method_ty(&self, method_call: ty::MethodCall)
-> Option<Ty<'tcx>> {
self.tables
.borrow()
.method_map
.get(&method_call)
.map(|method| method.ty)
.map(|ty| self.resolve_type_vars_if_possible(&ty))
}
pub fn node_method_id(&self, method_call: ty::MethodCall)
-> Option<DefId> {
self.tables
.borrow()
.method_map
.get(&method_call)
.map(|method| method.def_id)
}
pub fn is_method_call(&self, id: ast::NodeId) -> bool {
self.tables.borrow().method_map.contains_key(&ty::MethodCall::expr(id))
}
pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarCapture<'tcx>> {
self.tables.borrow().upvar_capture_map.get(&upvar_id).cloned()
}

4
src/librustc/middle/dead.rs
View File

@ -95,9 +95,7 @@ impl<'a, 'tcx> MarkSymbolVisitor<'a, 'tcx> {
}
fn lookup_and_handle_method(&mut self, id: ast::NodeId) {
let method_call = ty::MethodCall::expr(id);
let method = self.tables.method_map[&method_call];
self.check_def_id(method.def_id);
self.check_def_id(self.tables.method_map[&id].def_id);
}
fn handle_field_access(&mut self, lhs: &hir::Expr, name: ast::Name) {

4
src/librustc/middle/effect.rs
View File

@ -13,7 +13,6 @@
use self::RootUnsafeContext::*;
use ty::{self, Ty, TyCtxt};
use ty::MethodCall;
use lint;
use syntax::ast;
@ -174,8 +173,7 @@ impl<'a, 'tcx> Visitor<'tcx> for EffectCheckVisitor<'a, 'tcx> {
fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
match expr.node {
hir::ExprMethodCall(..) => {
let method_call = MethodCall::expr(expr.id);
let base_type = self.tables.method_map[&method_call].ty;
let base_type = self.tables.method_map[&expr.id].ty;
debug!("effect: method call case, base type is {:?}",
base_type);
if type_is_unsafe_function(base_type) {

53
src/librustc/middle/expr_use_visitor.rs
View File

@ -563,19 +563,8 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
}
ty::TyError => { }
_ => {
let overloaded_call_type =
match self.mc.infcx.node_method_id(ty::MethodCall::expr(call.id)) {
Some(method_id) => {
OverloadedCallType::from_method_id(self.tcx(), method_id)
}
None => {
span_bug!(
callee.span,
"unexpected callee type {}",
callee_ty)
}
};
match overloaded_call_type {
let method = self.mc.infcx.tables.borrow().method_map[&call.id];
match OverloadedCallType::from_method_id(self.tcx(), method.def_id) {
FnMutOverloadedCall => {
let call_scope_r = self.tcx().node_scope_region(call.id);
self.borrow_expr(callee,
@ -717,7 +706,9 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
fn walk_adjustment(&mut self, expr: &hir::Expr) {
let infcx = self.mc.infcx;
//NOTE(@jroesch): mixed RefCell borrow causes crash
let adj = infcx.tables.borrow().adjustments.get(&expr.id).map(|x| x.clone());
let adj = infcx.tables.borrow().adjustments.get(&expr.id).cloned();
let cmt_unadjusted =
return_if_err!(self.mc.cat_expr_unadjusted(expr));
if let Some(adjustment) = adj {
match adjustment.kind {
adjustment::Adjust::NeverToAny |
@ -728,17 +719,13 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
// Creating a closure/fn-pointer or unsizing consumes
// the input and stores it into the resulting rvalue.
debug!("walk_adjustment: trivial adjustment");
let cmt_unadjusted =
return_if_err!(self.mc.cat_expr_unadjusted(expr));
self.delegate_consume(expr.id, expr.span, cmt_unadjusted);
}
adjustment::Adjust::DerefRef { autoderefs, autoref, unsize } => {
adjustment::Adjust::DerefRef { ref autoderefs, autoref, unsize } => {
debug!("walk_adjustment expr={:?} adj={:?}", expr, adjustment);
self.walk_autoderefs(expr, autoderefs);
let cmt_derefd =
return_if_err!(self.mc.cat_expr_autoderefd(expr, autoderefs));
return_if_err!(self.walk_autoderefs(expr, cmt_unadjusted, autoderefs));
let cmt_refd =
self.walk_autoref(expr, cmt_derefd, autoref);
@ -757,30 +744,30 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
/// `deref()` is declared with `&self`, this is an autoref of `x`.
fn walk_autoderefs(&mut self,
expr: &hir::Expr,
autoderefs: usize) {
debug!("walk_autoderefs expr={:?} autoderefs={}", expr, autoderefs);
for i in 0..autoderefs {
let deref_id = ty::MethodCall::autoderef(expr.id, i as u32);
if let Some(method_ty) = self.mc.infcx.node_method_ty(deref_id) {
let cmt = return_if_err!(self.mc.cat_expr_autoderefd(expr, i));
mut cmt: mc::cmt<'tcx>,
autoderefs: &[Option<ty::MethodCallee<'tcx>>])
-> mc::McResult<mc::cmt<'tcx>> {
debug!("walk_autoderefs expr={:?} autoderefs={:?}", expr, autoderefs);
for &overloaded in autoderefs {
if let Some(method) = overloaded {
// the method call infrastructure should have
// replaced all late-bound regions with variables:
let self_ty = method_ty.fn_sig().input(0);
let self_ty = method.ty.fn_sig().input(0);
let self_ty = self.mc.infcx.resolve_type_vars_if_possible(&self_ty);
let self_ty = self.tcx().no_late_bound_regions(&self_ty).unwrap();
let (m, r) = match self_ty.sty {
ty::TyRef(r, ref m) => (m.mutbl, r),
_ => span_bug!(expr.span,
"bad overloaded deref type {:?}",
method_ty)
_ => span_bug!(expr.span, "bad overloaded deref type {:?}", self_ty)
};
let bk = ty::BorrowKind::from_mutbl(m);
self.delegate.borrow(expr.id, expr.span, cmt,
self.delegate.borrow(expr.id, expr.span, cmt.clone(),
r, bk, AutoRef);
}
cmt = self.mc.cat_deref(expr, cmt, overloaded)?;
}
Ok(cmt)
}
/// Walks the autoref `opt_autoref` applied to the autoderef'd
@ -863,7 +850,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
pass_args: PassArgs)
-> bool
{
if !self.mc.infcx.is_method_call(expr.id) {
if !self.mc.infcx.tables.borrow().is_method_call(expr.id) {
return false;
}

3
src/librustc/middle/liveness.rs
View File

@ -1084,8 +1084,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
}
hir::ExprMethodCall(.., ref args) => {
let method_call = ty::MethodCall::expr(expr.id);
let method_ty = self.tables.method_map[&method_call].ty;
let method_ty = self.tables.method_map[&expr.id].ty;
// FIXME(canndrew): This is_never should really be an is_uninhabited
let succ = if method_ty.fn_ret().0.is_never() {
self.s.exit_ln

87
src/librustc/middle/mem_categorization.rs
View File

@ -480,14 +480,21 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}
Some(adjustment) => {
debug!("cat_expr({:?}): {:?}", adjustment, expr);
match adjustment.kind {
adjustment::Adjust::DerefRef {
autoderefs,
ref autoderefs,
autoref: None,
unsize: false
} => {
// Equivalent to *expr or something similar.
self.cat_expr_autoderefd(expr, autoderefs)
let mut cmt = self.cat_expr_unadjusted(expr)?;
debug!("cat_expr: autoderefs={:?}, cmt={:?}",
autoderefs, cmt);
for &overloaded in autoderefs {
cmt = self.cat_deref(expr, cmt, overloaded)?;
}
return Ok(cmt);
}
adjustment::Adjust::NeverToAny |
@ -496,9 +503,6 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
adjustment::Adjust::ClosureFnPointer |
adjustment::Adjust::MutToConstPointer |
adjustment::Adjust::DerefRef {..} => {
debug!("cat_expr({:?}): {:?}",
adjustment,
expr);
// Result is an rvalue.
let expr_ty = self.expr_ty_adjusted(expr)?;
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
@ -508,20 +512,6 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}
}
pub fn cat_expr_autoderefd(&self,
expr: &hir::Expr,
autoderefs: usize)
-> McResult<cmt<'tcx>> {
let mut cmt = self.cat_expr_unadjusted(expr)?;
debug!("cat_expr_autoderefd: autoderefs={}, cmt={:?}",
autoderefs,
cmt);
for deref in 1..autoderefs + 1 {
cmt = self.cat_deref(expr, cmt, deref)?;
}
return Ok(cmt);
}
pub fn cat_expr_unadjusted(&self, expr: &hir::Expr) -> McResult<cmt<'tcx>> {
debug!("cat_expr: id={} expr={:?}", expr.id, expr);
@ -529,7 +519,9 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
match expr.node {
hir::ExprUnary(hir::UnDeref, ref e_base) => {
let base_cmt = self.cat_expr(&e_base)?;
self.cat_deref(expr, base_cmt, 0)
let method = self.infcx.tables.borrow().method_map
.get(&expr.id).cloned();
self.cat_deref(expr, base_cmt, method)
}
hir::ExprField(ref base, f_name) => {
@ -547,12 +539,12 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}
hir::ExprIndex(ref base, _) => {
let method_call = ty::MethodCall::expr(expr.id());
match self.infcx.node_method_ty(method_call) {
Some(method_ty) => {
let method = self.infcx.tables.borrow().method_map.get(&expr.id()).cloned();
match method {
Some(method) => {
// If this is an index implemented by a method call, then it
// will include an implicit deref of the result.
let ret_ty = self.overloaded_method_return_ty(method_ty);
let ret_ty = self.overloaded_method_return_ty(method);
// The index method always returns an `&T`, so
// dereference it to find the result type.
@ -932,24 +924,16 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ret
}
fn cat_deref<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
deref_cnt: usize)
-> McResult<cmt<'tcx>> {
let method_call = ty::MethodCall {
expr_id: node.id(),
autoderef: deref_cnt as u32
};
let method_ty = self.infcx.node_method_ty(method_call);
pub fn cat_deref<N:ast_node>(&self,
node: &N,
base_cmt: cmt<'tcx>,
overloaded: Option<ty::MethodCallee<'tcx>>)
-> McResult<cmt<'tcx>> {
debug!("cat_deref: overloaded={:?}", overloaded);
debug!("cat_deref: method_call={:?} method_ty={:?}",
method_call, method_ty.map(|ty| ty));
let base_cmt = match method_ty {
Some(method_ty) => {
let ref_ty =
self.tcx().no_late_bound_regions(&method_ty.fn_ret()).unwrap();
let base_cmt = match overloaded {
Some(method) => {
let ref_ty = self.overloaded_method_return_ty(method);
self.cat_rvalue_node(node.id(), node.span(), ref_ty)
}
None => base_cmt
@ -1020,12 +1004,10 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
//! - `elt`: the AST node being indexed
//! - `base_cmt`: the cmt of `elt`
let method_call = ty::MethodCall::expr(elt.id());
let method_ty = self.infcx.node_method_ty(method_call);
let (element_ty, element_kind) = match method_ty {
Some(method_ty) => {
let ref_ty = self.overloaded_method_return_ty(method_ty);
let method = self.infcx.tables.borrow().method_map.get(&elt.id()).cloned();
let (element_ty, element_kind) = match method {
Some(method) => {
let ref_ty = self.overloaded_method_return_ty(method);
base_cmt = self.cat_rvalue_node(elt.id(), elt.span(), ref_ty);
(ref_ty.builtin_deref(false, ty::NoPreference).unwrap().ty,
@ -1234,7 +1216,9 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// box p1, &p1, &mut p1. we can ignore the mutability of
// PatKind::Ref since that information is already contained
// in the type.
let subcmt = self.cat_deref(pat, cmt, 0)?;
let method = self.infcx.tables.borrow().method_map
.get(&pat.id).cloned();
let subcmt = self.cat_deref(pat, cmt, method)?;
self.cat_pattern_(subcmt, &subpat, op)?;
}
@ -1262,7 +1246,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}
fn overloaded_method_return_ty(&self,
method_ty: Ty<'tcx>)
method: ty::MethodCallee<'tcx>)
-> Ty<'tcx>
{
// When we process an overloaded `*` or `[]` etc, we often
@ -1270,8 +1254,9 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// types are generated by method resolution and always have
// all late-bound regions fully instantiated, so we just want
// to skip past the binder.
self.tcx().no_late_bound_regions(&method_ty.fn_ret())
.unwrap()
let ret_ty = method.ty.fn_ret();
let ret_ty = self.infcx.resolve_type_vars_if_possible(&ret_ty);
self.tcx().no_late_bound_regions(&ret_ty).unwrap()
}
}

3
src/librustc/middle/reachable.rs
View File

@ -110,8 +110,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ReachableContext<'a, 'tcx> {
Some(self.tables.qpath_def(qpath, expr.id))
}
hir::ExprMethodCall(..) => {
let method_call = ty::MethodCall::expr(expr.id);
let def_id = self.tables.method_map[&method_call].def_id;
let def_id = self.tables.method_map[&expr.id].def_id;
Some(Def::Method(def_id))
}
_ => None

73
src/librustc/ty/adjustment.rs
View File

@ -9,10 +9,6 @@
// except according to those terms.
use ty::{self, Ty, TyCtxt, TypeAndMut};
use ty::LvaluePreference::{NoPreference};
use syntax::ast;
use syntax_pos::Span;
use hir;
@ -43,10 +39,10 @@ pub enum Adjust<'tcx> {
/// here means either or both of raw vs borrowed vs unique and fat vs thin.
///
/// We transform pointers by following the following steps in order:
/// 1. Deref the pointer `self.autoderefs` times (may be 0).
/// 1. Deref the pointer through `self.autoderefs` steps (may be no steps).
/// 2. If `autoref` is `Some(_)`, then take the address and produce either a
/// `&` or `*` pointer.
/// 3. If `unsize` is `Some(_)`, then apply the unsize transformation,
/// 3. If `unsize` is `true`, then apply the unsize transformation,
/// which will do things like convert thin pointers to fat
/// pointers, or convert structs containing thin pointers to
/// structs containing fat pointers, or convert between fat
@ -61,23 +57,26 @@ pub enum Adjust<'tcx> {
/// 1. The simplest cases are where the pointer is not adjusted fat vs thin.
/// Here the pointer will be dereferenced N times (where a dereference can
/// happen to raw or borrowed pointers or any smart pointer which implements
/// Deref, including Box<_>). The number of dereferences is given by
/// Deref, including Box<_>). The types of dereferences is given by
/// `autoderefs`. It can then be auto-referenced zero or one times, indicated
/// by `autoref`, to either a raw or borrowed pointer. In these cases unsize is
/// None.
/// `false`.
///
/// 2. A thin-to-fat coercon involves unsizing the underlying data. We start
/// with a thin pointer, deref a number of times, unsize the underlying data,
/// then autoref. The 'unsize' phase may change a fixed length array to a
/// dynamically sized one, a concrete object to a trait object, or statically
/// sized struct to a dyncamically sized one. E.g., &[i32; 4] -> &[i32] is
/// sized struct to a dynamically sized one. E.g., &[i32; 4] -> &[i32] is
/// represented by:
///
/// ```
/// Adjust::DerefRef {
/// autoderefs: 1, // &[i32; 4] -> [i32; 4]
/// autoref: Some(AutoBorrow::Ref), // [i32] -> &[i32]
/// unsize: Some([i32]), // [i32; 4] -> [i32]
/// Adjustment {
/// kind: Adjust::DerefRef {
/// autoderefs: vec![None], // &[i32; 4] -> [i32; 4]
/// autoref: Some(AutoBorrow::Ref), // [i32; 4] -> &[i32; 4]
/// unsize: true, // &[i32; 4] -> &[i32]
/// },
/// target: `[i32]`,
/// }
/// ```
///
@ -95,15 +94,18 @@ pub enum Adjust<'tcx> {
/// Box<[i32]> is represented by:
///
/// ```
/// Adjust::DerefRef {
/// autoderefs: 0,
/// autoref: None,
/// unsize: Some(Box<[i32]>),
/// Adjustment {
/// Adjust::DerefRef {
/// autoderefs: vec![],
/// autoref: None,
/// unsize: true,
/// },
/// target: `Box<[i32]>`,
/// }
/// ```
DerefRef {
/// Step 1. Apply a number of dereferences, producing an lvalue.
autoderefs: usize,
autoderefs: Vec<Option<ty::MethodCallee<'tcx>>>,
/// Step 2. Optionally produce a pointer/reference from the value.
autoref: Option<AutoBorrow<'tcx>>,
@ -119,7 +121,11 @@ impl<'tcx> Adjustment<'tcx> {
match self.kind {
Adjust::NeverToAny => self.target.is_never(),
Adjust::DerefRef { autoderefs: 0, autoref: None, unsize: false } => true,
Adjust::DerefRef {
ref autoderefs,
autoref: None,
unsize: false
} if autoderefs.is_empty() => true,
Adjust::ReifyFnPointer |
Adjust::UnsafeFnPointer |
@ -161,35 +167,6 @@ pub enum CustomCoerceUnsized {
}
impl<'a, 'gcx, 'tcx> ty::TyS<'tcx> {
pub fn adjust_for_autoderef<F>(&'tcx self,
tcx: TyCtxt<'a, 'gcx, 'tcx>,
expr_id: ast::NodeId,
expr_span: Span,
autoderef: u32, // how many autoderefs so far?
mut method_type: F)
-> Ty<'tcx> where
F: FnMut(ty::MethodCall) -> Option<Ty<'tcx>>,
{
let method_call = ty::MethodCall::autoderef(expr_id, autoderef);
let mut adjusted_ty = self;
if let Some(method_ty) = method_type(method_call) {
// Method calls always have all late-bound regions
// fully instantiated.
adjusted_ty = tcx.no_late_bound_regions(&method_ty.fn_ret()).unwrap();
}
match adjusted_ty.builtin_deref(true, NoPreference) {
Some(mt) => mt.ty,
None => {
span_bug!(
expr_span,
"the {}th autoderef for {} failed: {}",
autoderef,
expr_id,
adjusted_ty);
}
}
}
pub fn adjust_for_autoref(&'tcx self, tcx: TyCtxt<'a, 'gcx, 'tcx>,
autoref: Option<AutoBorrow<'tcx>>)
-> Ty<'tcx> {

8
src/librustc/ty/context.rs
View File

@ -222,7 +222,7 @@ pub struct TypeckTables<'tcx> {
pub adjustments: NodeMap<ty::adjustment::Adjustment<'tcx>>,
pub method_map: ty::MethodMap<'tcx>,
pub method_map: NodeMap<ty::MethodCallee<'tcx>>,
/// Borrows
pub upvar_capture_map: ty::UpvarCaptureMap<'tcx>,
@ -358,11 +358,7 @@ impl<'tcx> TypeckTables<'tcx> {
}
pub fn is_method_call(&self, expr_id: NodeId) -> bool {
self.method_map.contains_key(&ty::MethodCall::expr(expr_id))
}
pub fn is_overloaded_autoderef(&self, expr_id: NodeId, autoderefs: u32) -> bool {
self.method_map.contains_key(&ty::MethodCall::autoderef(expr_id, autoderefs))
self.method_map.contains_key(&expr_id)
}
pub fn upvar_capture(&self, upvar_id: ty::UpvarId) -> Option<ty::UpvarCapture<'tcx>> {

38
src/librustc/ty/mod.rs
View File

@ -398,44 +398,6 @@ pub struct MethodCallee<'tcx> {
pub substs: &'tcx Substs<'tcx>
}
/// With method calls, we store some extra information in
/// side tables (i.e method_map). We use
/// MethodCall as a key to index into these tables instead of
/// just directly using the expression's NodeId. The reason
/// for this being that we may apply adjustments (coercions)
/// with the resulting expression also needing to use the
/// side tables. The problem with this is that we don't
/// assign a separate NodeId to this new expression
/// and so it would clash with the base expression if both
/// needed to add to the side tables. Thus to disambiguate
/// we also keep track of whether there's an adjustment in
/// our key.
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable)]
pub struct MethodCall {
pub expr_id: NodeId,
pub autoderef: u32
}
impl MethodCall {
pub fn expr(id: NodeId) -> MethodCall {
MethodCall {
expr_id: id,
autoderef: 0
}
}
pub fn autoderef(expr_id: NodeId, autoderef: u32) -> MethodCall {
MethodCall {
expr_id: expr_id,
autoderef: 1 + autoderef
}
}
}
// maps from an expression id that corresponds to a method call to the details
// of the method to be invoked
pub type MethodMap<'tcx> = FxHashMap<MethodCall, MethodCallee<'tcx>>;
// Contains information needed to resolve types and (in the future) look up
// the types of AST nodes.
#[derive(Copy, Clone, PartialEq, Eq, Hash)]

13
src/librustc_lint/builtin.rs
View File

@ -882,19 +882,18 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for UnconditionalRecursion {
use rustc::ty::adjustment::*;
// Check for method calls and overloaded operators.
let opt_m = cx.tables.method_map.get(&ty::MethodCall::expr(id)).cloned();
if let Some(m) = opt_m {
if let Some(m) = cx.tables.method_map.get(&id).cloned() {
if method_call_refers_to_method(cx.tcx, method, m.def_id, m.substs, id) {
return true;
}
}
// Check for overloaded autoderef method calls.
let opt_adj = cx.tables.adjustments.get(&id).cloned();
if let Some(Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) = opt_adj {
for i in 0..autoderefs {
let method_call = ty::MethodCall::autoderef(id, i as u32);
if let Some(m) = cx.tables.method_map.get(&method_call).cloned() {
if let Some(Adjustment {
kind: Adjust::DerefRef { ref autoderefs, .. }, ..
}) = cx.tables.adjustments.get(&id).cloned() {
for &overloaded in autoderefs {
if let Some(m) = overloaded {
if method_call_refers_to_method(cx.tcx, method, m.def_id, m.substs, id) {
return true;
}

95
src/librustc_mir/hair/cx/expr.rs
View File

@ -31,16 +31,16 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
debug!("Expr::make_mirror(): id={}, span={:?}", self.id, self.span);
let mut expr = make_mirror_unadjusted(cx, self);
let adj = cx.tables().adjustments.get(&self.id).cloned();
let adj = cx.tables().adjustments.get(&self.id);
debug!("make_mirror: unadjusted-expr={:?} applying adjustments={:?}",
expr,
adj);
// Now apply adjustments, if any.
match adj.map(|adj| (adj.kind, adj.target)) {
match adj.map(|adj| (&adj.kind, adj.target)) {
None => {}
Some((ty::adjustment::Adjust::ReifyFnPointer, adjusted_ty)) => {
Some((&ty::adjustment::Adjust::ReifyFnPointer, adjusted_ty)) => {
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -49,7 +49,7 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
kind: ExprKind::ReifyFnPointer { source: expr.to_ref() },
};
}
Some((ty::adjustment::Adjust::UnsafeFnPointer, adjusted_ty)) => {
Some((&ty::adjustment::Adjust::UnsafeFnPointer, adjusted_ty)) => {
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -58,7 +58,7 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
kind: ExprKind::UnsafeFnPointer { source: expr.to_ref() },
};
}
Some((ty::adjustment::Adjust::ClosureFnPointer, adjusted_ty)) => {
Some((&ty::adjustment::Adjust::ClosureFnPointer, adjusted_ty)) => {
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -67,7 +67,7 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
kind: ExprKind::ClosureFnPointer { source: expr.to_ref() },
};
}
Some((ty::adjustment::Adjust::NeverToAny, adjusted_ty)) => {
Some((&ty::adjustment::Adjust::NeverToAny, adjusted_ty)) => {
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -76,7 +76,7 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
kind: ExprKind::NeverToAny { source: expr.to_ref() },
};
}
Some((ty::adjustment::Adjust::MutToConstPointer, adjusted_ty)) => {
Some((&ty::adjustment::Adjust::MutToConstPointer, adjusted_ty)) => {
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -85,25 +85,18 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
kind: ExprKind::Cast { source: expr.to_ref() },
};
}
Some((ty::adjustment::Adjust::DerefRef { autoderefs, autoref, unsize },
Some((&ty::adjustment::Adjust::DerefRef { ref autoderefs, autoref, unsize },
adjusted_ty)) => {
for i in 0..autoderefs {
let i = i as u32;
let adjusted_ty =
expr.ty.adjust_for_autoderef(cx.tcx, self.id, self.span, i, |mc| {
cx.tables().method_map.get(&mc).map(|m| m.ty)
});
debug!("make_mirror: autoderef #{}, adjusted_ty={:?}",
i,
adjusted_ty);
let method_key = ty::MethodCall::autoderef(self.id, i);
let meth_ty = cx.tables().method_map.get(&method_key).map(|m| m.ty);
let kind = if let Some(meth_ty) = meth_ty {
debug!("make_mirror: overloaded autoderef (meth_ty={:?})", meth_ty);
for &overloaded in autoderefs {
let mut ref_ty = expr.ty;
let kind = if let Some(method) = overloaded {
debug!("make_mirror: overloaded autoderef (method={:?})", method);
let ref_ty = cx.tcx.no_late_bound_regions(&meth_ty.fn_ret());
let (region, mutbl) = match ref_ty {
Some(&ty::TyS { sty: ty::TyRef(region, mt), .. }) => (region, mt.mutbl),
// Method calls always have all late-bound regions
// fully instantiated.
ref_ty = cx.tcx.no_late_bound_regions(&method.ty.fn_ret()).unwrap();
let (region, mutbl) = match ref_ty.sty {
ty::TyRef(region, mt) => (region, mt.mutbl),
_ => span_bug!(expr.span, "autoderef returned bad type"),
};
@ -125,7 +118,7 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
overloaded_lvalue(cx,
self,
method_key,
method,
PassArgs::ByRef,
expr.to_ref(),
vec![])
@ -133,6 +126,14 @@ impl<'tcx> Mirror<'tcx> for &'tcx hir::Expr {
debug!("make_mirror: built-in autoderef");
ExprKind::Deref { arg: expr.to_ref() }
};
let adjusted_ty = match ref_ty.builtin_deref(true,
ty::LvaluePreference::NoPreference) {
Some(mt) => mt.ty,
None => {
span_bug!(self.span, "autoderef for {} failed: {}", self.id, ref_ty);
}
};
debug!("make_mirror: autoderef adjusted_ty={:?}", adjusted_ty);
expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,
@ -243,7 +244,8 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
// Here comes the interesting stuff:
hir::ExprMethodCall(.., ref args) => {
// Rewrite a.b(c) into UFCS form like Trait::b(a, c)
let expr = method_callee(cx, expr, ty::MethodCall::expr(expr.id));
let method = cx.tables().method_map[&expr.id];
let expr = method_callee(cx, expr, method);
let args = args.iter()
.map(|e| e.to_ref())
.collect();
@ -255,7 +257,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprCall(ref fun, ref args) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
// The callee is something implementing Fn, FnMut, or FnOnce.
// Find the actual method implementation being called and
// build the appropriate UFCS call expression with the
@ -263,7 +265,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
// rewrite f(u, v) into FnOnce::call_once(f, (u, v))
let method = method_callee(cx, expr, ty::MethodCall::expr(expr.id));
let method = method_callee(cx, expr, method);
let sig = method.ty.fn_sig();
@ -352,7 +354,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprAssignOp(op, ref lhs, ref rhs) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
let pass_args = if op.node.is_by_value() {
PassArgs::ByValue
} else {
@ -360,7 +362,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
};
overloaded_operator(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
pass_args,
lhs.to_ref(),
vec![rhs])
@ -376,7 +378,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
hir::ExprLit(..) => ExprKind::Literal { literal: cx.const_eval_literal(expr) },
hir::ExprBinary(op, ref lhs, ref rhs) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
let pass_args = if op.node.is_by_value() {
PassArgs::ByValue
} else {
@ -384,7 +386,7 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
};
overloaded_operator(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
pass_args,
lhs.to_ref(),
vec![rhs])
@ -436,10 +438,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprIndex(ref lhs, ref index) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
overloaded_lvalue(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
PassArgs::ByValue,
lhs.to_ref(),
vec![index])
@ -452,10 +454,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprUnary(hir::UnOp::UnDeref, ref arg) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
overloaded_lvalue(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
PassArgs::ByValue,
arg.to_ref(),
vec![])
@ -465,10 +467,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprUnary(hir::UnOp::UnNot, ref arg) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
overloaded_operator(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
PassArgs::ByValue,
arg.to_ref(),
vec![])
@ -481,10 +483,10 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
hir::ExprUnary(hir::UnOp::UnNeg, ref arg) => {
if cx.tables().is_method_call(expr.id) {
if let Some(&method) = cx.tables().method_map.get(&expr.id) {
overloaded_operator(cx,
expr,
ty::MethodCall::expr(expr.id),
method,
PassArgs::ByValue,
arg.to_ref(),
vec![])
@ -703,9 +705,8 @@ fn make_mirror_unadjusted<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
fn method_callee<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
expr: &hir::Expr,
method_call: ty::MethodCall)
callee: ty::MethodCallee<'tcx>)
-> Expr<'tcx> {
let callee = cx.tables().method_map[&method_call];
let (temp_lifetime, was_shrunk) = cx.region_maps.temporary_scope2(expr.id);
Expr {
temp_lifetime: temp_lifetime,
@ -948,7 +949,7 @@ enum PassArgs {
fn overloaded_operator<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
expr: &'tcx hir::Expr,
method_call: ty::MethodCall,
method: ty::MethodCallee<'tcx>,
pass_args: PassArgs,
receiver: ExprRef<'tcx>,
args: Vec<&'tcx P<hir::Expr>>)
@ -991,7 +992,7 @@ fn overloaded_operator<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
}
// now create the call itself
let fun = method_callee(cx, expr, method_call);
let fun = method_callee(cx, expr, method);
ExprKind::Call {
ty: fun.ty,
fun: fun.to_ref(),
@ -1001,7 +1002,7 @@ fn overloaded_operator<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
fn overloaded_lvalue<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
expr: &'tcx hir::Expr,
method_call: ty::MethodCall,
method: ty::MethodCallee<'tcx>,
pass_args: PassArgs,
receiver: ExprRef<'tcx>,
args: Vec<&'tcx P<hir::Expr>>)
@ -1011,14 +1012,14 @@ fn overloaded_lvalue<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
// line up (this is because `*x` and `x[y]` represent lvalues):
// to find the type &T of the content returned by the method;
let ref_ty = cx.tables().method_map[&method_call].ty.fn_ret();
let ref_ty = method.ty.fn_ret();
let ref_ty = cx.tcx.no_late_bound_regions(&ref_ty).unwrap();
// callees always have all late-bound regions fully instantiated,
// construct the complete expression `foo()` for the overloaded call,
// which will yield the &T type
let (temp_lifetime, was_shrunk) = cx.region_maps.temporary_scope2(expr.id);
let ref_kind = overloaded_operator(cx, expr, method_call, pass_args, receiver, args);
let ref_kind = overloaded_operator(cx, expr, method, pass_args, receiver, args);
let ref_expr = Expr {
temp_lifetime: temp_lifetime,
temp_lifetime_was_shrunk: was_shrunk,

10
src/librustc_passes/consts.rs
View File

@ -280,11 +280,10 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node
_ => {}
}
let method_call = ty::MethodCall::expr(e.id);
match e.node {
hir::ExprUnary(..) |
hir::ExprBinary(..) |
hir::ExprIndex(..) if v.tables.method_map.contains_key(&method_call) => {
hir::ExprIndex(..) if v.tables.method_map.contains_key(&e.id) => {
v.promotable = false;
}
hir::ExprBox(_) => {
@ -381,7 +380,7 @@ fn check_expr<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Expr, node
}
}
hir::ExprMethodCall(..) => {
let method = v.tables.method_map[&method_call];
let method = v.tables.method_map[&e.id];
match v.tcx.associated_item(method.def_id).container {
ty::ImplContainer(_) => v.handle_const_fn_call(method.def_id, node_ty),
ty::TraitContainer(_) => v.promotable = false
@ -450,9 +449,8 @@ fn check_adjustments<'a, 'tcx>(v: &mut CheckCrateVisitor<'a, 'tcx>, e: &hir::Exp
Some(&Adjust::ClosureFnPointer) |
Some(&Adjust::MutToConstPointer) => {}
Some(&Adjust::DerefRef { autoderefs, .. }) => {
if (0..autoderefs as u32)
.any(|autoderef| v.tables.is_overloaded_autoderef(e.id, autoderef)) {
Some(&Adjust::DerefRef { ref autoderefs, .. }) => {
if autoderefs.iter().any(|overloaded| overloaded.is_some()) {
v.promotable = false;
}
}

3
src/librustc_save_analysis/lib.rs
View File

@ -564,8 +564,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> {
}
}
ast::ExprKind::MethodCall(..) => {
let method_call = ty::MethodCall::expr(expr.id);
let method_id = self.tables.method_map[&method_call].def_id;
let method_id = self.tables.method_map[&expr.id].def_id;
let (def_id, decl_id) = match self.tcx.associated_item(method_id).container {
ty::ImplContainer(_) => (Some(method_id), None),
ty::TraitContainer(_) => (None, Some(method_id)),

84
src/librustc_typeck/check/autoderef.rs
View File

@ -12,14 +12,12 @@ use astconv::AstConv;
use super::{FnCtxt, LvalueOp};
use check::coercion::AsCoercionSite;
use rustc::infer::InferOk;
use rustc::traits;
use rustc::ty::{self, Ty, TraitRef};
use rustc::ty::{ToPredicate, TypeFoldable};
use rustc::ty::{MethodCall, MethodCallee};
use rustc::ty::{LvaluePreference, NoPreference};
use rustc::hir;
use rustc::ty::adjustment::AutoBorrow;
use syntax_pos::Span;
use syntax::symbol::Symbol;
@ -149,52 +147,45 @@ impl<'a, 'gcx, 'tcx> Autoderef<'a, 'gcx, 'tcx> {
self.fcx.resolve_type_vars_if_possible(&self.cur_ty)
}
pub fn finalize(self, pref: LvaluePreference, expr: &hir::Expr) {
let fcx = self.fcx;
fcx.register_infer_ok_obligations(self.finalize_as_infer_ok(pref, &[expr]));
pub fn step_count(&self) -> usize {
self.steps.len()
}
pub fn finalize_as_infer_ok<E>(self, pref: LvaluePreference, exprs: &[E])
-> InferOk<'tcx, ()>
where E: AsCoercionSite
{
let Autoderef { fcx, span, mut obligations, steps, .. } = self;
let methods: Vec<_> = steps
.iter()
.map(|&(ty, kind)| {
if let AutoderefKind::Overloaded = kind {
fcx.try_overloaded_deref(span, None, ty, pref)
.map(|InferOk { value, obligations: o }| {
obligations.extend(o);
value
})
} else {
None
}
})
.collect();
/// Returns the steps required in adjustments (overloaded deref calls).
pub fn adjust_steps(&self, pref: LvaluePreference)
-> Vec<Option<ty::MethodCallee<'tcx>>> {
self.fcx.register_infer_ok_obligations(self.adjust_steps_as_infer_ok(pref))
}
debug!("finalize({:?}) - {:?},{:?}",
pref,
methods,
obligations);
for expr in exprs {
let expr = expr.as_coercion_site();
debug!("finalize - finalizing #{} - {:?}", expr.id, expr);
for (n, method) in methods.iter().enumerate() {
if let &Some(method) = method {
let method_call = MethodCall::autoderef(expr.id, n as u32);
fcx.tables.borrow_mut().method_map.insert(method_call, method);
}
pub fn adjust_steps_as_infer_ok(&self, pref: LvaluePreference)
-> InferOk<'tcx, Vec<Option<ty::MethodCallee<'tcx>>>> {
let mut obligations = vec![];
let steps: Vec<_> = self.steps.iter().map(|&(ty, kind)| {
if let AutoderefKind::Overloaded = kind {
self.fcx.try_overloaded_deref(self.span, ty, pref)
.map(|InferOk { value: (_, method), obligations: o }| {
obligations.extend(o);
method
})
} else {
None
}
}
}).collect();
InferOk {
value: (),
obligations
obligations,
value: steps
}
}
pub fn finalize(self) {
let fcx = self.fcx;
fcx.register_predicates(self.into_obligations());
}
pub fn into_obligations(self) -> Vec<traits::PredicateObligation<'tcx>> {
self.obligations
}
}
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
@ -211,14 +202,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
pub fn try_overloaded_deref(&self,
span: Span,
base_expr: Option<&hir::Expr>,
base_ty: Ty<'tcx>,
pref: LvaluePreference)
-> Option<InferOk<'tcx, MethodCallee<'tcx>>> {
let rcvr = base_expr.map(|base_expr| super::AdjustedRcvr {
rcvr_expr: base_expr, autoderefs: 0, unsize: false
});
self.try_overloaded_lvalue_op(span, rcvr, base_ty, &[], pref, LvalueOp::Deref)
-> Option<InferOk<'tcx,
(Option<AutoBorrow<'tcx>>,
ty::MethodCallee<'tcx>)>> {
self.try_overloaded_lvalue_op(span, base_ty, &[], pref, LvalueOp::Deref)
}
}

119
src/librustc_typeck/check/callee.rs
View File

@ -8,13 +8,15 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use super::{DeferredCallResolution, Expectation, FnCtxt, TupleArgumentsFlag};
use super::{Expectation, FnCtxt, TupleArgumentsFlag};
use super::autoderef::Autoderef;
use hir::def::Def;
use hir::def_id::{DefId, LOCAL_CRATE};
use rustc::{infer, traits};
use rustc::ty::{self, TyCtxt, LvaluePreference, Ty};
use rustc::ty::subst::Subst;
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
use syntax::abi;
use syntax::symbol::Symbol;
use syntax_pos::Span;
@ -33,7 +35,7 @@ pub fn check_legal_trait_for_method_call(tcx: TyCtxt, span: Span, trait_id: DefI
}
enum CallStep<'tcx> {
Builtin,
Builtin(Ty<'tcx>),
DeferredClosure(ty::FnSig<'tcx>),
Overloaded(ty::MethodCallee<'tcx>),
}
@ -49,13 +51,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let expr_ty = self.structurally_resolved_type(call_expr.span, original_callee_ty);
let mut autoderef = self.autoderef(callee_expr.span, expr_ty);
let result = autoderef.by_ref()
.flat_map(|(adj_ty, idx)| {
self.try_overloaded_call_step(call_expr, callee_expr, adj_ty, idx)
})
.next();
let callee_ty = autoderef.unambiguous_final_ty();
autoderef.finalize(LvaluePreference::NoPreference, callee_expr);
let mut result = None;
while result.is_none() && autoderef.next().is_some() {
result = self.try_overloaded_call_step(call_expr, callee_expr, &autoderef);
}
autoderef.finalize();
let output = match result {
None => {
@ -63,7 +63,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
self.confirm_builtin_call(call_expr, original_callee_ty, arg_exprs, expected)
}
Some(CallStep::Builtin) => {
Some(CallStep::Builtin(callee_ty)) => {
self.confirm_builtin_call(call_expr, callee_ty, arg_exprs, expected)
}
@ -89,19 +89,19 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn try_overloaded_call_step(&self,
call_expr: &'gcx hir::Expr,
callee_expr: &'gcx hir::Expr,
adjusted_ty: Ty<'tcx>,
autoderefs: usize)
autoderef: &Autoderef<'a, 'gcx, 'tcx>)
-> Option<CallStep<'tcx>> {
debug!("try_overloaded_call_step(call_expr={:?}, adjusted_ty={:?}, autoderefs={})",
let adjusted_ty = autoderef.unambiguous_final_ty();
debug!("try_overloaded_call_step(call_expr={:?}, adjusted_ty={:?})",
call_expr,
adjusted_ty,
autoderefs);
adjusted_ty);
// If the callee is a bare function or a closure, then we're all set.
match self.structurally_resolved_type(callee_expr.span, adjusted_ty).sty {
match adjusted_ty.sty {
ty::TyFnDef(..) | ty::TyFnPtr(_) => {
let autoderefs = autoderef.adjust_steps(LvaluePreference::NoPreference);
self.apply_autoderef_adjustment(callee_expr.id, autoderefs, adjusted_ty);
return Some(CallStep::Builtin);
return Some(CallStep::Builtin(adjusted_ty));
}
ty::TyClosure(def_id, substs) => {
@ -116,15 +116,15 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
infer::FnCall,
&closure_ty)
.0;
self.record_deferred_call_resolution(def_id,
Box::new(CallResolution {
call_expr: call_expr,
callee_expr: callee_expr,
adjusted_ty: adjusted_ty,
autoderefs: autoderefs,
fn_sig: fn_sig.clone(),
closure_def_id: def_id,
}));
let autoderefs = autoderef.adjust_steps(LvaluePreference::NoPreference);
self.record_deferred_call_resolution(def_id, DeferredCallResolution {
call_expr: call_expr,
callee_expr: callee_expr,
adjusted_ty: adjusted_ty,
autoderefs: autoderefs,
fn_sig: fn_sig.clone(),
closure_def_id: def_id,
});
return Some(CallStep::DeferredClosure(fn_sig));
}
}
@ -137,23 +137,32 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// over the top. The simplest fix by far is to just ignore
// this case and deref again, so we wind up with
// `FnMut::call_mut(&mut *x, ())`.
ty::TyRef(..) if autoderefs == 0 => {
ty::TyRef(..) if autoderef.step_count() == 0 => {
return None;
}
_ => {}
}
self.try_overloaded_call_traits(call_expr, callee_expr, adjusted_ty, autoderefs)
.map(|method_callee| CallStep::Overloaded(method_callee))
self.try_overloaded_call_traits(call_expr, adjusted_ty).map(|(autoref, method)| {
let autoderefs = autoderef.adjust_steps(LvaluePreference::NoPreference);
self.apply_adjustment(callee_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs,
autoref,
unsize: false
},
target: *method.ty.fn_sig().input(0).skip_binder()
});
CallStep::Overloaded(method)
})
}
fn try_overloaded_call_traits(&self,
call_expr: &hir::Expr,
callee_expr: &hir::Expr,
adjusted_ty: Ty<'tcx>,
autoderefs: usize)
-> Option<ty::MethodCallee<'tcx>> {
adjusted_ty: Ty<'tcx>)
-> Option<(Option<AutoBorrow<'tcx>>,
ty::MethodCallee<'tcx>)> {
// Try the options that are least restrictive on the caller first.
for &(opt_trait_def_id, method_name) in
&[(self.tcx.lang_items.fn_trait(), Symbol::intern("call")),
@ -165,20 +174,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
};
match self.lookup_method_in_trait_adjusted(call_expr.span,
Some(super::AdjustedRcvr {
rcvr_expr: callee_expr,
autoderefs,
unsize: false
}),
method_name,
trait_def_id,
adjusted_ty,
None) {
None => continue,
Some(ok) => {
let method_callee = self.register_infer_ok_obligations(ok);
return Some(method_callee);
}
Some(ok) => return Some(self.register_infer_ok_obligations(ok))
}
}
@ -313,30 +314,23 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
TupleArgumentsFlag::TupleArguments,
expected);
self.write_overloaded_call_method_map(call_expr, method_callee);
self.tables.borrow_mut().method_map.insert(call_expr.id, method_callee);
output_type
}
fn write_overloaded_call_method_map(&self,
call_expr: &hir::Expr,
method_callee: ty::MethodCallee<'tcx>) {
let method_call = ty::MethodCall::expr(call_expr.id);
self.tables.borrow_mut().method_map.insert(method_call, method_callee);
}
}
#[derive(Debug)]
struct CallResolution<'gcx: 'tcx, 'tcx> {
pub struct DeferredCallResolution<'gcx: 'tcx, 'tcx> {
call_expr: &'gcx hir::Expr,
callee_expr: &'gcx hir::Expr,
adjusted_ty: Ty<'tcx>,
autoderefs: usize,
autoderefs: Vec<Option<ty::MethodCallee<'tcx>>>,
fn_sig: ty::FnSig<'tcx>,
closure_def_id: DefId,
}
impl<'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> for CallResolution<'gcx, 'tcx> {
fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) {
impl<'a, 'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> {
pub fn resolve(self, fcx: &FnCtxt<'a, 'gcx, 'tcx>) {
debug!("DeferredCallResolution::resolve() {:?}", self);
// we should not be invoked until the closure kind has been
@ -345,10 +339,8 @@ impl<'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> for CallResolution<'gcx, 'tc
// We may now know enough to figure out fn vs fnmut etc.
match fcx.try_overloaded_call_traits(self.call_expr,
self.callee_expr,
self.adjusted_ty,
self.autoderefs) {
Some(method_callee) => {
self.adjusted_ty) {
Some((autoref, method_callee)) => {
// One problem is that when we get here, we are going
// to have a newly instantiated function signature
// from the call trait. This has to be reconciled with
@ -370,7 +362,16 @@ impl<'gcx, 'tcx> DeferredCallResolution<'gcx, 'tcx> for CallResolution<'gcx, 'tc
fcx.demand_eqtype(self.call_expr.span, method_sig.output(), self.fn_sig.output());
fcx.write_overloaded_call_method_map(self.call_expr, method_callee);
fcx.apply_adjustment(self.callee_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: self.autoderefs,
autoref,
unsize: false
},
target: method_sig.inputs()[0]
});
fcx.tables.borrow_mut().method_map.insert(self.call_expr.id, method_callee);
}
None => {
span_bug!(self.call_expr.span,

63
src/librustc_typeck/check/coercion.rs
View File

@ -110,7 +110,7 @@ fn coerce_mutbls<'tcx>(from_mutbl: hir::Mutability,
fn identity<'tcx>() -> Adjust<'tcx> {
Adjust::DerefRef {
autoderefs: 0,
autoderefs: vec![],
autoref: None,
unsize: false,
}
@ -157,13 +157,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
})
}
fn coerce<E>(&self,
exprs: &[E],
a: Ty<'tcx>,
b: Ty<'tcx>)
-> CoerceResult<'tcx>
where E: AsCoercionSite
{
fn coerce(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
let a = self.shallow_resolve(a);
debug!("Coerce.tys({:?} => {:?})", a, b);
@ -210,7 +204,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
}
ty::TyRef(r_b, mt_b) => {
return self.coerce_borrowed_pointer(exprs, a, b, r_b, mt_b);
return self.coerce_borrowed_pointer(a, b, r_b, mt_b);
}
_ => {}
@ -245,15 +239,12 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
/// Reborrows `&mut A` to `&mut B` and `&(mut) A` to `&B`.
/// To match `A` with `B`, autoderef will be performed,
/// calling `deref`/`deref_mut` where necessary.
fn coerce_borrowed_pointer<E>(&self,
exprs: &[E],
a: Ty<'tcx>,
b: Ty<'tcx>,
r_b: ty::Region<'tcx>,
mt_b: TypeAndMut<'tcx>)
-> CoerceResult<'tcx>
where E: AsCoercionSite
{
fn coerce_borrowed_pointer(&self,
a: Ty<'tcx>,
b: Ty<'tcx>,
r_b: ty::Region<'tcx>,
mt_b: TypeAndMut<'tcx>)
-> CoerceResult<'tcx> {
debug!("coerce_borrowed_pointer(a={:?}, b={:?})", a, b);
@ -375,7 +366,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
});
match self.unify(derefd_ty_a, b) {
Ok(ok) => {
found = Some((ok, autoderefs));
found = Some(ok);
break;
}
Err(err) => {
@ -391,7 +382,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
// (e.g., in example above, the failure from relating `Vec<T>`
// to the target type), since that should be the least
// confusing.
let (InferOk { value: ty, mut obligations }, autoderefs) = match found {
let InferOk { value: ty, mut obligations } = match found {
Some(d) => d,
None => {
let err = first_error.expect("coerce_borrowed_pointer had no error");
@ -400,7 +391,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
}
};
if ty == a && mt_a.mutbl == hir::MutImmutable && autoderefs == 1 {
if ty == a && mt_a.mutbl == hir::MutImmutable && autoderef.step_count() == 1 {
// As a special case, if we would produce `&'a *x`, that's
// a total no-op. We end up with the type `&'a T` just as
// we started with. In that case, just skip it
@ -423,17 +414,21 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
_ => span_bug!(span, "expected a ref type, got {:?}", ty),
};
let autoref = Some(AutoBorrow::Ref(r_borrow, mt_b.mutbl));
let pref = LvaluePreference::from_mutbl(mt_b.mutbl);
let InferOk { value: autoderefs, obligations: o }
= autoderef.adjust_steps_as_infer_ok(pref);
obligations.extend(o);
obligations.extend(autoderef.into_obligations());
debug!("coerce_borrowed_pointer: succeeded ty={:?} autoderefs={:?} autoref={:?}",
ty,
autoderefs,
autoref);
let pref = LvaluePreference::from_mutbl(mt_b.mutbl);
obligations.extend(autoderef.finalize_as_infer_ok(pref, exprs).obligations);
success(Adjust::DerefRef {
autoderefs: autoderefs,
autoref: autoref,
autoderefs,
autoref,
unsize: false,
}, ty, obligations)
}
@ -477,7 +472,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
let coerce_source = source.adjust_for_autoref(self.tcx, reborrow);
let adjust = Adjust::DerefRef {
autoderefs: if reborrow.is_some() { 1 } else { 0 },
autoderefs: if reborrow.is_some() { vec![None] } else { vec![] },
autoref: reborrow,
unsize: true,
};
@ -668,7 +663,7 @@ impl<'f, 'gcx, 'tcx> Coerce<'f, 'gcx, 'tcx> {
// regionck knows that the region for `a` must be valid here.
self.unify_and(a_unsafe, b, if is_ref {
Adjust::DerefRef {
autoderefs: 1,
autoderefs: vec![None],
autoref: Some(AutoBorrow::RawPtr(mutbl_b)),
unsize: false,
}
@ -703,7 +698,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let cause = self.cause(expr.span, ObligationCauseCode::ExprAssignable);
let coerce = Coerce::new(self, cause);
let ok = self.commit_if_ok(|_| coerce.coerce(&[expr], source, target))?;
let ok = self.commit_if_ok(|_| coerce.coerce(source, target))?;
let adjustment = self.register_infer_ok_obligations(ok);
self.apply_adjustment(expr.id, adjustment);
@ -721,7 +716,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let cause = self.cause(syntax_pos::DUMMY_SP, ObligationCauseCode::ExprAssignable);
let coerce = Coerce::new(self, cause);
self.probe(|_| coerce.coerce::<hir::Expr>(&[], source, target)).is_ok()
self.probe(|_| coerce.coerce(source, target)).is_ok()
}
/// Given some expressions, their known unified type and another expression,
@ -796,7 +791,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// but only if the new expression has no coercion already applied to it.
let mut first_error = None;
if !self.tables.borrow().adjustments.contains_key(&new.id) {
let result = self.commit_if_ok(|_| coerce.coerce(&[new], new_ty, prev_ty));
let result = self.commit_if_ok(|_| coerce.coerce(new_ty, prev_ty));
match result {
Ok(ok) => {
let adjustment = self.register_infer_ok_obligations(ok);
@ -815,10 +810,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let expr = expr.as_coercion_site();
let noop = match self.tables.borrow().adjustments.get(&expr.id).map(|adj| &adj.kind) {
Some(&Adjust::DerefRef {
autoderefs: 1,
ref autoderefs,
autoref: Some(AutoBorrow::Ref(_, mutbl_adj)),
unsize: false
}) => {
}) if autoderefs.len() == 1 => {
match self.node_ty(expr.id).sty {
ty::TyRef(_, mt_orig) => {
// Reborrow that we can safely ignore, because
@ -842,7 +837,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
}
}
match self.commit_if_ok(|_| coerce.coerce(&exprs, prev_ty, new_ty)) {
match self.commit_if_ok(|_| coerce.coerce(prev_ty, new_ty)) {
Err(_) => {
// Avoid giving strange errors on failed attempts.
if let Some(e) = first_error {

42
src/librustc_typeck/check/method/confirm.rs
View File

@ -136,8 +136,10 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
let (autoderefd_ty, n) = autoderef.nth(pick.autoderefs).unwrap();
assert_eq!(n, pick.autoderefs);
let autoderefs = autoderef.adjust_steps(LvaluePreference::NoPreference);
autoderef.unambiguous_final_ty();
autoderef.finalize(LvaluePreference::NoPreference, self.self_expr);
autoderef.finalize();
let target = pick.unsize.unwrap_or(autoderefd_ty);
let target = target.adjust_for_autoref(self.tcx, autoref);
@ -145,8 +147,8 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
// Write out the final adjustment.
self.apply_adjustment(self.self_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: pick.autoderefs,
autoref: autoref,
autoderefs,
autoref,
unsize: pick.unsize.is_some(),
},
target: target
@ -436,19 +438,18 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
// Fix up the autoderefs. Autorefs can only occur immediately preceding
// overloaded lvalue ops, and will be fixed by them in order to get
// the correct region.
let autoderefs = match self.tables.borrow().adjustments.get(&expr.id) {
Some(&Adjustment { kind: Adjust::DerefRef { autoderefs, .. }, .. }) => autoderefs,
Some(_) | None => 0
};
if autoderefs > 0 {
let mut autoderef = self.autoderef(expr.span, self.node_ty(expr.id));
autoderef.nth(autoderefs).unwrap_or_else(|| {
span_bug!(expr.span,
"expr was deref-able {} times but now isn't?",
autoderefs);
});
autoderef.finalize(PreferMutLvalue, expr);
let expr_ty = self.node_ty(expr.id);
if let Some(adj) = self.tables.borrow_mut().adjustments.get_mut(&expr.id) {
if let Adjust::DerefRef { ref mut autoderefs, .. } = adj.kind {
let mut autoderef = self.autoderef(expr.span, expr_ty);
autoderef.nth(autoderefs.len()).unwrap_or_else(|| {
span_bug!(expr.span,
"expr was deref-able as {:?} but now isn't?",
autoderefs);
});
*autoderefs = autoderef.adjust_steps(LvaluePreference::PreferMutLvalue);
autoderef.finalize();
}
}
match expr.node {
@ -474,8 +475,7 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
{
debug!("convert_lvalue_op_to_mutable({:?}, {:?}, {:?}, {:?})",
op, expr, base_expr, arg_tys);
let method_call = ty::MethodCall::expr(expr.id);
if !self.tables.borrow().method_map.contains_key(&method_call) {
if !self.tables.borrow().method_map.contains_key(&expr.id) {
debug!("convert_lvalue_op_to_mutable - builtin, nothing to do");
return
}
@ -490,14 +490,14 @@ impl<'a, 'gcx, 'tcx> ConfirmContext<'a, 'gcx, 'tcx> {
.ty;
let method = self.try_overloaded_lvalue_op(
expr.span, None, base_ty, arg_tys, PreferMutLvalue, op);
expr.span, base_ty, arg_tys, PreferMutLvalue, op);
let ok = match method {
Some(method) => method,
None => return self.tcx.sess.delay_span_bug(expr.span, "re-trying op failed")
};
let method = self.register_infer_ok_obligations(ok);
let (_, method) = self.register_infer_ok_obligations(ok);
debug!("convert_lvalue_op_to_mutable: method={:?}", method);
self.tables.borrow_mut().method_map.insert(method_call, method);
self.tables.borrow_mut().method_map.insert(expr.id, method);
// Convert the autoref in the base expr to mutable with the correct
// region and mutability.

59
src/librustc_typeck/check/method/mod.rs
View File

@ -10,13 +10,13 @@
//! Method lookup: the secret sauce of Rust. See `README.md`.
use check::{FnCtxt, AdjustedRcvr};
use check::FnCtxt;
use hir::def::Def;
use hir::def_id::DefId;
use rustc::ty::subst::Substs;
use rustc::traits;
use rustc::ty::{self, ToPredicate, ToPolyTraitRef, TraitRef, TypeFoldable};
use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow};
use rustc::ty::adjustment::AutoBorrow;
use rustc::ty::subst::Subst;
use rustc::infer::{self, InferOk};
@ -166,16 +166,16 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
/// this method is basically the same as confirmation.
pub fn lookup_method_in_trait_adjusted(&self,
span: Span,
self_info: Option<AdjustedRcvr>,
m_name: ast::Name,
trait_def_id: DefId,
self_ty: ty::Ty<'tcx>,
opt_input_types: Option<Vec<ty::Ty<'tcx>>>)
-> Option<InferOk<'tcx, ty::MethodCallee<'tcx>>> {
debug!("lookup_in_trait_adjusted(self_ty={:?}, self_info={:?}, \
opt_input_types: Option<&[ty::Ty<'tcx>]>)
-> Option<InferOk<'tcx,
(Option<AutoBorrow<'tcx>>,
ty::MethodCallee<'tcx>)>> {
debug!("lookup_in_trait_adjusted(self_ty={:?}, \
m_name={}, trait_def_id={:?})",
self_ty,
self_info,
m_name,
trait_def_id);
@ -237,7 +237,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
value
}
};
let transformed_self_ty = fn_sig.inputs()[0];
let method_ty = tcx.mk_fn_def(def_id, substs, ty::Binder(fn_sig));
debug!("lookup_in_trait_adjusted: matched method method_ty={:?} obligation={:?}",
@ -267,36 +266,18 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// Also add an obligation for the method type being well-formed.
obligations.push(traits::Obligation::new(cause, ty::Predicate::WellFormed(method_ty)));
// Insert any adjustments needed (always an autoref of some mutability).
if let Some(AdjustedRcvr { rcvr_expr, autoderefs, unsize }) = self_info {
debug!("lookup_in_trait_adjusted: inserting adjustment if needed \
(self-id={}, autoderefs={}, unsize={}, fty={:?})",
rcvr_expr.id, autoderefs, unsize, original_method_ty);
let original_sig = original_method_ty.fn_sig();
let autoref = match (&original_sig.input(0).skip_binder().sty,
&transformed_self_ty.sty) {
(&ty::TyRef(..), &ty::TyRef(region, ty::TypeAndMut { mutbl, ty: _ })) => {
// Trait method is fn(&self) or fn(&mut self), need an
// autoref. Pull the region etc out of the type of first argument.
Some(AutoBorrow::Ref(region, mutbl))
}
_ => {
// Trait method is fn(self), no transformation needed.
assert!(!unsize);
None
}
};
self.apply_adjustment(rcvr_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: autoderefs,
autoref: autoref,
unsize: unsize
},
target: transformed_self_ty
});
}
let autoref = match (&original_method_ty.fn_sig().input(0).skip_binder().sty,
&method_ty.fn_sig().input(0).skip_binder().sty) {
(&ty::TyRef(..), &ty::TyRef(region, ty::TypeAndMut { mutbl, ty: _ })) => {
// Trait method is fn(&self) or fn(&mut self), need an
// autoref. Pull the region etc out of the type of first argument.
Some(AutoBorrow::Ref(region, mutbl))
}
_ => {
// Trait method is fn(self), no transformation needed.
None
}
};
let callee = ty::MethodCallee {
def_id: def_id,
@ -308,7 +289,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
Some(InferOk {
obligations,
value: callee
value: (autoref, callee)
})
}

190
src/librustc_typeck/check/mod.rs
View File

@ -77,6 +77,8 @@ type parameter).
*/
pub use self::Expectation::*;
use self::autoderef::Autoderef;
use self::callee::DeferredCallResolution;
use self::coercion::{CoerceMany, DynamicCoerceMany};
pub use self::compare_method::{compare_impl_method, compare_const_impl};
use self::TupleArgumentsFlag::*;
@ -93,7 +95,7 @@ use rustc::ty::subst::{Kind, Subst, Substs};
use rustc::traits::{self, FulfillmentContext, ObligationCause, ObligationCauseCode, Reveal};
use rustc::ty::{ParamTy, LvaluePreference, NoPreference, PreferMutLvalue};
use rustc::ty::{self, Ty, TyCtxt, Visibility};
use rustc::ty::{MethodCall, MethodCallee};
use rustc::ty::{MethodCallee};
use rustc::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
use rustc::ty::fold::{BottomUpFolder, TypeFoldable};
use rustc::ty::maps::Providers;
@ -168,7 +170,7 @@ pub struct Inherited<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
// decision. We keep these deferred resolutions grouped by the
// def-id of the closure, so that once we decide, we can easily go
// back and process them.
deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>>>,
deferred_call_resolutions: RefCell<DefIdMap<Vec<DeferredCallResolution<'gcx, 'tcx>>>>,
deferred_cast_checks: RefCell<Vec<cast::CastCheck<'tcx>>>,
@ -194,12 +196,6 @@ impl<'a, 'gcx, 'tcx> Deref for Inherited<'a, 'gcx, 'tcx> {
}
}
trait DeferredCallResolution<'gcx, 'tcx> {
fn resolve<'a>(&mut self, fcx: &FnCtxt<'a, 'gcx, 'tcx>);
}
type DeferredCallResolutionHandler<'gcx, 'tcx> = Box<DeferredCallResolution<'gcx, 'tcx>+'tcx>;
/// When type-checking an expression, we propagate downward
/// whatever type hint we are able in the form of an `Expectation`.
#[derive(Copy, Clone, Debug)]
@ -375,13 +371,6 @@ pub enum LvalueOp {
Index
}
#[derive(Copy, Clone, Debug)]
pub struct AdjustedRcvr<'a> {
pub rcvr_expr: &'a hir::Expr,
pub autoderefs: usize,
pub unsize: bool
}
/// Tracks whether executing a node may exit normally (versus
/// return/break/panic, which "diverge", leaving dead code in their
/// wake). Tracked semi-automatically (through type variables marked
@ -1729,17 +1718,17 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn record_deferred_call_resolution(&self,
closure_def_id: DefId,
r: DeferredCallResolutionHandler<'gcx, 'tcx>) {
r: DeferredCallResolution<'gcx, 'tcx>) {
let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
deferred_call_resolutions.entry(closure_def_id).or_insert(vec![]).push(r);
}
fn remove_deferred_call_resolutions(&self,
closure_def_id: DefId)
-> Vec<DeferredCallResolutionHandler<'gcx, 'tcx>>
-> Vec<DeferredCallResolution<'gcx, 'tcx>>
{
let mut deferred_call_resolutions = self.deferred_call_resolutions.borrow_mut();
deferred_call_resolutions.remove(&closure_def_id).unwrap_or(Vec::new())
deferred_call_resolutions.remove(&closure_def_id).unwrap_or(vec![])
}
pub fn tag(&self) -> String {
@ -1782,11 +1771,11 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
pub fn apply_autoderef_adjustment(&self,
node_id: ast::NodeId,
derefs: usize,
autoderefs: Vec<Option<ty::MethodCallee<'tcx>>>,
adjusted_ty: Ty<'tcx>) {
self.apply_adjustment(node_id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: derefs,
autoderefs,
autoref: None,
unsize: false
},
@ -1805,18 +1794,19 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
Entry::Vacant(entry) => { entry.insert(adj); },
Entry::Occupied(mut entry) => {
debug!(" - composing on top of {:?}", entry.get());
let composed_kind = match (&entry.get().kind, &adj.kind) {
match (&entry.get().kind, &adj.kind) {
// Applying any adjustment on top of a NeverToAny
// is a valid NeverToAny adjustment, because it can't
// be reached.
(&Adjust::NeverToAny, _) => Adjust::NeverToAny,
(&Adjust::NeverToAny, _) => return,
(&Adjust::DerefRef {
autoderefs: 1,
autoderefs: ref old,
autoref: Some(AutoBorrow::Ref(..)),
unsize: false
}, &Adjust::DerefRef { autoderefs, .. }) if autoderefs > 0 => {
}, &Adjust::DerefRef {
autoderefs: ref new, ..
}) if old.len() == 1 && new.len() >= 1 => {
// A reborrow has no effect before a dereference.
adj.kind
}
// FIXME: currently we never try to compose autoderefs
// and ReifyFnPointer/UnsafeFnPointer, but we could.
@ -1824,10 +1814,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
bug!("while adjusting {}, can't compose {:?} and {:?}",
node_id, entry.get(), adj)
};
*entry.get_mut() = Adjustment {
kind: composed_kind,
target: adj.target
};
*entry.get_mut() = adj;
}
}
}
@ -2189,32 +2176,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// consolidated.
let mut autoderef = self.autoderef(base_expr.span, base_ty);
while let Some((adj_ty, autoderefs)) = autoderef.next() {
if let Some(final_mt) = self.try_index_step(
MethodCall::expr(expr.id), expr, Some(AdjustedRcvr {
rcvr_expr: base_expr,
autoderefs,
unsize: false
}), base_expr.span, adj_ty, lvalue_pref, idx_ty)
{
autoderef.finalize(lvalue_pref, base_expr);
return Some(final_mt);
}
if let ty::TyArray(element_ty, _) = adj_ty.sty {
autoderef.finalize(lvalue_pref, base_expr);
let adj_ty = self.tcx.mk_slice(element_ty);
return self.try_index_step(
MethodCall::expr(expr.id), expr, Some(AdjustedRcvr {
rcvr_expr: base_expr,
autoderefs,
unsize: true
}), base_expr.span, adj_ty, lvalue_pref, idx_ty)
}
let mut result = None;
while result.is_none() && autoderef.next().is_some() {
result = self.try_index_step(expr, base_expr, &autoderef, lvalue_pref, idx_ty);
}
autoderef.unambiguous_final_ty();
None
autoderef.finalize();
result
}
/// To type-check `base_expr[index_expr]`, we progressively autoderef
@ -2223,16 +2190,14 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
/// This loop implements one step in that search; the autoderef loop
/// is implemented by `lookup_indexing`.
fn try_index_step(&self,
method_call: MethodCall,
expr: &hir::Expr,
base_expr: Option<AdjustedRcvr>,
base_span: Span,
adjusted_ty: Ty<'tcx>,
base_expr: &hir::Expr,
autoderef: &Autoderef<'a, 'gcx, 'tcx>,
lvalue_pref: LvaluePreference,
index_ty: Ty<'tcx>)
-> Option<(/*index type*/ Ty<'tcx>, /*element type*/ Ty<'tcx>)>
{
let tcx = self.tcx;
let mut adjusted_ty = autoderef.unambiguous_final_ty();
debug!("try_index_step(expr={:?}, base_expr={:?}, adjusted_ty={:?}, \
index_ty={:?})",
expr,
@ -2240,35 +2205,59 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
adjusted_ty,
index_ty);
let input_ty = self.next_ty_var(TypeVariableOrigin::AutoDeref(base_span));
// First, try built-in indexing.
match (adjusted_ty.builtin_index(), &index_ty.sty) {
(Some(ty), &ty::TyUint(ast::UintTy::Us)) | (Some(ty), &ty::TyInfer(ty::IntVar(_))) => {
debug!("try_index_step: success, using built-in indexing");
// If we had `[T; N]`, we should've caught it before unsizing to `[T]`.
if let Some(base_expr) = base_expr {
assert!(!base_expr.unsize);
self.apply_autoderef_adjustment(
base_expr.rcvr_expr.id, base_expr.autoderefs, adjusted_ty);
}
return Some((tcx.types.usize, ty));
let autoderefs = autoderef.adjust_steps(lvalue_pref);
self.apply_autoderef_adjustment(
base_expr.id, autoderefs, adjusted_ty);
return Some((self.tcx.types.usize, ty));
}
_ => {}
}
// If some lookup succeeds, write callee into table and extract index/element
// type from the method signature.
// If some lookup succeeded, install method in table
let method = self.try_overloaded_lvalue_op(
expr.span, base_expr, adjusted_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
for &unsize in &[false, true] {
if unsize {
// We only unsize arrays here.
if let ty::TyArray(element_ty, _) = adjusted_ty.sty {
adjusted_ty = self.tcx.mk_slice(element_ty);
} else {
continue;
}
}
method.map(|ok| {
debug!("try_index_step: success, using overloaded indexing");
let method = self.register_infer_ok_obligations(ok);
self.tables.borrow_mut().method_map.insert(method_call, method);
(input_ty, self.make_overloaded_lvalue_return_type(method).ty)
})
// If some lookup succeeds, write callee into table and extract index/element
// 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, adjusted_ty, &[input_ty], lvalue_pref, LvalueOp::Index);
let result = method.map(|ok| {
debug!("try_index_step: success, using overloaded indexing");
let (autoref, method) = self.register_infer_ok_obligations(ok);
let autoderefs = autoderef.adjust_steps(lvalue_pref);
self.apply_adjustment(base_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs,
autoref,
unsize
},
target: *method.ty.fn_sig().input(0).skip_binder()
});
self.tables.borrow_mut().method_map.insert(expr.id, method);
(input_ty, self.make_overloaded_lvalue_return_type(method).ty)
});
if result.is_some() {
return result;
}
}
None
}
fn resolve_lvalue_op(&self, op: LvalueOp, is_mut: bool) -> (Option<DefId>, Symbol) {
@ -2287,16 +2276,16 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn try_overloaded_lvalue_op(&self,
span: Span,
base_expr: Option<AdjustedRcvr>,
base_ty: Ty<'tcx>,
arg_tys: &[Ty<'tcx>],
lvalue_pref: LvaluePreference,
op: LvalueOp)
-> Option<InferOk<'tcx, MethodCallee<'tcx>>>
-> Option<InferOk<'tcx,
(Option<AutoBorrow<'tcx>>,
ty::MethodCallee<'tcx>)>>
{
debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?},{:?})",
debug!("try_overloaded_lvalue_op({:?},{:?},{:?},{:?})",
span,
base_expr,
base_ty,
lvalue_pref,
op);
@ -2306,11 +2295,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let method = match (lvalue_pref, mut_tr) {
(PreferMutLvalue, Some(trait_did)) => {
self.lookup_method_in_trait_adjusted(span,
base_expr,
mut_op,
trait_did,
base_ty,
Some(arg_tys.to_owned()))
Some(arg_tys))
}
_ => None,
};
@ -2320,11 +2308,10 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let method = match (method, imm_tr) {
(None, Some(trait_did)) => {
self.lookup_method_in_trait_adjusted(span,
base_expr,
imm_op,
trait_did,
base_ty,
Some(arg_tys.to_owned()))
Some(arg_tys))
}
(method, _) => method,
};
@ -2802,10 +2789,8 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
expr,
rcvr) {
Ok(method) => {
let method_ty = method.ty;
let method_call = MethodCall::expr(expr.id);
self.tables.borrow_mut().method_map.insert(method_call, method);
method_ty
self.tables.borrow_mut().method_map.insert(expr.id, method);
method.ty
}
Err(error) => {
if method_name.node != keywords::Invalid.name() {
@ -2912,7 +2897,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
expr_t);
let mut private_candidate = None;
let mut autoderef = self.autoderef(expr.span, expr_t);
while let Some((base_t, autoderefs)) = autoderef.next() {
while let Some((base_t, _)) = autoderef.next() {
match base_t.sty {
ty::TyAdt(base_def, substs) if !base_def.is_enum() => {
debug!("struct named {:?}", base_t);
@ -2922,8 +2907,9 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
if let Some(field) = fields.iter().find(|f| f.name.to_ident() == ident) {
let field_ty = self.field_ty(expr.span, field, substs);
if field.vis.is_accessible_from(def_scope, self.tcx) {
autoderef.finalize(lvalue_pref, base);
let autoderefs = autoderef.adjust_steps(lvalue_pref);
self.apply_autoderef_adjustment(base.id, autoderefs, base_t);
autoderef.finalize();
self.tcx.check_stability(field.did, expr.id, expr.span);
@ -3020,7 +3006,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let mut private_candidate = None;
let mut tuple_like = false;
let mut autoderef = self.autoderef(expr.span, expr_t);
while let Some((base_t, autoderefs)) = autoderef.next() {
while let Some((base_t, _)) = autoderef.next() {
let field = match base_t.sty {
ty::TyAdt(base_def, substs) if base_def.is_struct() => {
tuple_like = base_def.struct_variant().ctor_kind == CtorKind::Fn;
@ -3055,8 +3041,9 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
};
if let Some(field_ty) = field {
autoderef.finalize(lvalue_pref, base);
let autoderefs = autoderef.adjust_steps(lvalue_pref);
self.apply_autoderef_adjustment(base.id, autoderefs, base_t);
autoderef.finalize();
return field_ty;
}
}
@ -3470,11 +3457,18 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
if let Some(mt) = oprnd_t.builtin_deref(true, NoPreference) {
oprnd_t = mt.ty;
} else if let Some(ok) = self.try_overloaded_deref(
expr.span, Some(&oprnd), oprnd_t, lvalue_pref) {
let method = self.register_infer_ok_obligations(ok);
expr.span, oprnd_t, lvalue_pref) {
let (autoref, method) = self.register_infer_ok_obligations(ok);
self.apply_adjustment(oprnd.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: vec![],
autoref,
unsize: false
},
target: *method.ty.fn_sig().input(0).skip_binder()
});
oprnd_t = self.make_overloaded_lvalue_return_type(method).ty;
self.tables.borrow_mut().method_map.insert(MethodCall::expr(expr.id),
method);
self.tables.borrow_mut().method_map.insert(expr.id, method);
} else {
self.type_error_message(expr.span, |actual| {
format!("type `{}` cannot be \

31
src/librustc_typeck/check/op.rs
View File

@ -14,6 +14,7 @@ use super::FnCtxt;
use hir::def_id::DefId;
use rustc::ty::{Ty, TypeFoldable, PreferMutLvalue, TypeVariants};
use rustc::ty::TypeVariants::{TyStr, TyRef};
use rustc::ty::adjustment::{Adjustment, Adjust};
use rustc::infer::type_variable::TypeVariableOrigin;
use errors;
use syntax::ast;
@ -184,7 +185,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// particularly for things like `String + &String`.
let rhs_ty_var = self.next_ty_var(TypeVariableOrigin::MiscVariable(rhs_expr.span));
let return_ty = self.lookup_op_method(expr, lhs_ty, vec![rhs_ty_var],
let return_ty = self.lookup_op_method(expr, lhs_ty, &[rhs_ty_var],
Symbol::intern(name), trait_def_id,
lhs_expr);
@ -214,7 +215,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
if let TypeVariants::TyRef(_, ref ty_mut) = lhs_ty.sty {
if !self.infcx.type_moves_by_default(ty_mut.ty, lhs_expr.span) &&
self.lookup_op_method(expr, ty_mut.ty, vec![rhs_ty],
self.lookup_op_method(expr, ty_mut.ty, &[rhs_ty],
Symbol::intern(name), trait_def_id,
lhs_expr).is_ok() {
err.note(
@ -313,7 +314,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
{
assert!(op.is_by_value());
let mname = Symbol::intern(mname);
match self.lookup_op_method(ex, operand_ty, vec![], mname, trait_did, operand_expr) {
match self.lookup_op_method(ex, operand_ty, &[], mname, trait_did, operand_expr) {
Ok(t) => t,
Err(()) => {
let actual = self.resolve_type_vars_if_possible(&operand_ty);
@ -382,7 +383,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn lookup_op_method(&self,
expr: &'gcx hir::Expr,
lhs_ty: Ty<'tcx>,
other_tys: Vec<Ty<'tcx>>,
other_tys: &[Ty<'tcx>],
opname: ast::Name,
trait_did: Option<DefId>,
lhs_expr: &'a hir::Expr)
@ -398,11 +399,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let method = match trait_did {
Some(trait_did) => {
let lhs_expr = Some(super::AdjustedRcvr {
rcvr_expr: lhs_expr, autoderefs: 0, unsize: false
});
self.lookup_method_in_trait_adjusted(expr.span,
lhs_expr,
opname,
trait_did,
lhs_ty,
@ -413,18 +410,22 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
match method {
Some(ok) => {
let method = self.register_infer_ok_obligations(ok);
let (autoref, method) = self.register_infer_ok_obligations(ok);
self.select_obligations_where_possible();
let method_ty = method.ty;
// HACK(eddyb) Fully qualified path to work around a resolve bug.
let method_call = ::rustc::ty::MethodCall::expr(expr.id);
self.tables.borrow_mut().method_map.insert(method_call, method);
self.apply_adjustment(lhs_expr.id, Adjustment {
kind: Adjust::DerefRef {
autoderefs: vec![],
autoref,
unsize: false
},
target: *method.ty.fn_sig().input(0).skip_binder()
});
self.tables.borrow_mut().method_map.insert(expr.id, method);
// extract return type for method; all late bound regions
// should have been instantiated by now
let ret_ty = method_ty.fn_ret();
let ret_ty = method.ty.fn_ret();
Ok(self.tcx.no_late_bound_regions(&ret_ty).unwrap())
}
None => {

131
src/librustc_typeck/check/regionck.rs
View File

@ -91,7 +91,7 @@ use middle::region::{CodeExtent, RegionMaps};
use rustc::hir::def_id::DefId;
use rustc::ty::subst::Substs;
use rustc::traits;
use rustc::ty::{self, Ty, MethodCall, TypeFoldable};
use rustc::ty::{self, Ty, TypeFoldable};
use rustc::infer::{self, GenericKind, SubregionOrigin, VerifyBound};
use rustc::ty::adjustment;
use rustc::ty::wf::ImpliedBound;
@ -520,8 +520,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for RegionCtxt<'a, 'gcx, 'tcx> {
self.type_must_outlive(infer::ExprTypeIsNotInScope(expr_ty, expr.span),
expr_ty, expr_region);
let method_call = MethodCall::expr(expr.id);
let opt_method_callee = self.tables.borrow().method_map.get(&method_call).cloned();
let opt_method_callee = self.tables.borrow().method_map.get(&expr.id).cloned();
let has_method_map = opt_method_callee.is_some();
// If we are calling a method (either explicitly or via an
@ -548,11 +547,10 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for RegionCtxt<'a, 'gcx, 'tcx> {
if let Some(adjustment) = adjustment {
debug!("adjustment={:?}", adjustment);
match adjustment.kind {
adjustment::Adjust::DerefRef { autoderefs, ref autoref, .. } => {
let expr_ty = self.resolve_node_type(expr.id);
self.constrain_autoderefs(expr, autoderefs, expr_ty);
adjustment::Adjust::DerefRef { ref autoderefs, ref autoref, .. } => {
let cmt = ignore_err!(self.constrain_autoderefs(expr, autoderefs));
if let Some(ref autoref) = *autoref {
self.link_autoref(expr, autoderefs, autoref);
self.link_autoref(expr, cmt, autoref);
// Require that the resulting region encompasses
// the current node.
@ -690,8 +688,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for RegionCtxt<'a, 'gcx, 'tcx> {
hir::ExprUnary(hir::UnDeref, ref base) => {
// For *a, the lifetime of a must enclose the deref
let method_call = MethodCall::expr(expr.id);
let base_ty = match self.tables.borrow().method_map.get(&method_call) {
let base_ty = match self.tables.borrow().method_map.get(&expr.id) {
Some(method) => {
self.constrain_call(expr, Some(&base),
None::<hir::Expr>.iter(), true);
@ -914,79 +911,68 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
/// dereferenced, the lifetime of the pointer includes the deref expr.
fn constrain_autoderefs(&mut self,
deref_expr: &hir::Expr,
derefs: usize,
mut derefd_ty: Ty<'tcx>)
autoderefs: &[Option<ty::MethodCallee<'tcx>>])
-> mc::McResult<mc::cmt<'tcx>>
{
debug!("constrain_autoderefs(deref_expr={:?}, derefs={}, derefd_ty={:?})",
debug!("constrain_autoderefs(deref_expr={:?}, autoderefs={:?})",
deref_expr,
derefs,
derefd_ty);
autoderefs);
let mut cmt = {
let mc = mc::MemCategorizationContext::new(self, &self.region_maps);
mc.cat_expr_unadjusted(deref_expr)?
};
let r_deref_expr = self.tcx.node_scope_region(deref_expr.id);
for i in 0..derefs {
let method_call = MethodCall::autoderef(deref_expr.id, i as u32);
debug!("constrain_autoderefs: method_call={:?} (of {:?} total)", method_call, derefs);
for &overloaded in autoderefs {
if let Some(method) = overloaded {
debug!("constrain_autoderefs: overloaded, method={:?}", method);
let method = self.tables.borrow().method_map.get(&method_call).map(|m| m.clone());
let origin = infer::ParameterOrigin::OverloadedDeref;
self.substs_wf_in_scope(origin, method.substs, deref_expr.span, r_deref_expr);
derefd_ty = match method {
Some(method) => {
debug!("constrain_autoderefs: #{} is overloaded, method={:?}",
i, method);
let origin = infer::ParameterOrigin::OverloadedDeref;
self.substs_wf_in_scope(origin, method.substs, deref_expr.span, r_deref_expr);
// Treat overloaded autoderefs as if an AutoBorrow adjustment
// was applied on the base type, as that is always the case.
let fn_sig = method.ty.fn_sig();
let fn_sig = // late-bound regions should have been instantiated
self.tcx.no_late_bound_regions(&fn_sig).unwrap();
let self_ty = fn_sig.inputs()[0];
let (m, r) = match self_ty.sty {
ty::TyRef(r, ref m) => (m.mutbl, r),
_ => {
span_bug!(
deref_expr.span,
"bad overloaded deref type {:?}",
method.ty)
}
};
debug!("constrain_autoderefs: receiver r={:?} m={:?}",
r, m);
{
let mc = mc::MemCategorizationContext::new(self, &self.region_maps);
let self_cmt = ignore_err!(mc.cat_expr_autoderefd(deref_expr, i));
debug!("constrain_autoderefs: self_cmt={:?}",
self_cmt);
self.link_region(deref_expr.span, r,
ty::BorrowKind::from_mutbl(m), self_cmt);
// Treat overloaded autoderefs as if an AutoBorrow adjustment
// was applied on the base type, as that is always the case.
let fn_sig = method.ty.fn_sig();
let fn_sig = // late-bound regions should have been instantiated
self.tcx.no_late_bound_regions(&fn_sig).unwrap();
let self_ty = fn_sig.inputs()[0];
let (m, r) = match self_ty.sty {
ty::TyRef(r, ref m) => (m.mutbl, r),
_ => {
span_bug!(
deref_expr.span,
"bad overloaded deref type {:?}",
method.ty)
}
};
// Specialized version of constrain_call.
self.type_must_outlive(infer::CallRcvr(deref_expr.span),
self_ty, r_deref_expr);
self.type_must_outlive(infer::CallReturn(deref_expr.span),
fn_sig.output(), r_deref_expr);
fn_sig.output()
}
None => derefd_ty
};
debug!("constrain_autoderefs: receiver r={:?} m={:?}",
r, m);
if let ty::TyRef(r_ptr, _) = derefd_ty.sty {
debug!("constrain_autoderefs: self_cmt={:?}", cmt);
self.link_region(deref_expr.span, r,
ty::BorrowKind::from_mutbl(m), cmt.clone());
// Specialized version of constrain_call.
self.type_must_outlive(infer::CallRcvr(deref_expr.span),
self_ty, r_deref_expr);
self.type_must_outlive(infer::CallReturn(deref_expr.span),
fn_sig.output(), r_deref_expr);
}
{
let mc = mc::MemCategorizationContext::new(self, &self.region_maps);
cmt = mc.cat_deref(deref_expr, cmt, overloaded)?;
}
if let Categorization::Deref(_, mc::BorrowedPtr(_, r_ptr)) = cmt.cat {
self.mk_subregion_due_to_dereference(deref_expr.span,
r_deref_expr, r_ptr);
}
match derefd_ty.builtin_deref(true, ty::NoPreference) {
Some(mt) => derefd_ty = mt.ty,
/* if this type can't be dereferenced, then there's already an error
in the session saying so. Just bail out for now */
None => break
}
}
Ok(cmt)
}
pub fn mk_subregion_due_to_dereference(&mut self,
@ -1151,13 +1137,10 @@ impl<'a, 'gcx, 'tcx> RegionCtxt<'a, 'gcx, 'tcx> {
/// autoref'd.
fn link_autoref(&self,
expr: &hir::Expr,
autoderefs: usize,
expr_cmt: mc::cmt<'tcx>,
autoref: &adjustment::AutoBorrow<'tcx>)
{
debug!("link_autoref(autoderefs={}, autoref={:?})", autoderefs, autoref);
let mc = mc::MemCategorizationContext::new(self, &self.region_maps);
let expr_cmt = ignore_err!(mc.cat_expr_autoderefd(expr, autoderefs));
debug!("expr_cmt={:?}", expr_cmt);
debug!("link_autoref(autoref={:?}, expr_cmt={:?})", autoref, expr_cmt);
match *autoref {
adjustment::AutoBorrow::Ref(r, m) => {

4
src/librustc_typeck/check/upvar.rs
View File

@ -216,9 +216,9 @@ impl<'a, 'gcx, 'tcx> AdjustBorrowKind<'a, 'gcx, 'tcx> {
let closure_def_id = self.fcx.tcx.hir.local_def_id(id);
debug!("closure_kind({:?}) = {:?}", closure_def_id, kind);
let mut deferred_call_resolutions =
let deferred_call_resolutions =
self.fcx.remove_deferred_call_resolutions(closure_def_id);
for deferred_call_resolution in &mut deferred_call_resolutions {
for deferred_call_resolution in deferred_call_resolutions {
deferred_call_resolution.resolve(self.fcx);
}
}

38
src/librustc_typeck/check/writeback.rs
View File

@ -16,7 +16,7 @@ use check::FnCtxt;
use rustc::hir;
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::infer::{InferCtxt};
use rustc::ty::{self, Ty, TyCtxt, MethodCall, MethodCallee};
use rustc::ty::{self, Ty, TyCtxt, MethodCallee};
use rustc::ty::adjustment;
use rustc::ty::fold::{TypeFolder,TypeFoldable};
use rustc::util::nodemap::DefIdSet;
@ -106,7 +106,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
let inner_ty = self.fcx.resolve_type_vars_if_possible(&inner_ty);
if inner_ty.is_scalar() {
self.fcx.tables.borrow_mut().method_map.remove(&MethodCall::expr(e.id));
self.fcx.tables.borrow_mut().method_map.remove(&e.id);
}
}
hir::ExprBinary(ref op, ref lhs, ref rhs) |
@ -118,7 +118,7 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
let rhs_ty = self.fcx.resolve_type_vars_if_possible(&rhs_ty);
if lhs_ty.is_scalar() && rhs_ty.is_scalar() {
self.fcx.tables.borrow_mut().method_map.remove(&MethodCall::expr(e.id));
self.fcx.tables.borrow_mut().method_map.remove(&e.id);
// weird but true: the by-ref binops put an
// adjustment on the lhs but not the rhs; the
@ -164,7 +164,7 @@ impl<'cx, 'gcx, 'tcx> Visitor<'gcx> for WritebackCx<'cx, 'gcx, 'tcx> {
self.fix_scalar_builtin_expr(e);
self.visit_node_id(e.span, e.id);
self.visit_method_map_entry(e.span, MethodCall::expr(e.id));
self.visit_method_map_entry(e.span, e.id);
if let hir::ExprClosure(_, _, body, _) = e.node {
let body = self.fcx.tcx.hir.body(body);
@ -335,13 +335,16 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
}
adjustment::Adjust::DerefRef { autoderefs, autoref, unsize } => {
for autoderef in 0..autoderefs {
let method_call = MethodCall::autoderef(node_id, autoderef as u32);
self.visit_method_map_entry(span, method_call);
}
adjustment::Adjust::DerefRef {
autoderefs: autoderefs,
autoderefs: autoderefs.iter().map(|overloaded| {
overloaded.map(|method| {
MethodCallee {
def_id: method.def_id,
ty: self.resolve(&method.ty, &span),
substs: self.resolve(&method.substs, &span),
}
})
}).collect(),
autoref: self.resolve(&autoref, &span),
unsize: unsize,
}
@ -359,27 +362,22 @@ impl<'cx, 'gcx, 'tcx> WritebackCx<'cx, 'gcx, 'tcx> {
fn visit_method_map_entry(&mut self,
method_span: Span,
method_call: MethodCall) {
node_id: ast::NodeId) {
// Resolve any method map entry
let new_method = match self.fcx.tables.borrow_mut().method_map.remove(&method_call) {
let new_method = match self.fcx.tables.borrow_mut().method_map.remove(&node_id) {
Some(method) => {
debug!("writeback::resolve_method_map_entry(call={:?}, entry={:?})",
method_call,
method);
let new_method = MethodCallee {
Some(MethodCallee {
def_id: method.def_id,
ty: self.resolve(&method.ty, &method_span),
substs: self.resolve(&method.substs, &method_span),
};
Some(new_method)
})
}
None => None
};
//NB(jroesch): We need to match twice to avoid a double borrow which would cause an ICE
if let Some(method) = new_method {
self.tables.method_map.insert(method_call, method);
self.tables.method_map.insert(node_id, method);
}
}