---

yaml
---
r: 5201
b: refs/heads/master
c: 0e6e56c
h: refs/heads/master
i:
  5199: 234cd7d
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 4be7e1e5cd10646acc814da147f4e91dd610d45a
+refs/heads/master: 0e6e56ca606dc8cc1d5435c3929c11c489f3854b

trunk/src/comp/front/test.rs

@@ -290,7 +290,8 @@ fn mk_main(cx: &test_ctxt) -> @ast::item {
     let args_ty: ast::ty = nospan(ast::ty_vec(args_mt));
 
     let args_arg: ast::arg =
-        {mode: ast::val, ty: @args_ty, ident: "args", id: cx.next_node_id()};
+        {mode: ast::by_ref, ty: @args_ty, ident: "args",
+         id: cx.next_node_id()};
 
     let ret_ty = nospan(ast::ty_nil);
 

trunk/src/comp/metadata/tydecode.rs

@@ -379,16 +379,12 @@ fn parse_ty_fn(st: @pstate, sd: str_def) ->
     assert (next(st) as char == '[');
     let inputs: [ty::arg] = [];
     while peek(st) as char != ']' {
-        let mode = ty::mo_val;
+        let mode = ast::by_ref;
         if peek(st) as char == '&' {
-            mode = ty::mo_alias(false);
+            mode = ast::by_mut_ref;
             st.pos += 1u;
-            if peek(st) as char == 'm' {
-                mode = ty::mo_alias(true);
-                st.pos += 1u;
-            }
         } else if peek(st) as char == '-' {
-            mode = ty::mo_move;
+            mode = ast::by_move;
             st.pos += 1u;
         }
         inputs += [{mode: mode, ty: parse_ty(st, sd)}];

trunk/src/comp/metadata/tyencode.rs

@@ -207,12 +207,9 @@ fn enc_ty_fn(w: &io::writer, cx: &@ctxt, args: &[ty::arg], out: ty::t,
     w.write_char('[');
     for arg: ty::arg in args {
         alt arg.mode {
-          ty::mo_alias(mut) {
-            w.write_char('&');
-            if mut { w.write_char('m'); }
-          }
-          ty::mo_move. { w.write_char('-'); }
-          ty::mo_val. { }
+          by_mut_ref. { w.write_char('&'); }
+          by_move. { w.write_char('-'); }
+          by_ref. { }
         }
         enc_ty(w, cx, arg.ty);
     }

trunk/src/comp/middle/alias.rs

@@ -180,7 +180,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope)
     for arg_t: ty::arg in arg_ts {
         let arg = args[i];
         let root = expr_root(cx.tcx, arg, false);
-        if arg_t.mode == ty::mo_alias(true) {
+        if arg_t.mode == ast::by_mut_ref {
             alt path_def(cx, arg) {
               some(def) {
                 let dnum = ast_util::def_id_of_def(def).node;
@@ -202,7 +202,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope)
                depends_on: deps(sc, root_var),
                mutable ok: valid,
                // FIXME kludge
-               mutable given_up: arg_t.mode == ty::mo_move}];
+               mutable given_up: arg_t.mode == ast::by_move}];
         i += 1u;
     }
     let f_may_close =
@@ -228,7 +228,7 @@ fn check_call(cx: &ctx, f: &@ast::expr, args: &[@ast::expr], sc: &scope)
           some(ty) {
             let i = 0u;
             for arg_t: ty::arg in arg_ts {
-                let mut_alias = arg_t.mode == ty::mo_alias(true);
+                let mut_alias = arg_t.mode == ast::by_mut_ref;
                 if i != j &&
                    ty_can_unsafely_include(cx, ty, arg_t.ty, mut_alias) &&
                    cant_copy(cx, r) {

trunk/src/comp/middle/mut.rs

@@ -193,7 +193,9 @@ fn check_lval(cx: &@ctx, dest: &@expr, msg: msg) {
       _ {
         let root = expr_root(cx.tcx, dest, false);
         if vec::len(*root.ds) == 0u {
-            mk_err(cx, dest.span, msg, "non-lvalue");
+            if msg == msg_assign {
+                mk_err(cx, dest.span, msg, "non-lvalue");
+            }
         } else if !root.ds[0].mut {
             let name =
                 alt root.ds[0].kind {
@@ -235,7 +237,7 @@ fn check_call(cx: &@ctx, f: &@expr, args: &[@expr]) {
                        ty::type_autoderef(cx.tcx, ty::expr_ty(cx.tcx, f)));
     let i = 0u;
     for arg_t: ty::arg in arg_ts {
-        if arg_t.mode == ty::mo_alias(true) {
+        if arg_t.mode != by_ref {
             check_lval(cx, args[i], msg_mut_alias);
         }
         i += 1u;
@@ -249,7 +251,6 @@ fn is_immutable_def(def: &def) -> option::t<str> {
         some("static item")
       }
       def_obj_field(_, imm.) { some("immutable object field") }
-      def_arg(_, alias(false)) { some("immutable alias") }
       def_upvar(_, inner, mut) {
         if !mut { some("upvar") } else { is_immutable_def(*inner) }
       }

trunk/src/comp/middle/trans.rs

@@ -3516,7 +3516,7 @@ fn trans_arg_expr(cx: &@block_ctxt, arg: &ty::arg, lldestty0: TypeRef,
         // be inspected. It's important for the value
         // to have type lldestty0 (the callee's expected type).
         val = llvm::LLVMGetUndef(lldestty0);
-    } else if arg.mode == ty::mo_val || arg.mode == ty::mo_alias(false) {
+    } else if arg.mode == ast::by_ref {
         let copied = false;
         if !lv.is_mem && type_is_immediate(ccx, e_ty) {
             val = do_spill_noroot(bcx, val);
@@ -3545,7 +3545,7 @@ fn trans_arg_expr(cx: &@block_ctxt, arg: &ty::arg, lldestty0: TypeRef,
     }
 
     // Collect arg for later if it happens to be one we've moving out.
-    if arg.mode == ty::mo_move {
+    if arg.mode == ast::by_move {
         if lv.is_mem {
             // Use actual ty, not declared ty -- anything else doesn't make
             // sense if declared ty is a ty param
@@ -4241,7 +4241,7 @@ fn trans_put(in_cx: &@block_ctxt, e: &option::t<@ast::expr>) -> result {
       none. { }
       some(x) {
         let e_ty = ty::expr_ty(bcx_tcx(cx), x);
-        let arg = {mode: ty::mo_alias(false), ty: e_ty};
+        let arg = {mode: ast::by_ref, ty: e_ty};
         let arg_tys = type_of_explicit_args(bcx_ccx(cx), x.span, [arg]);
         let z = [];
         let k = [];
@@ -4867,7 +4867,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, scope: @block_ctxt, args: &[ast::arg],
     for aarg: ast::arg in args {
         let arg_ty = arg_tys[arg_n].ty;
         alt aarg.mode {
-          ast::val. | ast::alias(false) {
+          ast::by_ref. {
             let mutated = !ignore_mut &&
                 fcx.lcx.ccx.mut_map.contains_key(aarg.id);
             // Overwrite the llargs entry for locally mutated params
@@ -4881,7 +4881,7 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, scope: @block_ctxt, args: &[ast::arg],
                 add_clean(scope, alloc, arg_ty);
             }
           }
-          ast::move. {
+          ast::by_move. {
             add_clean(scope, bcx.fcx.llargs.get(aarg.id), arg_ty);
           }
           _ { }
@@ -5109,7 +5109,7 @@ fn trans_tag_variant(cx: @local_ctxt, tag_id: ast::node_id,
     let i = 0u;
     for varg: ast::variant_arg in variant.node.args {
         fn_args +=
-            [{mode: ast::alias(false),
+            [{mode: ast::by_ref,
               ty: varg.ty,
               ident: "arg" + uint::to_str(i, 10u),
               id: varg.id}];
@@ -5334,7 +5334,7 @@ fn create_main_wrapper(ccx: &@crate_ctxt, sp: &span, main_llfn: ValueRef,
                    takes_argv: bool) -> ValueRef {
         let unit_ty = ty::mk_str(ccx.tcx);
         let vecarg_ty: ty::arg =
-            {mode: ty::mo_val,
+            {mode: ast::by_ref,
              ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mut: ast::imm})};
         let llfty =
             type_of_fn(ccx, sp, ast::proto_fn, [vecarg_ty],
@@ -5528,7 +5528,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
     }
     fn convert_arg_to_i32(cx: &@block_ctxt, v: ValueRef, t: ty::t,
                           mode: ty::mode) -> ValueRef {
-        if mode == ty::mo_val {
+        if mode == ast::by_ref {
             if ty::type_is_integral(bcx_tcx(cx), t) {
                 // FIXME: would be nice to have a postcondition that says
                 // if a type is integral, then it has static size (#586)
@@ -5582,7 +5582,7 @@ fn decl_native_fn_and_pair(ccx: &@crate_ctxt, sp: &span, path: &[str],
     let i = arg_n;
     for arg: ty::arg in args {
         let llarg = llvm::LLVMGetParam(fcx.llfn, i);
-        if arg.mode == ty::mo_val {
+        if arg.mode == ast::by_ref {
             llarg = load_if_immediate(bcx, llarg, arg.ty);
         }
         assert (llarg as int != 0);

trunk/src/comp/middle/trans_common.rs

@@ -358,7 +358,7 @@ fn get_res_dtor(ccx: &@crate_ctxt, sp: &span, did: &ast::def_id,
     let params = csearch::get_type_param_count(ccx.sess.get_cstore(), did);
     let f_t =
         trans::type_of_fn(ccx, sp, ast::proto_fn,
-                          [{mode: ty::mo_alias(false), ty: inner_t}],
+                          [{mode: ast::by_ref, ty: inner_t}],
                           ty::mk_nil(ccx.tcx), params);
     ret trans::get_extern_const(ccx.externs, ccx.llmod,
                                 csearch::get_symbol(ccx.sess.get_cstore(),

trunk/src/comp/middle/trans_objects.rs

@@ -49,7 +49,7 @@ fn trans_obj(cx: @local_ctxt, sp: &span, ob: &ast::_obj,
     let fn_args: [ast::arg] = [];
     for f: ast::obj_field in ob.fields {
         fn_args +=
-            [{mode: ast::alias(false), ty: f.ty, ident: f.ident, id: f.id}];
+            [{mode: ast::by_ref, ty: f.ty, ident: f.ident, id: f.id}];
     }
     let fcx = new_fn_ctxt(cx, sp, llctor_decl);
 
@@ -689,12 +689,8 @@ fn process_bkwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
     // function (they're in fcx.llargs) to llouter_mthd_args.
 
     let a: uint = 3u; // retptr, task ptr, env come first
-    let passed_arg: ValueRef = llvm::LLVMGetParam(llbackwarding_fn, a);
     for arg: ty::arg in m.inputs {
-        if arg.mode == ty::mo_val {
-            passed_arg = load_if_immediate(bcx, passed_arg, arg.ty);
-        }
-        llouter_mthd_args += [passed_arg];
+        llouter_mthd_args += [llvm::LLVMGetParam(llbackwarding_fn, a)];
         a += 1u;
     }
 
@@ -861,12 +857,8 @@ fn process_fwding_mthd(cx: @local_ctxt, sp: &span, m: @ty::method,
     // function (they're in fcx.llargs) to llorig_mthd_args.
 
     let a: uint = 3u; // retptr, task ptr, env come first
-    let passed_arg: ValueRef = llvm::LLVMGetParam(llforwarding_fn, a);
     for arg: ty::arg in m.inputs {
-        if arg.mode == ty::mo_val {
-            passed_arg = load_if_immediate(bcx, passed_arg, arg.ty);
-        }
-        llorig_mthd_args += [passed_arg];
+        llorig_mthd_args += [llvm::LLVMGetParam(llforwarding_fn, a)];
         a += 1u;
     }
 

trunk/src/comp/middle/tstate/auxiliary.rs

@@ -1113,7 +1113,7 @@ fn callee_modes(fcx: &fn_ctxt, callee: node_id) -> [ty::mode] {
 
 fn callee_arg_init_ops(fcx: &fn_ctxt, callee: node_id) -> [init_op] {
     fn mode_to_op(m: &ty::mode) -> init_op {
-        alt m { ty::mo_move. { init_move } _ { init_assign } }
+        alt m { by_move. { init_move } _ { init_assign } }
     }
     vec::map(mode_to_op, callee_modes(fcx, callee))
 }

trunk/src/comp/middle/tstate/pre_post_conditions.rs

@@ -311,7 +311,7 @@ fn forget_args_moved_in(fcx: &fn_ctxt, parent: &@expr, modes: &[ty::mode],
                         operands: &[@expr]) {
     let i = 0u;
     for mode: ty::mode in modes {
-        if mode == ty::mo_move {
+        if mode == by_move {
             forget_in_postcond(fcx, parent.id, operands[i].id);
         }
         i += 1u;

trunk/src/comp/middle/ty.rs

@@ -86,9 +86,6 @@ export mk_uniq;
 export mk_var;
 export mk_iter_body_fn;
 export mode;
-export mo_val;
-export mo_alias;
-export mo_move;
 export mt;
 export node_type_table;
 export pat_ty;
@@ -177,7 +174,6 @@ export walk_ty;
 export occurs_check_fails;
 
 // Data types
-tag mode { mo_val; mo_alias(bool); mo_move; }
 
 type arg = {mode: mode, ty: t};
 
@@ -587,7 +583,7 @@ fn mk_type(_cx: &ctxt) -> t { ret idx_type; }
 fn mk_native(cx: &ctxt, did: &def_id) -> t { ret gen_ty(cx, ty_native(did)); }
 
 fn mk_iter_body_fn(cx: &ctxt, output: t) -> t {
-    ret mk_fn(cx, ast::proto_block, [{mode: ty::mo_alias(false), ty: output}],
+    ret mk_fn(cx, ast::proto_block, [{mode: ast::by_ref, ty: output}],
               ty::mk_nil(cx), ast::return, []);
 }
 

trunk/src/comp/middle/typeck.rs

@@ -20,9 +20,6 @@ import middle::ty::block_ty;
 import middle::ty::expr_ty;
 import middle::ty::field;
 import middle::ty::method;
-import middle::ty::mo_val;
-import middle::ty::mo_alias;
-import middle::ty::mo_move;
 import middle::ty::node_type_table;
 import middle::ty::pat_ty;
 import middle::ty::ty_param_substs_opt_and_ty;
@@ -213,15 +210,6 @@ fn instantiate_path(fcx: &@fn_ctxt, pth: &ast::path,
     ret {substs: ty_substs_opt, ty: tpt.ty};
 }
 
-fn ast_mode_to_mode(mode: ast::mode) -> ty::mode {
-    alt mode {
-      ast::val. { mo_val }
-      ast::alias(mut) { mo_alias(mut) }
-      ast::move. { mo_move }
-    }
-}
-
-
 // Type tests
 fn structurally_resolved_type(fcx: &@fn_ctxt, sp: &span, tp: ty::t) -> ty::t {
     alt ty::unify::resolve_type_structure(fcx.ccx.tcx, fcx.var_bindings, tp) {
@@ -282,8 +270,7 @@ fn ast_ty_to_ty(tcx: &ty::ctxt, getter: &ty_getter, ast_ty: &@ast::ty) ->
     tcx.ast_ty_to_ty_cache.insert(ast_ty, none::<ty::t>);
     fn ast_arg_to_arg(tcx: &ty::ctxt, getter: &ty_getter, arg: &ast::ty_arg)
        -> {mode: ty::mode, ty: ty::t} {
-        let ty_mode = ast_mode_to_mode(arg.node.mode);
-        ret {mode: ty_mode, ty: ast_ty_to_ty(tcx, getter, arg.node.ty)};
+        ret {mode: arg.node.mode, ty: ast_ty_to_ty(tcx, getter, arg.node.ty)};
     }
     fn ast_mt_to_mt(tcx: &ty::ctxt, getter: &ty_getter, mt: &ast::mt) ->
        ty::mt {
@@ -592,10 +579,9 @@ mod collect {
         ret tpt;
     }
     fn ty_of_arg(cx: @ctxt, a: &ast::arg) -> ty::arg {
-        let ty_mode = ast_mode_to_mode(a.mode);
         let f = bind getter(cx, _);
         let tt = ast_ty_to_ty(cx.tcx, f, a.ty);
-        ret {mode: ty_mode, ty: tt};
+        ret {mode: a.mode, ty: tt};
     }
     fn ty_of_method(cx: @ctxt, m: &@ast::method) -> ty::method {
         let get = bind getter(cx, _);
@@ -635,7 +621,7 @@ mod collect {
         for f: ast::obj_field in ob.fields {
             let g = bind getter(cx, _);
             let t_field = ast_ty_to_ty(cx.tcx, g, f.ty);
-            t_inputs += [{mode: ty::mo_alias(false), ty: t_field}];
+            t_inputs += [{mode: ast::by_ref, ty: t_field}];
         }
 
         let t_fn =
@@ -745,7 +731,7 @@ mod collect {
                 let args: [arg] = [];
                 for va: ast::variant_arg in variant.node.args {
                     let arg_ty = ast_ty_to_ty(cx.tcx, f, va.ty);
-                    args += [{mode: ty::mo_alias(false), ty: arg_ty}];
+                    args += [{mode: ast::by_ref, ty: arg_ty}];
                 }
                 let tag_t = ty::mk_tag(cx.tcx, tag_id, ty_param_tys);
                 // FIXME: this will be different for constrained types
@@ -1605,7 +1591,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
                                            } else { "s were" }]);
             // HACK: build an arguments list with dummy arguments to
             // check against
-            let dummy = {mode: ty::mo_val, ty: ty::mk_bot(fcx.ccx.tcx)};
+            let dummy = {mode: ast::by_ref, ty: ty::mk_bot(fcx.ccx.tcx)};
             arg_tys = vec::init_elt(dummy, supplied_arg_count);
         }
 
@@ -2018,9 +2004,8 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
         let convert = bind ast_ty_to_ty_crate_tyvar(fcx, _);
         let ty_of_arg =
             lambda (a: &ast::arg) -> ty::arg {
-                let ty_mode = ast_mode_to_mode(a.mode);
                 let tt = ast_ty_to_ty_crate_tyvar(fcx, a.ty);
-                ret {mode: ty_mode, ty: tt};
+                ret {mode: a.mode, ty: tt};
             };
         let fty =
             collect::ty_of_fn_decl(cx, convert, ty_of_arg, f.decl, f.proto,
@@ -2292,8 +2277,7 @@ fn check_expr_with_unifier(fcx: &@fn_ctxt, expr: &@ast::expr, unify: &unifier,
         // FIXME: These next three functions are largely ripped off from
         // similar ones in collect::.  Is there a better way to do this?
         fn ty_of_arg(ccx: @crate_ctxt, a: &ast::arg) -> ty::arg {
-            let ty_mode = ast_mode_to_mode(a.mode);
-            ret {mode: ty_mode, ty: ast_ty_to_ty_crate(ccx, a.ty)};
+            ret {mode: a.mode, ty: ast_ty_to_ty_crate(ccx, a.ty)};
         }
 
         fn ty_of_method(ccx: @crate_ctxt, m: &@ast::method) -> ty::method {

trunk/src/comp/syntax/ast.rs

@@ -127,7 +127,7 @@ tag binop {
 
 tag unop { box(mutability); deref; not; neg; }
 
-tag mode { val; alias(bool); move; }
+tag mode { by_ref; by_mut_ref; by_move; }
 
 type stmt = spanned<stmt_>;
 
@@ -296,7 +296,7 @@ tag ty_ {
      /* bot represents the value of functions that don't return a value
         locally to their context. in contrast, things like log that do
         return, but don't return a meaningful value, have result type nil. */
-     ty_bool;
+    ty_bool;
     ty_int;
     ty_uint;
     ty_float;