Implement an initial version of placement new.

Author: nikomatsakis

src/cargo/cargo.rs

@@ -434,8 +434,8 @@ fn for_each_package(c: cargo, b: fn(source, package)) {
 
 // Runs all programs in directory <buildpath>
 fn run_programs(buildpath: str) {
-    let new = os::list_dir(buildpath);
-    for ct: str in new {
+    let newv = os::list_dir(buildpath);
+    for ct: str in newv {
         run::run_program(ct, []);
     }
 }
@@ -471,9 +471,9 @@ fn install_one_crate(c: cargo, path: str, cf: str) {
       none { ret; }
       some(bp) { bp }
     };
-    let new = os::list_dir(buildpath);
+    let newv = os::list_dir(buildpath);
     let exec_suffix = os::exe_suffix();
-    for ct: str in new {
+    for ct: str in newv {
         if (exec_suffix != "" && str::ends_with(ct, exec_suffix)) ||
             (exec_suffix == "" && !str::starts_with(path::basename(ct),
                                                     "lib")) {

src/fuzzer/fuzzer.rs

@@ -488,23 +488,23 @@ fn file_might_not_converge(filename: str) -> bool {
 fn check_roundtrip_convergence(code: @str, maxIters: uint) {
 
     let i = 0u;
-    let new = code;
-    let old = code;
+    let newv = code;
+    let oldv = code;
 
     while i < maxIters {
-        old = new;
-        if content_might_not_converge(*old) { ret; }
-        new = @parse_and_print(old);
-        if old == new { break; }
+        oldv = newv;
+        if content_might_not_converge(*oldv) { ret; }
+        newv = @parse_and_print(oldv);
+        if oldv == newv { break; }
         i += 1u;
     }
 
-    if old == new {
+    if oldv == newv {
         #error("Converged after %u iterations", i);
     } else {
         #error("Did not converge after %u iterations!", i);
-        write_file("round-trip-a.rs", *old);
-        write_file("round-trip-b.rs", *new);
+        write_file("round-trip-a.rs", *oldv);
+        write_file("round-trip-b.rs", *newv);
         run::run_program("diff",
                          ["-w", "-u", "round-trip-a.rs",
                           "round-trip-b.rs"]);

src/libcore/path.rs

@@ -266,30 +266,30 @@ fn normalize(p: path) -> path {
     #[cfg(target_os = "linux")]
     #[cfg(target_os = "macos")]
     #[cfg(target_os = "freebsd")]
-    fn reabsolute(orig: path, new: path) -> path {
+    fn reabsolute(orig: path, n: path) -> path {
         if path_is_absolute(orig) {
-            path_sep() + new
+            path_sep() + n
         } else {
-            new
+            n
         }
     }
 
     #[cfg(target_os = "win32")]
-    fn reabsolute(orig: path, new: path) -> path {
+    fn reabsolute(orig: path, newp: path) -> path {
        if path_is_absolute(orig) && orig[0] == consts::path_sep as u8 {
-           str::from_char(consts::path_sep) + new
+           str::from_char(consts::path_sep) + newp
        } else {
-           new
+           newp
        }
     }
 
-    fn reterminate(orig: path, new: path) -> path {
+    fn reterminate(orig: path, newp: path) -> path {
         let last = orig[str::len(orig) - 1u];
         if last == consts::path_sep as u8
             || last == consts::path_sep as u8 {
-            ret new + path_sep();
+            ret newp + path_sep();
         } else {
-            ret new;
+            ret newp;
         }
     }
 }

src/libcore/vec.rs

@@ -468,22 +468,22 @@ Concatenate a vector of vectors.
 Flattens a vector of vectors of T into a single vector of T.
 "]
 fn concat<T: copy>(v: [const [const T]]) -> [T] {
-    let mut new: [T] = [];
-    for inner: [T] in v { new += inner; }
-    ret new;
+    let mut r: [T] = [];
+    for inner: [T] in v { r += inner; }
+    ret r;
 }
 
 #[doc = "
 Concatenate a vector of vectors, placing a given separator between each
 "]
 fn connect<T: copy>(v: [const [const T]], sep: T) -> [T] {
-    let mut new: [T] = [];
+    let mut r: [T] = [];
     let mut first = true;
     for inner: [T] in v {
-        if first { first = false; } else { push(new, sep); }
-        new += inner;
+        if first { first = false; } else { push(r, sep); }
+        r += inner;
     }
-    ret new;
+    ret r;
 }
 
 #[doc = "Reduce a vector from left to right"]

src/rustc/middle/resolve.rs

@@ -2308,6 +2308,9 @@ fn resolve_impl_in_expr(e: @env, x: @ast::expr, sc: iscopes, v: vt<iscopes>) {
       ast::expr_assign_op(_, _, _) | ast::expr_index(_, _) {
         e.impl_map.insert(x.id, sc);
       }
+      ast::expr_new(p, _, _) {
+        e.impl_map.insert(p.id, sc);
+      }
       _ {}
     }
     visit::visit_expr(x, sc, v);

src/rustc/middle/trans/base.rs

@@ -1261,9 +1261,9 @@ fn trans_unary(bcx: block, op: ast::unop, e: @ast::expr,
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(un_expr);
         let fty = node_id_type(bcx, callee_id);
-        ret trans_call_inner(bcx, fty, {|bcx|
+        ret trans_call_inner(bcx, fty, expr_ty(bcx, un_expr), {|bcx|
             impl::trans_method_callee(bcx, callee_id, e, origin)
-        }, [], un_expr.id, dest);
+        }, arg_exprs([]), dest);
       }
       _ {}
     }
@@ -1450,10 +1450,10 @@ fn trans_assign_op(bcx: block, ex: @ast::expr, op: ast::binop,
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(ex);
         let fty = node_id_type(bcx, callee_id);
-        ret trans_call_inner(bcx, fty, {|bcx|
+        ret trans_call_inner(bcx, fty, expr_ty(bcx, ex), {|bcx|
             // FIXME provide the already-computed address, not the expr
             impl::trans_method_callee(bcx, callee_id, dst, origin)
-        }, [src], ex.id, save_in(lhs_res.val));
+        }, arg_exprs([src]), save_in(lhs_res.val));
       }
       _ {}
     }
@@ -1561,9 +1561,9 @@ fn trans_binary(bcx: block, op: ast::binop, lhs: @ast::expr,
       some(origin) {
         let callee_id = ast_util::op_expr_callee_id(ex);
         let fty = node_id_type(bcx, callee_id);
-        ret trans_call_inner(bcx, fty, {|bcx|
+        ret trans_call_inner(bcx, fty, expr_ty(bcx, ex), {|bcx|
             impl::trans_method_callee(bcx, callee_id, lhs, origin)
-        }, [rhs], ex.id, dest);
+        }, arg_exprs([rhs]), dest);
       }
       _ {}
     }
@@ -2498,19 +2498,23 @@ fn trans_arg_expr(cx: block, arg: ty::arg, lldestty: TypeRef, e: @ast::expr,
     ret rslt(bcx, val);
 }
 
+enum call_args {
+    arg_exprs([@ast::expr]),
+    arg_vals([ValueRef])
+}
 
 // NB: must keep 4 fns in sync:
 //
 //  - type_of_fn
 //  - create_llargs_for_fn_args.
 //  - new_fn_ctxt
 //  - trans_args
-fn trans_args(cx: block, llenv: ValueRef, es: [@ast::expr], fn_ty: ty::t,
+fn trans_args(cx: block, llenv: ValueRef, args: call_args, fn_ty: ty::t,
               dest: dest, generic_intrinsic: bool)
     -> {bcx: block, args: [ValueRef], retslot: ValueRef} {
 
     let temp_cleanups = [];
-    let args = ty::ty_fn_args(fn_ty);
+    let arg_tys = ty::ty_fn_args(fn_ty);
     let llargs: [ValueRef] = [];
 
     let ccx = cx.ccx();
@@ -2546,13 +2550,21 @@ fn trans_args(cx: block, llenv: ValueRef, es: [@ast::expr], fn_ty: ty::t,
     // First we figure out the caller's view of the types of the arguments.
     // This will be needed if this is a generic call, because the callee has
     // to cast her view of the arguments to the caller's view.
-    let arg_tys = type_of_explicit_args(ccx, args);
-    let i = 0u;
-    for e: @ast::expr in es {
-        let r = trans_arg_expr(bcx, args[i], arg_tys[i], e, temp_cleanups);
-        bcx = r.bcx;
-        llargs += [r.val];
-        i += 1u;
+    alt args {
+      arg_exprs(es) {
+        let llarg_tys = type_of_explicit_args(ccx, arg_tys);
+        let i = 0u;
+        for e: @ast::expr in es {
+            let r = trans_arg_expr(bcx, arg_tys[i], llarg_tys[i],
+                                   e, temp_cleanups);
+            bcx = r.bcx;
+            llargs += [r.val];
+            i += 1u;
+        }
+      }
+      arg_vals(vs) {
+        llargs += vs;
+      }
     }
 
     // now that all arguments have been successfully built, we can revoke any
@@ -2568,15 +2580,15 @@ fn trans_args(cx: block, llenv: ValueRef, es: [@ast::expr], fn_ty: ty::t,
 }
 
 fn trans_call(in_cx: block, f: @ast::expr,
-              args: [@ast::expr], id: ast::node_id, dest: dest)
+              args: call_args, id: ast::node_id, dest: dest)
     -> block {
-    trans_call_inner(in_cx, expr_ty(in_cx, f),
-                     {|cx| trans_callee(cx, f)}, args, id, dest)
+    trans_call_inner(in_cx, expr_ty(in_cx, f), node_id_type(in_cx, id),
+                     {|cx| trans_callee(cx, f)}, args, dest)
 }
 
-fn trans_call_inner(in_cx: block, fn_expr_ty: ty::t,
+fn trans_call_inner(in_cx: block, fn_expr_ty: ty::t, ret_ty: ty::t,
                     get_callee: fn(block) -> lval_maybe_callee,
-                    args: [@ast::expr], id: ast::node_id, dest: dest)
+                    args: call_args, dest: dest)
     -> block {
     with_scope(in_cx, "call") {|cx|
         let f_res = get_callee(cx);
@@ -2603,9 +2615,10 @@ fn trans_call_inner(in_cx: block, fn_expr_ty: ty::t,
           }
         };
 
-        let ret_ty = node_id_type(bcx, id);
-        let args_res = trans_args(bcx, llenv, args, fn_expr_ty, dest,
-                                  option::is_some(f_res.tds));
+        let args_res = {
+            trans_args(bcx, llenv, args, fn_expr_ty, dest,
+                       option::is_some(f_res.tds))
+        };
         bcx = args_res.bcx;
         let llargs = args_res.args;
         option::may(f_res.tds) {|vals|
@@ -2923,7 +2936,7 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
       }
       ast::expr_cast(val, _) { ret trans_cast(bcx, val, e.id, dest); }
       ast::expr_call(f, args, _) {
-        ret trans_call(bcx, f, args, e.id, dest);
+        ret trans_call(bcx, f, arg_exprs(args), e.id, dest);
       }
       ast::expr_field(base, _, _) {
         if dest == ignore { ret trans_expr(bcx, base, ignore); }
@@ -2937,9 +2950,9 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         let origin = bcx.ccx().maps.method_map.get(e.id);
         let callee_id = ast_util::op_expr_callee_id(e);
         let fty = node_id_type(bcx, callee_id);
-        ret trans_call_inner(bcx, fty, {|bcx|
+        ret trans_call_inner(bcx, fty, expr_ty(bcx, e), {|bcx|
             impl::trans_method_callee(bcx, callee_id, base, origin)
-        }, [idx], e.id, dest);
+        }, arg_exprs([idx]), dest);
       }
 
       // These return nothing
@@ -3037,6 +3050,45 @@ fn trans_expr(bcx: block, e: @ast::expr, dest: dest) -> block {
         assert dest == ignore;
         ret trans_assign_op(bcx, e, op, dst, src);
       }
+      ast::expr_new(pool, alloc_id, val) {
+        // First, call pool->alloc(sz, align) to get back a void*.  Then, cast
+        // this memory to the required type and evaluate value into it.
+        let ccx = bcx.ccx();
+
+        // Allocate space for the ptr that will be returned from
+        // `pool.alloc()`:
+        let ptr_ty = expr_ty(bcx, e);
+        let {bcx, val: ptr_ptr_val} = alloc_ty(bcx, ptr_ty);
+
+        #debug["ptr_ty = %s", ty_to_str(tcx, ptr_ty)];
+        #debug["ptr_ptr_val = %s", val_str(ccx.tn, ptr_ptr_val)];
+
+        let void_ty = ty::mk_ptr(tcx, {ty: ty::mk_nil(tcx),
+                                       mutbl: ast::m_imm});
+        let voidval = {
+            let llvoid_ty = type_of(ccx, void_ty);
+            PointerCast(bcx, ptr_ptr_val, T_ptr(llvoid_ty))
+        };
+
+        #debug["voidval = %s", val_str(ccx.tn, voidval)];
+
+        let llval_ty = type_of(ccx, expr_ty(bcx, val));
+        let args = [llsize_of(ccx, llval_ty), llalign_of(ccx, llval_ty)];
+        let origin = bcx.ccx().maps.method_map.get(alloc_id);
+        let bcx = trans_call_inner(
+            bcx,
+            node_id_type(bcx, alloc_id),
+            void_ty,
+            {|bcx| impl::trans_method_callee(bcx, alloc_id, pool, origin) },
+            arg_vals(args),
+            save_in(voidval));
+
+        #debug["dest = %s", dest_str(ccx, dest)];
+        let ptr_val = Load(bcx, ptr_ptr_val);
+        #debug["ptr_val = %s", val_str(ccx.tn, ptr_val)];
+        let bcx = trans_expr(bcx, val, save_in(ptr_val));
+        store_in_dest(bcx, ptr_val, dest)
+      }
       _ { bcx.tcx().sess.span_bug(e.span, "trans_expr reached \
              fall-through case"); }
 

src/rustc/middle/trans/native.rs

@@ -111,27 +111,28 @@ fn classify_ty(ty: TypeRef) -> [x86_64_reg_class] {
         }
     }
 
-    fn unify(cls: [mut x86_64_reg_class], i: uint,
-             new: x86_64_reg_class) {
-        if cls[i] == new {
+    fn unify(cls: [mut x86_64_reg_class],
+             i: uint,
+             newv: x86_64_reg_class) {
+        if cls[i] == newv {
             ret;
         } else if cls[i] == no_class {
-            cls[i] = new;
-        } else if new == no_class {
+            cls[i] = newv;
+        } else if newv == no_class {
             ret;
-        } else if cls[i] == memory_class || new == memory_class {
+        } else if cls[i] == memory_class || newv == memory_class {
             cls[i] = memory_class;
-        } else if cls[i] == integer_class || new == integer_class {
+        } else if cls[i] == integer_class || newv == integer_class {
             cls[i] = integer_class;
         } else if cls[i] == x87_class ||
                   cls[i] == x87up_class ||
                   cls[i] == complex_x87_class ||
-                  new == x87_class ||
-                  new == x87up_class ||
-                  new == complex_x87_class {
+                  newv == x87_class ||
+                  newv == x87up_class ||
+                  newv == complex_x87_class {
             cls[i] = memory_class;
         } else {
-            cls[i] = new;
+            cls[i] = newv;
         }
     }
 

src/rustc/middle/trans/type_use.rs

@@ -168,6 +168,9 @@ fn mark_for_expr(cx: ctx, e: @expr) {
       expr_log(_, _, val) {
         node_type_needs(cx, use_tydesc, val.id);
       }
+      expr_new(_, _, v) {
+        node_type_needs(cx, use_repr, v.id);
+      }
       expr_for(_, _, _) | expr_do_while(_, _) | expr_alt(_, _, _) |
       expr_block(_) | expr_if(_, _, _) | expr_while(_, _) |
       expr_fail(_) | expr_break | expr_cont | expr_unary(_, _) |

src/rustc/middle/tstate/ann.rs

@@ -183,14 +183,14 @@ fn set_poststate(a: ts_ann, p: poststate) -> bool {
 
 
 // Set all the bits in p that are set in new
-fn extend_prestate(p: prestate, new: poststate) -> bool {
-    ret tritv_union(p, new);
+fn extend_prestate(p: prestate, newv: poststate) -> bool {
+    ret tritv_union(p, newv);
 }
 
 
 // Set all the bits in p that are set in new
-fn extend_poststate(p: poststate, new: poststate) -> bool {
-    ret tritv_union(p, new);
+fn extend_poststate(p: poststate, newv: poststate) -> bool {
+    ret tritv_union(p, newv);
 }
 
 // Sets the given bit in p to "don't care"