rustc: Implement "@foo as @bar" for boxed traits

Author: pcwalton

src/rustc/middle/astencode.rs

@@ -929,6 +929,8 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
 
         if tag == (c::tag_table_mutbl as uint) {
             dcx.maps.mutbl_map.insert(id, ());
+        } else if tag == (c::tag_table_legacy_boxed_trait as uint) {
+            dcx.tcx.legacy_boxed_traits.insert(id, ());
         } else {
             let val_doc = entry_doc[c::tag_table_val as uint];
             let val_dsr = ebml::ebml_deserializer(val_doc);
@@ -969,8 +971,6 @@ fn decode_side_tables(xcx: extended_decode_ctxt,
             } else if tag == (c::tag_table_adjustments as uint) {
                 let adj = @ty::deserialize_AutoAdjustment(val_dsr).tr(xcx);
                 dcx.tcx.adjustments.insert(id, adj);
-            } else if tag == (c::tag_table_legacy_boxed_trait as uint) {
-                dcx.tcx.legacy_boxed_traits.insert(id, ());
             } else {
                 xcx.dcx.tcx.sess.bug(
                     fmt!("unknown tag found in side tables: %x", tag));

src/rustc/middle/trans/meth.rs

@@ -536,6 +536,7 @@ fn trans_trait_cast(bcx: block,
                     dest: expr::Dest)
     -> block
 {
+    let mut bcx = bcx;
     let _icx = bcx.insn_ctxt("impl::trans_cast");
 
     let lldest = match dest {
@@ -548,16 +549,24 @@ fn trans_trait_cast(bcx: block,
     let ccx = bcx.ccx();
     let v_ty = expr_ty(bcx, val);
 
-    // Allocate an @ box and store the value into it
-    let {bcx: bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty);
-    add_clean_free(bcx, llbox, heap_shared);
-    let bcx = expr::trans_into(bcx, val, SaveIn(body));
-    revoke_clean(bcx, llbox);
+    let mut llboxdest = GEPi(bcx, lldest, [0u, 1u]);
+    llboxdest = PointerCast(bcx, llboxdest,
+                            T_ptr(type_of::type_of(bcx.ccx(), v_ty)));
+
+    if bcx.tcx().legacy_boxed_traits.contains_key(id) {
+        // Allocate an @ box and store the value into it
+        let {bcx: new_bcx, box: llbox, body: body} = malloc_boxed(bcx, v_ty);
+        bcx = new_bcx;
+        add_clean_free(bcx, llbox, heap_shared);
+        bcx = expr::trans_into(bcx, val, SaveIn(body));
+        revoke_clean(bcx, llbox);
 
-    // Store the @ box into the pair
-    Store(bcx, llbox, PointerCast(bcx,
-                                  GEPi(bcx, lldest, [0u, 1u]),
-                                  T_ptr(val_ty(llbox))));
+        // Store the @ box into the pair
+        Store(bcx, llbox, llboxdest);
+    } else {
+        // Just store the @ box into the pair.
+        bcx = expr::trans_into(bcx, val, SaveIn(llboxdest));
+    }
 
     // Store the vtable into the pair
     let orig = ccx.maps.vtable_map.get(id)[0];

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

@@ -51,8 +51,18 @@ fn lookup_vtables(fcx: @fn_ctxt,
             match *bound {
               ty::bound_trait(i_ty) => {
                 let i_ty = ty::subst(tcx, substs, i_ty);
-                result.push(lookup_vtable(fcx, expr, *ty, i_ty,
-                                          allow_unsafe, is_early));
+                match lookup_vtable(fcx, expr, *ty, i_ty, allow_unsafe,
+                                    is_early) {
+                    Some(vtable) => result.push(vtable),
+                    None => {
+                        fcx.tcx().sess.span_fatal(
+                            expr.span,
+                            fmt!("failed to find an implementation of trait \
+                                  %s for %s",
+                                 ty_to_str(fcx.tcx(), i_ty),
+                                 ty_to_str(fcx.tcx(), *ty)));
+                    }
+                }
               }
               _ => ()
             }
@@ -91,7 +101,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                  trait_ty: ty::t,
                  allow_unsafe: bool,
                  is_early: bool)
-    -> vtable_origin
+    -> Option<vtable_origin>
 {
 
     debug!("lookup_vtable(ty=%s, trait_ty=%s)",
@@ -113,7 +123,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
             // The type has unconstrained type variables in it, so we can't
             // do early resolution on it. Return some completely bogus vtable
             // information: we aren't storing it anyways.
-            return vtable_param(0, 0);
+            return Some(vtable_param(0, 0));
         }
     };
 
@@ -135,7 +145,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                            idid);
                                     relate_trait_tys(fcx, expr,
                                                      trait_ty, ity);
-                                    return vtable_param(n, n_bound);
+                                    return Some(vtable_param(n, n_bound));
                                 }
                             }
                             _ => tcx.sess.impossible_case(
@@ -170,7 +180,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                     }
                 }
             }
