Implement vtable and cross-crate support for autoderef.

src/librustc/middle/astencode.rs

@@ -581,41 +581,48 @@ impl tr for moves::CaptureVar {
 // Encoding and decoding of MethodCallee
 
 trait read_method_callee_helper {
-    fn read_method_callee(&mut self, xcx: &ExtendedDecodeContext) -> MethodCallee;
+    fn read_method_callee(&mut self, xcx: &ExtendedDecodeContext) -> (u32, MethodCallee);
 }
 
 fn encode_method_callee(ecx: &e::EncodeContext,
                         ebml_w: &mut writer::Encoder,
+                        autoderef: u32,
                         method: &MethodCallee) {
-    ebml_w.emit_struct("MethodCallee", 3, |ebml_w| {
-        ebml_w.emit_struct_field("origin", 0u, |ebml_w| {
+    ebml_w.emit_struct("MethodCallee", 4, |ebml_w| {
+        ebml_w.emit_struct_field("autoderef", 0u, |ebml_w| {
+            autoderef.encode(ebml_w);
+        });
+        ebml_w.emit_struct_field("origin", 1u, |ebml_w| {
             method.origin.encode(ebml_w);
         });
-        ebml_w.emit_struct_field("ty", 1u, |ebml_w| {
+        ebml_w.emit_struct_field("ty", 2u, |ebml_w| {
             ebml_w.emit_ty(ecx, method.ty);
         });
-        ebml_w.emit_struct_field("substs", 2u, |ebml_w| {
+        ebml_w.emit_struct_field("substs", 3u, |ebml_w| {
             ebml_w.emit_substs(ecx, &method.substs);
         });
     })
 }
 
 impl<'a> read_method_callee_helper for reader::Decoder<'a> {
-    fn read_method_callee(&mut self, xcx: &ExtendedDecodeContext) -> MethodCallee {
-        self.read_struct("MethodCallee", 3, |this| {
-            MethodCallee {
-                origin: this.read_struct_field("origin", 0, |this| {
+    fn read_method_callee(&mut self, xcx: &ExtendedDecodeContext) -> (u32, MethodCallee) {
+        self.read_struct("MethodCallee", 4, |this| {
+            let autoderef = this.read_struct_field("autoderef", 0, |this| {
+                Decodable::decode(this)
+            });
+            (autoderef, MethodCallee {
+                origin: this.read_struct_field("origin", 1, |this| {
                     let method_origin: MethodOrigin =
                         Decodable::decode(this);
                     method_origin.tr(xcx)
                 }),
-                ty: this.read_struct_field("ty", 1, |this| {
+                ty: this.read_struct_field("ty", 2, |this| {
                     this.read_ty(xcx)
                 }),
-                substs: this.read_struct_field("substs", 2, |this| {
+                substs: this.read_struct_field("substs", 3, |this| {
                     this.read_substs(xcx)
                 })
-            }
+            })
         })
     }
 }
@@ -647,6 +654,20 @@ impl tr for MethodOrigin {
 // ______________________________________________________________________
 // Encoding and decoding vtable_res
 
+fn encode_vtable_res_with_key(ecx: &e::EncodeContext,
+                              ebml_w: &mut writer::Encoder,
+                              autoderef: u32,
+                              dr: typeck::vtable_res) {
+    ebml_w.emit_struct("VtableWithKey", 2, |ebml_w| {
+        ebml_w.emit_struct_field("autoderef", 0u, |ebml_w| {
+            autoderef.encode(ebml_w);
+        });
+        ebml_w.emit_struct_field("vtable_res", 1u, |ebml_w| {
+            encode_vtable_res(ecx, ebml_w, dr);
+        });
+    })
+}
+
 pub fn encode_vtable_res(ecx: &e::EncodeContext,
                      ebml_w: &mut writer::Encoder,
                      dr: typeck::vtable_res) {
@@ -701,6 +722,10 @@ pub fn encode_vtable_origin(ecx: &e::EncodeContext,
 }
 
 pub trait vtable_decoder_helpers {
+    fn read_vtable_res_with_key(&mut self,
+                                tcx: &ty::ctxt,
+                                cdata: @cstore::crate_metadata)
+                                -> (u32, typeck::vtable_res);
     fn read_vtable_res(&mut self,
                        tcx: &ty::ctxt, cdata: @cstore::crate_metadata)
                       -> typeck::vtable_res;
@@ -713,6 +738,20 @@ pub trait vtable_decoder_helpers {
 }
 
 impl<'a> vtable_decoder_helpers for reader::Decoder<'a> {
+    fn read_vtable_res_with_key(&mut self,
+                                tcx: &ty::ctxt,
+                                cdata: @cstore::crate_metadata)
+                                -> (u32, typeck::vtable_res) {
+        self.read_struct("VtableWithKey", 2, |this| {
+            let autoderef = this.read_struct_field("autoderef", 0, |this| {
+                Decodable::decode(this)
+            });
+            (autoderef, this.read_struct_field("vtable_res", 1, |this| {
+                this.read_vtable_res(tcx, cdata)
+            }))
+        })
+    }
+
     fn read_vtable_res(&mut self,
                        tcx: &ty::ctxt, cdata: @cstore::crate_metadata)
                       -> typeck::vtable_res {
@@ -1018,21 +1057,48 @@ fn encode_side_tables_for_id(ecx: &e::EncodeContext,
         ebml_w.tag(c::tag_table_method_map, |ebml_w| {
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val, |ebml_w| {
-                encode_method_callee(ecx, ebml_w, method)
+                encode_method_callee(ecx, ebml_w, method_call.autoderef, method)
             })
         })
     }
 
-    for &dr in maps.vtable_map.borrow().find(&id).iter() {
+    for &dr in maps.vtable_map.borrow().find(&method_call).iter() {
         ebml_w.tag(c::tag_table_vtable_map, |ebml_w| {
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val, |ebml_w| {
-                encode_vtable_res(ecx, ebml_w, *dr);
+                encode_vtable_res_with_key(ecx, ebml_w, method_call.autoderef, *dr);
             })
         })
     }
 
     for adj in tcx.adjustments.borrow().find(&id).iter() {
+        match ***adj {
+            ty::AutoDerefRef(adj) => {
+                for autoderef in range(0, adj.autoderefs) {
+                    let method_call = MethodCall::autoderef(id, autoderef as u32);
+                    for &method in maps.method_map.borrow().find(&method_call).iter() {
+                        ebml_w.tag(c::tag_table_method_map, |ebml_w| {
+                            ebml_w.id(id);
+                            ebml_w.tag(c::tag_table_val, |ebml_w| {
+                                encode_method_callee(ecx, ebml_w, method_call.autoderef, method)
+                            })
+                        })
+                    }
+
+                    for &dr in maps.vtable_map.borrow().find(&method_call).iter() {
+                        ebml_w.tag(c::tag_table_vtable_map, |ebml_w| {
+                            ebml_w.id(id);
+                            ebml_w.tag(c::tag_table_val, |ebml_w| {
+                                encode_vtable_res_with_key(ecx, ebml_w,
+                                                           method_call.autoderef, *dr);
+                            })
+                        })
+                    }
+                }
+            }
+            _ => {}
+        }
+
         ebml_w.tag(c::tag_table_adjustments, |ebml_w| {
             ebml_w.id(id);
             ebml_w.tag(c::tag_table_val, |ebml_w| {
@@ -1336,15 +1402,22 @@ fn decode_side_tables(xcx: &ExtendedDecodeContext,
                         dcx.tcx.ty_param_defs.borrow_mut().insert(id, bounds);
                     }
                     c::tag_table_method_map => {
-                        let method = val_dsr.read_method_callee(xcx);
-                        let method_call = MethodCall::expr(id);
+                        let (autoderef, method) = val_dsr.read_method_callee(xcx);
+                        let method_call = MethodCall {
+                            expr_id: id,
+                            autoderef: autoderef
+                        };
                         dcx.maps.method_map.borrow_mut().insert(method_call, method);
                     }
                     c::tag_table_vtable_map => {
-                        let vtable_res =
-                            val_dsr.read_vtable_res(xcx.dcx.tcx,
-                                                    xcx.dcx.cdata);
-                        dcx.maps.vtable_map.borrow_mut().insert(id, vtable_res);
+                        let (autoderef, vtable_res) =
+                            val_dsr.read_vtable_res_with_key(xcx.dcx.tcx,
+                                                             xcx.dcx.cdata);
+                        let vtable_key = MethodCall {
+                            expr_id: id,
+                            autoderef: autoderef
+                        };
+                        dcx.maps.vtable_map.borrow_mut().insert(vtable_key, vtable_res);
                     }
                     c::tag_table_adjustments => {
                         let adj: @ty::AutoAdjustment = @val_dsr.read_auto_adjustment(xcx);

src/librustc/middle/const_eval.rs

@@ -129,7 +129,7 @@ pub fn lookup_variant_by_id(tcx: &ty::ctxt,
         let maps = astencode::Maps {
             root_map: @RefCell::new(HashMap::new()),
             method_map: @RefCell::new(FnvHashMap::new()),
-            vtable_map: @RefCell::new(NodeMap::new()),
+            vtable_map: @RefCell::new(FnvHashMap::new()),
             capture_map: RefCell::new(NodeMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, enum_def,
@@ -170,7 +170,7 @@ pub fn lookup_const_by_id(tcx: &ty::ctxt, def_id: ast::DefId)
         let maps = astencode::Maps {
             root_map: @RefCell::new(HashMap::new()),
             method_map: @RefCell::new(FnvHashMap::new()),
-            vtable_map: @RefCell::new(NodeMap::new()),
+            vtable_map: @RefCell::new(FnvHashMap::new()),
             capture_map: RefCell::new(NodeMap::new())
         };
         let e = match csearch::maybe_get_item_ast(tcx, def_id,

src/librustc/middle/trans/callee.rs

@@ -170,16 +170,11 @@ pub fn trans_fn_ref(bcx: &Block, def_id: ast::DefId, node: ExprOrMethodCall) ->
     let _icx = push_ctxt("trans_fn_ref");
 
     let type_params = node_id_type_params(bcx, node);
-    let vtables = match node {
-        ExprId(id) => node_vtables(bcx, id),
-        MethodCall(ref method_call) => {
-            if method_call.autoderef == 0 {
-                node_vtables(bcx, method_call.expr_id)
-            } else {
-                None
-            }
-        }
+    let vtable_key = match node {
+        ExprId(id) => MethodCall::expr(id),
+        MethodCall(method_call) => method_call
     };
+    let vtables = node_vtables(bcx, vtable_key);
     debug!("trans_fn_ref(def_id={}, node={:?}, type_params={}, vtables={})",
            def_id.repr(bcx.tcx()), node, type_params.repr(bcx.tcx()),
            vtables.repr(bcx.tcx()));

src/librustc/middle/trans/common.rs

@@ -829,7 +829,7 @@ pub fn node_id_type_params(bcx: &Block, node: ExprOrMethodCall) -> Vec<ty::t> {
     }
 }
 
-pub fn node_vtables(bcx: &Block, id: ast::NodeId)
+pub fn node_vtables(bcx: &Block, id: typeck::MethodCall)
                  -> Option<typeck::vtable_res> {
     let vtable_map = bcx.ccx().maps.vtable_map.borrow();
     let raw_vtables = vtable_map.find(&id);

src/librustc/middle/trans/meth.rs

@@ -208,7 +208,8 @@ pub fn trans_static_method_callee(bcx: &Block,
     debug!("trans_static_method_callee: method_id={:?}, expr_id={:?}, \
             name={}", method_id, expr_id, token::get_name(mname));
 
-    let vtbls = ccx.maps.vtable_map.borrow().get_copy(&expr_id);
+    let vtable_key = MethodCall::expr(expr_id);
+    let vtbls = ccx.maps.vtable_map.borrow().get_copy(&vtable_key);
     let vtbls = resolve_vtables_in_fn_ctxt(bcx.fcx, vtbls);
 
     match vtbls.get(bound_index).get(0) {
@@ -327,16 +328,11 @@ fn combine_impl_and_methods_tps(bcx: &Block,
 
     // Now, do the same work for the vtables.  The vtables might not
     // exist, in which case we need to make them.
-    let vtables = match node {
-        ExprId(id) => node_vtables(bcx, id),
-        MethodCall(method_call) => {
-            if method_call.autoderef == 0 {
-                node_vtables(bcx, method_call.expr_id)
-            } else {
-                None
-            }
-        }
+    let vtable_key = match node {
+        ExprId(id) => MethodCall::expr(id),
+        MethodCall(method_call) => method_call
     };
+    let vtables = node_vtables(bcx, vtable_key);
     let r_m_origins = match vtables {
         Some(vt) => vt,
         None => @Vec::from_elem(node_substs.len(), @Vec::new())
@@ -597,10 +593,8 @@ pub fn trans_trait_cast<'a>(bcx: &'a Block<'a>,
     bcx = datum.store_to(bcx, llboxdest);
 
     // Store the vtable into the second half of pair.
-    // This is structured a bit funny because of dynamic borrow failures.
-    let res = *ccx.maps.vtable_map.borrow().get(&id);
-    let res = resolve_vtables_in_fn_ctxt(bcx.fcx, res);
-    let origins = *res.get(0);
+    let res = *ccx.maps.vtable_map.borrow().get(&MethodCall::expr(id));
+    let origins = *resolve_vtables_in_fn_ctxt(bcx.fcx, res).get(0);
     let vtable = get_vtable(bcx, v_ty, origins);
     let llvtabledest = GEPi(bcx, lldest, [0u, abi::trt_field_vtable]);
     let llvtabledest = PointerCast(bcx, llvtabledest, val_ty(vtable).ptr_to());

src/librustc/middle/typeck/check/mod.rs

@@ -267,7 +267,7 @@ impl<'a> Inherited<'a> {
             node_type_substs: RefCell::new(NodeMap::new()),
             adjustments: RefCell::new(NodeMap::new()),
             method_map: @RefCell::new(FnvHashMap::new()),
-            vtable_map: @RefCell::new(NodeMap::new()),
+            vtable_map: @RefCell::new(FnvHashMap::new()),
             upvar_borrow_map: RefCell::new(HashMap::new()),
         }
     }

src/librustc/middle/typeck/check/vtable.rs

@@ -516,10 +516,10 @@ fn connect_trait_tps(vcx: &VtableContext,
     relate_trait_refs(vcx, span, impl_trait_ref, trait_ref);
 }
 
-fn insert_vtables(fcx: &FnCtxt, expr_id: ast::NodeId, vtables: vtable_res) {
-    debug!("insert_vtables(expr_id={}, vtables={:?})",
-           expr_id, vtables.repr(fcx.tcx()));
-    fcx.inh.vtable_map.borrow_mut().insert(expr_id, vtables);
+fn insert_vtables(fcx: &FnCtxt, vtable_key: MethodCall, vtables: vtable_res) {
+    debug!("insert_vtables(vtable_key={}, vtables={:?})",
+           vtable_key, vtables.repr(fcx.tcx()));
+    fcx.inh.vtable_map.borrow_mut().insert(vtable_key, vtables);
 }
 
 pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
@@ -591,7 +591,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                                                      is_early);
 
                       if !is_early {
-                          insert_vtables(fcx, ex.id, @vec!(vtables));
+                          insert_vtables(fcx, MethodCall::expr(ex.id), @vec!(vtables));
                       }
 
                       // Now, if this is &trait, we need to link the
@@ -648,7 +648,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                                            item_ty.generics.type_param_defs(),
                                            substs, is_early);
                 if !is_early {
-                    insert_vtables(fcx, ex.id, vtbls);
+                    insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
                 }
             }
             true
@@ -673,7 +673,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                                            type_param_defs.as_slice(),
                                            &substs, is_early);
                 if !is_early {
-                    insert_vtables(fcx, ex.id, vtbls);
+                    insert_vtables(fcx, MethodCall::expr(ex.id), vtbls);
                 }
             }
           }
@@ -692,6 +692,30 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
     match fcx.inh.adjustments.borrow().find(&ex.id) {
         Some(adjustment) => {
             match **adjustment {
+                AutoDerefRef(adj) => {
+                    for autoderef in range(0, adj.autoderefs) {
+                        let method_call = MethodCall::autoderef(ex.id, autoderef as u32);
+                        match fcx.inh.method_map.borrow().find(&method_call) {
+                            Some(method) => {
+                                debug!("vtable resolution on parameter bounds for autoderef {}",
+                                       ex.repr(fcx.tcx()));
+                                let type_param_defs =
+                                    ty::method_call_type_param_defs(cx.tcx, method.origin);
+                                if has_trait_bounds(type_param_defs.deref().as_slice()) {
+                                    let vcx = fcx.vtable_context();
+                                    let vtbls = lookup_vtables(&vcx, ex.span,
+                                                               type_param_defs.deref()
+                                                               .as_slice(),
+                                                               &method.substs, is_early);
+                                    if !is_early {
+                                        insert_vtables(fcx, method_call, vtbls);
+                                    }
+                                }
+                            }
+                            None => {}
+                        }
+                    }
+                }
                 AutoObject(ref sigil,
                            ref region,
                            m,
@@ -713,7 +737,7 @@ pub fn early_resolve_expr(ex: &ast::Expr, fcx: &FnCtxt, is_early: bool) {
                                                                b);
                     resolve_object_cast(ex, object_ty);
                 }
-                AutoAddEnv(..) | AutoDerefRef(..) => {}
+                AutoAddEnv(..) => {}
             }
         }
         None => {}