---

yaml
---
r: 7131
b: refs/heads/master
c: 47cfeba
h: refs/heads/master
i:
  7129: 3e02701
  7127: fc86010
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: ba694775f5ea61c9b29e318bbe2e4d942adb39ad
+refs/heads/master: 47cfeba4675906dceb92e0a6b2846146ff888581

trunk/AUTHORS.txt

@@ -41,6 +41,7 @@ Paul Stansifer <[email protected]>
 Peter Hull <[email protected]>
 Ralph Giles <[email protected]>
 Rafael Ávila de Espíndola <[email protected]>
+Reuben Morais <[email protected]>
 Rob Arnold <[email protected]>
 Roy Frostig <[email protected]>
 Stefan Plantikow <[email protected]>

trunk/LICENSE.txt

@@ -250,8 +250,8 @@ The remaining code and documentation in the collective work
 presented here, as well as the collective work itslf, is
 distributed under the following terms ("The Rust License"):
 
-    Copyright (c) 2006-2011 Graydon Hoare
-    Copyright (c) 2009-2011 Mozilla Foundation
+    Copyright (c) 2006-2012 Graydon Hoare
+    Copyright (c) 2009-2012 Mozilla Foundation
 
     Permission is hereby granted, free of charge, to any
     person obtaining a copy of this software and associated

trunk/configure

@@ -324,7 +324,7 @@ then
                       | cut -d ' ' -f 3)
 
     case $CFG_CLANG_VERSION in
-        (3.0svn | 3.0)
+        (3.0svn | 3.0 | 3.1)
         step_msg "found ok version of CLANG: $CFG_CLANG_VERSION"
         CFG_C_COMPILER="clang"
         ;;

trunk/src/comp/middle/last_use.rs

@@ -136,6 +136,16 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
         v.visit_expr(dest, cx, v);
         clear_if_path(cx, dest, v, true);
       }
+      expr_fn(_, _, _, cap_clause) {
+        // n.b.: safe to ignore copies, as if they are unused
+        // then they are ignored, otherwise they will show up
+        // as freevars in the body.
+
+        vec::iter(cap_clause.moves) {|ci|
+            clear_def_if_path(cx, cx.def_map.get(ci.id), true);
+        }
+        visit::visit_expr(ex, cx, v);
+      }
       expr_call(f, args, _) {
         v.visit_expr(f, cx, v);
         let i = 0u, fns = [];
@@ -263,18 +273,25 @@ fn clear_in_current(cx: ctx, my_def: node_id, to: bool) {
     }
 }
 