-            return vtable_trait(did, substs.tps);
+            return Some(vtable_trait(did, substs.tps));
         }
 
         _ => {
@@ -303,7 +313,7 @@ fn lookup_vtable(fcx: @fn_ctxt,
                                 None => {
                                     assert is_early;
                                     // Bail out with a bogus answer
-                                    return vtable_param(0, 0);
+                                    return Some(vtable_param(0, 0));
                                 }
                             };
 
@@ -341,23 +351,20 @@ fn lookup_vtable(fcx: @fn_ctxt,
 
             match found.len() {
                 0 => { /* fallthrough */ }
-                1 => { return found[0]; }
+                1 => { return Some(found[0]); }
                 _ => {
                     if !is_early {
                         fcx.ccx.tcx.sess.span_err(
                             expr.span,
                             ~"multiple applicable methods in scope");
                     }
-                    return found[0];
+                    return Some(found[0]);
                 }
             }
         }
     }
 
-    tcx.sess.span_fatal(
-        expr.span,
-        fmt!("failed to find an implementation of trait %s for %s",
-             ty_to_str(tcx, trait_ty), ty_to_str(tcx, ty)));
+    return None;
 }
 
 fn fixup_ty(fcx: @fn_ctxt,
@@ -459,13 +466,55 @@ fn early_resolve_expr(ex: @ast::expr, &&fcx: @fn_ctxt, is_early: bool) {
             Look up vtables for the type we're casting to,
             passing in the source and target type
             */
-            let vtable = lookup_vtable(fcx, ex, fcx.expr_ty(src),
-                                       target_ty, true, is_early);
-            /*
-            Map this expression to that vtable (that is: "ex has
-            vtable <vtable>")
-            */
-            if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+            let ty = fcx.expr_ty(src);
+            let vtable_opt = lookup_vtable(fcx, ex, ty, target_ty, true,
+                                           is_early);
+            match vtable_opt {
+                None => {
+                    // Try the new-style boxed trait; "@int as @Trait".
+                    let mut err = false;
+                    let ty = structurally_resolved_type(fcx, ex.span, ty);
+                    match ty::get(ty).sty {
+                        ty::ty_box(boxed_ty) => {
+                            let vtable_opt = lookup_vtable(fcx, ex,
+                                                           boxed_ty.ty,
+                                                           target_ty, true,
+                                                           is_early);
+                            match vtable_opt {
+                                Some(vtable) => {
+                                    /*
+                                    Map this expression to that vtable (that
+                                    is: "ex has vtable <vtable>")
+                                    */
+                                    if !is_early {
+                                        cx.vtable_map.insert(ex.id,
+                                                             @~[vtable]);
+                                    }
+                                }
+                                None => err = true
+                            }
+                        }
+                        _ => err = true
+                    }
+
+                    if err {
+                        fcx.tcx().sess.span_fatal(
+                            ex.span,
+                            fmt!("failed to find an implementation of trait \
+                                  %s for %s",
+                                 ty_to_str(fcx.tcx(), target_ty),
+                                 ty_to_str(fcx.tcx(), ty)));
+                    }
+                }
+                Some(vtable) => {
+                    /*
+                    Map this expression to that vtable (that is: "ex has
+                    vtable <vtable>")
+                    */
+                    if !is_early { cx.vtable_map.insert(ex.id, @~[vtable]); }
+                    fcx.tcx().legacy_boxed_traits.insert(ex.id, ());
+                }
+            }
           }
           _ => ()
         }