+fn clear_def_if_path(cx: ctx, d: def, to: bool)
+    -> option<node_id> {
+    alt d {
+      def_local(def_id, let_copy.) | def_arg(def_id, by_copy.) |
+      def_arg(def_id, by_move.) {
+        clear_in_current(cx, def_id.node, to);
+        some(def_id.node)
+      }
+      _ {
+        none
+      }
+    }
+}
+
 fn clear_if_path(cx: ctx, ex: @expr, v: visit::vt<ctx>, to: bool)
     -> option::t<node_id> {
     alt ex.node {
       expr_path(_) {
-        alt cx.def_map.get(ex.id) {
-          def_local(def_id, let_copy.) | def_arg(def_id, by_copy.) |
-          def_arg(def_id, by_move.) {
-            clear_in_current(cx, def_id.node, to);
-            ret option::some(def_id.node);
-          }
-          _ {}
-        }
+        ret clear_def_if_path(cx, cx.def_map.get(ex.id), to);
       }
       _ { v.visit_expr(ex, cx, v); }
     }

trunk/src/comp/middle/resolve.rs

@@ -486,12 +486,9 @@ fn visit_fn_with_scope(e: @env, fk: visit::fn_kind, decl: ast::fn_decl,
     for c: @ast::constr in decl.constraints { resolve_constr(e, c, sc, v); }
     let scope = alt fk {
       visit::fk_item_fn(_, tps) | visit::fk_res(_, tps) |
-      visit::fk_method(_, tps) {
-        scope_bare_fn(decl, id, tps)
-      }
-      visit::fk_anon(_) | visit::fk_fn_block. {
-        scope_fn_expr(decl, id, [])
-      }
+      visit::fk_method(_, tps) { scope_bare_fn(decl, id, tps) }
+      visit::fk_anon(ast::proto_bare.) { scope_bare_fn(decl, id, []) }
+      visit::fk_anon(_) | visit::fk_fn_block. { scope_fn_expr(decl, id, []) }
     };
 
     visit::visit_fn(fk, decl, body, sp, id, cons(scope, @sc), v);

trunk/src/comp/middle/shape.rs

@@ -52,6 +52,7 @@ const shape_res: u8 = 20u8;
 const shape_var: u8 = 21u8;
 const shape_uniq: u8 = 22u8;
 const shape_opaque_closure_ptr: u8 = 23u8; // the closure itself.
+const shape_iface: u8 = 24u8;
 
 // FIXME: This is a bad API in trans_common.
 fn C_u8(n: u8) -> ValueRef { ret trans_common::C_u8(n as uint); }
@@ -387,6 +388,7 @@ fn shape_of(ccx: @crate_ctxt, t: ty::t, ty_param_map: [uint],
       }
       ty::ty_native_fn(_, _) { s += [shape_u32]; }
       ty::ty_obj(_) { s += [shape_obj]; }
+      ty::ty_iface(_, _) { s += [shape_iface]; }
       ty::ty_res(did, raw_subt, tps) {
         let subt = ty::substitute_type_params(ccx.tcx, tps, raw_subt);
         let ri = {did: did, t: subt};

trunk/src/comp/middle/trans.rs

@@ -178,7 +178,8 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t)
         let nft = native_fn_wrapper_type(cx, sp, [], t);
         T_fn_pair(cx, nft)
       }
-      ty::ty_obj(meths) { cx.rust_object_type }
+      ty::ty_obj(_) { cx.rust_object_type }
+      ty::ty_iface(_, _) { T_opaque_iface_ptr(cx) }
       ty::ty_res(_, sub, tps) {
         let sub1 = ty::substitute_type_params(cx.tcx, tps, sub);
         check non_ty_var(cx, sub1);
@@ -483,7 +484,9 @@ fn mk_obstack_token(ccx: @crate_ctxt, fcx: @fn_ctxt) ->
 fn simplify_type(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
     fn simplifier(ccx: @crate_ctxt, typ: ty::t) -> ty::t {
         alt ty::struct(ccx.tcx, typ) {
-          ty::ty_box(_) { ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx)); }
+          ty::ty_box(_) | ty::ty_iface(_, _) {
+            ret ty::mk_imm_box(ccx.tcx, ty::mk_nil(ccx.tcx));
+          }
           ty::ty_uniq(_) {
             ret ty::mk_imm_uniq(ccx.tcx, ty::mk_nil(ccx.tcx));
           }
@@ -1386,9 +1389,10 @@ fn make_free_glue(bcx: @block_ctxt, v: ValueRef, t: ty::t) {
       ty::ty_vec(_) | ty::ty_str. {
         tvec::make_free_glue(bcx, PointerCast(bcx, v, type_of_1(bcx, t)), t)
       }
-      ty::ty_obj(_) {
+      ty::ty_obj(_) | ty::ty_iface(_, _) {
         // Call through the obj's own fields-drop glue first.
         // Then free the body.
+        // (Same code of ifaces, whose layout is similar)
         let ccx = bcx_ccx(bcx);
         let llbox_ty = T_opaque_obj_ptr(ccx);
         let b = PointerCast(bcx, v, llbox_ty);
@@ -1425,13 +1429,14 @@ fn make_drop_glue(bcx: @block_ctxt, v0: ValueRef, t: ty::t) {
     let ccx = bcx_ccx(bcx);
     let bcx =
         alt ty::struct(ccx.tcx, t) {
-          ty::ty_box(_) { decr_refcnt_maybe_free(bcx, Load(bcx, v0), t) }
+          ty::ty_box(_) | ty::ty_iface(_, _) {
+              decr_refcnt_maybe_free(bcx, Load(bcx, v0), t)
+          }
           ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str. | ty::ty_send_type. {
             free_ty(bcx, Load(bcx, v0), t)
           }
           ty::ty_obj(_) {
-            let box_cell =
-                GEPi(bcx, v0, [0, abi::obj_field_box]);
+            let box_cell = GEPi(bcx, v0, [0, abi::obj_field_box]);
             decr_refcnt_maybe_free(bcx, Load(bcx, box_cell), t)
           }
           ty::ty_res(did, inner, tps) {
@@ -1935,22 +1940,22 @@ fn drop_ty(cx: @block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt {
 
 fn drop_ty_immediate(bcx: @block_ctxt, v: ValueRef, t: ty::t) -> @block_ctxt {
     alt ty::struct(bcx_tcx(bcx), t) {
-      ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str. {
-        ret free_ty(bcx, v, t);
-      }
-      ty::ty_box(_) { ret decr_refcnt_maybe_free(bcx, v, t); }
+      ty::ty_uniq(_) | ty::ty_vec(_) | ty::ty_str. { free_ty(bcx, v, t) }
+      ty::ty_box(_) | ty::ty_iface(_, _) { decr_refcnt_maybe_free(bcx, v, t) }
     }
 }
 
 fn take_ty_immediate(bcx: @block_ctxt, v: ValueRef, t: ty::t) -> result {
     alt ty::struct(bcx_tcx(bcx), t) {
-      ty::ty_box(_) { ret rslt(incr_refcnt_of_boxed(bcx, v), v); }
+      ty::ty_box(_) | ty::ty_iface(_, _) {
+        rslt(incr_refcnt_of_boxed(bcx, v), v)
+      }
       ty::ty_uniq(_) {
         check trans_uniq::type_is_unique_box(bcx, t);
-        ret trans_uniq::duplicate(bcx, v, t);
+        trans_uniq::duplicate(bcx, v, t)
       }
-      ty::ty_str. | ty::ty_vec(_) { ret tvec::duplicate(bcx, v, t); }
-      _ { ret rslt(bcx, v); }
+      ty::ty_str. | ty::ty_vec(_) { tvec::duplicate(bcx, v, t) }
+      _ { rslt(bcx, v) }
     }
 }
 
@@ -2873,9 +2878,12 @@ fn trans_callee(bcx: @block_ctxt, e: @ast::expr) -> lval_maybe_callee {
                 ret trans_impl::trans_static_callee(bcx, e, base, did);
               }
               some(typeck::method_param(iid, off, p, b)) {
-                ret trans_impl::trans_dict_callee(
+                ret trans_impl::trans_param_callee(
                     bcx, e, base, iid, off, p, b);
               }
+              some(typeck::method_iface(off)) {
+                ret trans_impl::trans_iface_callee(bcx, e, base, off);
+              }
               none. { // An object method
                 let of = trans_object_field(bcx, base, ident);
                 ret {bcx: of.bcx, val: of.mthptr, kind: owned,
@@ -3001,10 +3009,14 @@ fn float_cast(bcx: @block_ctxt, lldsttype: TypeRef, llsrctype: TypeRef,
 fn trans_cast(cx: @block_ctxt, e: @ast::expr, id: ast::node_id,
               dest: dest) -> @block_ctxt {
     let ccx = bcx_ccx(cx);
+    let t_out = node_id_type(ccx, id);
+    alt ty::struct(ccx.tcx, t_out) {
+      ty::ty_iface(_, _) { ret trans_impl::trans_cast(cx, e, id, dest); }
+      _ {}
+    }
     let e_res = trans_temp_expr(cx, e);
     let ll_t_in = val_ty(e_res.val);
     let t_in = ty::expr_ty(ccx.tcx, e);
-    let t_out = node_id_type(ccx, id);
     // Check should be avoidable because it's a cast.
     // FIXME: Constrain types so as to avoid this check.
     check (type_has_static_size(ccx, t_out));

trunk/src/comp/middle/trans_closure.rs

@@ -9,6 +9,7 @@ import middle::freevars::{get_freevars, freevar_info};
 import option::{some, none};
 import back::abi;
 import syntax::codemap::span;
+import syntax::print::pprust::expr_to_str;
 import back::link::{
     mangle_internal_name_by_path,
     mangle_internal_name_by_path_and_seq};
@@ -121,6 +122,18 @@ tag environment_value {
     env_ref(ValueRef, ty::t, lval_kind);
 }
 
+fn ev_to_str(ccx: @crate_ctxt, ev: environment_value) -> str {
+    alt ev {
+      env_expr(ex) { expr_to_str(ex) }
+      env_copy(v, t, lk) { #fmt("copy(%s,%s)", val_str(ccx.tn, v),
+                                ty_to_str(ccx.tcx, t)) }
+      env_move(v, t, lk) { #fmt("move(%s,%s)", val_str(ccx.tn, v),
+                                ty_to_str(ccx.tcx, t)) }
+      env_ref(v, t, lk) { #fmt("ref(%s,%s)", val_str(ccx.tn, v),
+                                ty_to_str(ccx.tcx, t)) }
+    }
+}
+
 fn mk_tydesc_ty(tcx: ty::ctxt, ck: ty::closure_kind) -> ty::t {
     ret alt ck {
       ty::closure_block. | ty::closure_shared. { ty::mk_type(tcx) }
@@ -284,7 +297,7 @@ fn store_environment(
         };
     }
 
-    //let ccx = bcx_ccx(bcx);
+    let ccx = bcx_ccx(bcx);
     let tcx = bcx_tcx(bcx);
 
     // compute the shape of the closure
@@ -351,6 +364,11 @@ fn store_environment(
     let {bcx: bcx, val:bindings_slot} =
         GEP_tup_like_1(bcx, cboxptr_ty, llbox, [0, abi::cbox_elt_bindings]);
     vec::iteri(bound_values) { |i, bv|
+        if (!ccx.sess.get_opts().no_asm_comments) {
+            add_comment(bcx, #fmt("Copy %s into closure",
+                                  ev_to_str(ccx, bv)));
+        }
+
         let bound_data = GEPi(bcx, bindings_slot, [0, i as int]);
         alt bv {
           env_expr(e) {

trunk/src/comp/middle/trans_common.rs

@@ -754,6 +754,11 @@ fn T_obj_ptr(cx: @crate_ctxt, n_captured_tydescs: uint) -> TypeRef {
 
 fn T_opaque_obj_ptr(cx: @crate_ctxt) -> TypeRef { ret T_obj_ptr(cx, 0u); }
 
+fn T_opaque_iface_ptr(cx: @crate_ctxt) -> TypeRef {
+    let tdptr = T_ptr(cx.tydesc_type);
+    T_ptr(T_box(cx, T_struct([tdptr, tdptr, T_i8()])))
+}
+
 fn T_opaque_port_ptr() -> TypeRef { ret T_ptr(T_i8()); }
 
 fn T_opaque_chan_ptr() -> TypeRef { ret T_ptr(T_i8()); }