---

yaml
---
r: 14063
b: refs/heads/try
c: 77b06d2
h: refs/heads/master
i:
  14061: 261ccd1
  14059: 42c4a59
  14055: 835601e
  14047: 52a3e5d
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: 5163606d060ccb2c6462d34f590e2a1f30ce4a1f
+refs/heads/try: 77b06d24cd76bf808138f1f7df4dcff40260ff38
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/comp/front/test.rs

@@ -382,7 +382,7 @@ 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::by_val,
+        {mode: ast::expl(ast::by_val),
          ty: @args_ty,
          ident: "args",
          id: cx.sess.next_node_id()};

branches/try/src/comp/metadata/tydecode.rs

@@ -353,7 +353,7 @@ fn parse_ty_fn(st: @pstate, conv: conv_did) -> ty::fn_ty {
           '#' { ast::by_val }
         };
         st.pos += 1u;
-        inputs += [{mode: mode, ty: parse_ty(st, conv)}];
+        inputs += [{mode: ast::expl(mode), ty: parse_ty(st, conv)}];
     }
     st.pos += 1u; // eat the ']'
     let cs = parse_constrs(st, conv);

branches/try/src/comp/metadata/tyencode.rs

@@ -203,16 +203,12 @@ fn enc_proto(w: io::writer, proto: proto) {
 fn enc_ty_fn(w: io::writer, cx: @ctxt, ft: ty::fn_ty) {
     w.write_char('[');
     for arg: ty::arg in ft.inputs {
-        alt arg.mode {
+        alt ty::resolved_mode(cx.tcx, arg.mode) {
           by_mut_ref { w.write_char('&'); }
           by_move { w.write_char('-'); }
           by_copy { w.write_char('+'); }
           by_ref { w.write_char('='); }
           by_val { w.write_char('#'); }
-          // tediously, this has to be there until there's a way
-          // to constraint post-typeck types not to contain a mode_infer
-          mode_infer { cx.tcx.sess.bug("enc_ty_fn: shouldn't see \
-            mode_infer"); }
         }
         enc_ty(w, cx, arg.ty);
     }

branches/try/src/comp/middle/alias.rs

@@ -82,9 +82,11 @@ fn visit_fn(cx: @ctx, _fk: visit::fn_kind, decl: ast::fn_decl,
     let fty = ty::node_id_to_type(cx.tcx, id);
     let args = ty::ty_fn_args(cx.tcx, fty);
     for arg in args {
-        if arg.mode == ast::by_val &&
-           ty::type_has_dynamic_size(cx.tcx, arg.ty) {
+        alt ty::resolved_mode(cx.tcx, arg.mode) {
+          ast::by_val if ty::type_has_dynamic_size(cx.tcx, arg.ty) {
             err(*cx, sp, "can not pass a dynamically-sized type by value");
+          }
+          _ { /* fallthrough */ }
         }
     }
 
@@ -226,26 +228,30 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
     for arg_t: ty::arg in arg_ts {
         let arg = args[i];
         let root = expr_root(cx, arg, false);
-        if arg_t.mode == ast::by_mut_ref {
+        alt ty::resolved_mode(cx.tcx, arg_t.mode) {
+          ast::by_mut_ref {
             alt path_def(cx, arg) {
               some(def) {
                 let dnum = ast_util::def_id_of_def(def).node;
                 mut_roots += [{arg: i, node: dnum}];
               }
               _ { }
             }
+          }
+          ast::by_ref | ast::by_val | ast::by_move | ast::by_copy { }
         }
         let root_var = path_def_id(cx, root.ex);
+        let arg_copied = alt ty::resolved_mode(cx.tcx, arg_t.mode) {
+          ast::by_move | ast::by_copy { copied }
+          ast::by_mut_ref { not_allowed }
+          ast::by_ref | ast::by_val { not_copied }
+        };
         bindings += [@{node_id: arg.id,
                        span: arg.span,
                        root_var: root_var,
                        local_id: 0u,
                        unsafe_tys: unsafe_set(root.mut),
-                       mutable copied: alt arg_t.mode {
-                         ast::by_move | ast::by_copy { copied }
-                         ast::by_mut_ref { not_allowed }
-                         _ { not_copied }
-                       }}];
+                       mutable copied: arg_copied}];
         i += 1u;
     }
     let f_may_close =
@@ -279,7 +285,8 @@ fn check_call(cx: ctx, sc: scope, f: @ast::expr, args: [@ast::expr])
         for unsafe_ty in b.unsafe_tys {
             let i = 0u;
             for arg_t: ty::arg in arg_ts {
-                let mut_alias = arg_t.mode == ast::by_mut_ref;
+                let mut_alias =
+                    (ast::by_mut_ref == ty::arg_mode(cx.tcx, arg_t));
                 if i != j &&
                        ty_can_unsafely_include(cx, unsafe_ty, arg_t.ty,
                                                mut_alias) &&

branches/try/src/comp/middle/block_use.rs

@@ -28,7 +28,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
         v.visit_expr(f, cx, v);
         let i = 0u;
         for arg_t in ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f)) {
-            cx.allow_block = arg_t.mode == by_ref;
+            cx.allow_block = (ty::arg_mode(cx.tcx, arg_t) == by_ref);
             v.visit_expr(args[i], cx, v);
             i += 1u;
         }

branches/try/src/comp/middle/kind.rs

@@ -165,7 +165,10 @@ fn check_expr(e: @expr, cx: ctx, v: visit::vt<ctx>) {
       expr_call(f, args, _) {
         let i = 0u;
         for arg_t in ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f)) {
-            alt arg_t.mode { by_copy { maybe_copy(cx, args[i]); } _ {} }
+            alt ty::arg_mode(cx.tcx, arg_t) {
+              by_copy { maybe_copy(cx, args[i]); }
+              by_ref | by_val | by_mut_ref | by_move { }
+            }
             i += 1u;
         }
       }

branches/try/src/comp/middle/last_use.rs

@@ -157,7 +157,7 @@ fn visit_expr(ex: @expr, cx: ctx, v: visit::vt<ctx>) {
                 fns += [arg];
               }
               _ {
-                alt arg_ts[i].mode {
+                alt ty::arg_mode(cx.tcx, arg_ts[i]) {
                   by_mut_ref { clear_if_path(cx, arg, v, false); }
                   _ { v.visit_expr(arg, cx, v); }
                 }
@@ -286,11 +286,21 @@ 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) {
+      def_local(def_id, let_copy) {
         clear_in_current(cx, def_id.node, to);
         some(def_id.node)
       }
+      def_arg(def_id, m) {
+        alt ty::resolved_mode(cx.tcx, m) {
+          by_copy | by_move {
+            clear_in_current(cx, def_id.node, to);
+            some(def_id.node)
+          }
+          by_ref | by_val | by_mut_ref {
+            none
+          }
+        }
+      }
       _ {
         none
       }

branches/try/src/comp/middle/mut.rs

@@ -228,10 +228,10 @@ fn check_call(cx: @ctx, f: @expr, args: [@expr]) {
     let arg_ts = ty::ty_fn_args(cx.tcx, ty::expr_ty(cx.tcx, f));
     let i = 0u;
     for arg_t: ty::arg in arg_ts {
-        alt arg_t.mode {
+        alt ty::resolved_mode(cx.tcx, arg_t.mode) {
           by_mut_ref { check_lval(cx, args[i], msg_mut_ref); }
           by_move { check_lval(cx, args[i], msg_move_out); }
-          _ {}
+          by_ref | by_val | by_copy { }
         }
         i += 1u;
     }
@@ -267,8 +267,12 @@ fn is_immutable_def(cx: @ctx, def: def) -> option<str> {
       def_use(_) {
         some("static item")
       }
-      def_arg(_, by_ref) | def_arg(_, by_val) |
-      def_arg(_, mode_infer) { some("argument") }
+      def_arg(_, m) {
+        alt ty::resolved_mode(cx.tcx, m) {
+          by_ref | by_val { some("argument") }
+          by_mut_ref | by_move | by_copy { none }
+        }
+      }
       def_self(_) { some("self argument") }
       def_upvar(_, inner, node_id) {
         let ty = ty::node_id_to_type(cx.tcx, node_id);

branches/try/src/comp/middle/trans/base.rs

@@ -63,16 +63,18 @@ fn type_of(cx: @crate_ctxt, t: ty::t) : type_has_static_size(cx, t)
 
 fn type_of_explicit_args(cx: @crate_ctxt, inputs: [ty::arg]) ->
    [TypeRef] {
-    let atys = [];
-    for arg in inputs {
+    let tcx = ccx_tcx(cx);
+    vec::map(inputs) {|arg|
         let arg_ty = arg.ty;
         // FIXME: would be nice to have a constraint on arg
         // that would obviate the need for this check
         check non_ty_var(cx, arg_ty);
         let llty = type_of_inner(cx, arg_ty);
-        atys += [if arg.mode == ast::by_val { llty } else { T_ptr(llty) }];
+        alt ty::resolved_mode(tcx, arg.mode) {
+          ast::by_val { llty }
+          _ { T_ptr(llty) }
+        }
     }
-    ret atys;
 }
 
 
@@ -2981,15 +2983,16 @@ fn trans_arg_expr(cx: @block_ctxt, arg: ty::arg, lldestty: TypeRef,
     let lv = trans_temp_lval(cx, e);
     let bcx = lv.bcx;
     let val = lv.val;
+    let arg_mode = ty::resolved_mode(ccx.tcx, arg.mode);
     if is_bot {
         // For values of type _|_, we generate an
         // "undef" value, as such a value should never
         // be inspected. It's important for the value
         // to have type lldestty (the callee's expected type).
         val = llvm::LLVMGetUndef(lldestty);
-    } else if arg.mode == ast::by_ref || arg.mode == ast::by_val {
+    } else if arg_mode == ast::by_ref || arg_mode == ast::by_val {
         let copied = false, imm = ty::type_is_immediate(ccx.tcx, e_ty);
-        if arg.mode == ast::by_ref && lv.kind != owned && imm {
+        if arg_mode == ast::by_ref && lv.kind != owned && imm {
             val = do_spill_noroot(bcx, val);
             copied = true;
         }
@@ -3002,10 +3005,10 @@ fn trans_arg_expr(cx: @block_ctxt, arg: ty::arg, lldestty: TypeRef,
             } else { bcx = take_ty(bcx, val, e_ty); }
             add_clean(bcx, val, e_ty);
         }
-        if arg.mode == ast::by_val && (lv.kind == owned || !imm) {
+        if arg_mode == ast::by_val && (lv.kind == owned || !imm) {
             val = Load(bcx, val);
         }
-        } else if arg.mode == ast::by_copy {
+        } else if arg_mode == ast::by_copy {
         let {bcx: cx, val: alloc} = alloc_ty(bcx, e_ty);
         let last_use = ccx.last_uses.contains_key(e.id);
         bcx = cx;
@@ -3031,7 +3034,7 @@ fn trans_arg_expr(cx: @block_ctxt, arg: ty::arg, lldestty: TypeRef,
     }
 
     // Collect arg for later if it happens to be one we've moving out.
-    if arg.mode == ast::by_move {
+    if arg_mode == ast::by_move {
         if lv.kind == owned {
             // Use actual ty, not declared ty -- anything else doesn't make
             // sense if declared ty is a ty param
@@ -4414,17 +4417,18 @@ fn create_llargs_for_fn_args(cx: @fn_ctxt, ty_self: self_arg,
 
 fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
                         arg_tys: [ty::arg]) -> @block_ctxt {
+    let tcx = bcx_tcx(bcx);
     let arg_n: uint = 0u, bcx = bcx;
-    fn epic_fail_(bcx: @block_ctxt) -> ! {
-        bcx_tcx(bcx).sess.bug("Someone forgot\
+    let epic_fail = fn@() -> ! {
+        tcx.sess.bug("Someone forgot\
                 to document an invariant in copy_args_to_allocas!");
     }
     let epic_fail = bind epic_fail_(bcx);
     for arg in arg_tys {
         let id = args[arg_n].id;
         let argval = alt fcx.llargs.get(id) { local_mem(v) { v }
                                               _ { epic_fail() } };
-        alt arg.mode {
+        alt ty::resolved_mode(tcx, arg.mode) {
           ast::by_mut_ref { }
           ast::by_move | ast::by_copy { add_clean(bcx, argval, arg.ty); }
           ast::by_val {
@@ -4438,7 +4442,6 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
             }
           }
           ast::by_ref {}
-          _ { epic_fail(); }
         }
         if fcx_ccx(fcx).sess.opts.extra_debuginfo {
             debuginfo::create_arg(bcx, args[arg_n], args[arg_n].ty.span);
@@ -4585,7 +4588,7 @@ fn trans_enum_variant(ccx: @crate_ctxt,
     // Translate variant arguments to function arguments.
     let fn_args = [], i = 0u;
     for varg in variant.node.args {
-        fn_args += [{mode: ast::by_copy,
+        fn_args += [{mode: ast::expl(ast::by_copy),
                      ty: varg.ty,
                      ident: "arg" + uint::to_str(i, 10u),
                      id: varg.id}];
@@ -5039,7 +5042,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: ast::by_val,
+            {mode: ast::expl(ast::by_val),
              ty: ty::mk_vec(ccx.tcx, {ty: unit_ty, mut: ast::imm})};
         // FIXME: mk_nil should have a postcondition
         let nt = ty::mk_nil(ccx.tcx);

branches/try/src/comp/middle/trans/closure.rs

@@ -895,13 +895,20 @@ fn trans_bind_thunk(ccx: @crate_ctxt,
                              [0, abi::closure_body_bindings, b]);
             bcx = bound_arg.bcx;
             let val = bound_arg.val;
-            if out_arg.mode == ast::by_val { val = Load(bcx, val); }
-            if out_arg.mode == ast::by_copy {
+
+            alt ty::resolved_mode(tcx, out_arg.mode) {
+              ast::by_val {
+                val = Load(bcx, val);
+              }
+              ast::by_copy {
                 let {bcx: cx, val: alloc} = alloc_ty(bcx, out_arg.ty);
                 bcx = memmove_ty(cx, alloc, val, out_arg.ty);
                 bcx = take_ty(bcx, alloc, out_arg.ty);
                 val = alloc;
+              }
+              ast::by_ref | ast::by_mut_ref | ast::by_move { }
             }
+
             // If the type is parameterized, then we need to cast the
             // type we actually have to the parameterized out type.
             if ty::type_contains_params(ccx.tcx, out_arg.ty) {

branches/try/src/comp/middle/trans/common.rs

@@ -300,7 +300,8 @@ fn get_res_dtor(ccx: @crate_ctxt, did: ast::def_id, inner_t: ty::t)
     let nil_res = ty::mk_nil(ccx.tcx);
     // FIXME: Silly check -- mk_nil should have a postcondition
     check non_ty_var(ccx, nil_res);
-    let f_t = type_of_fn(ccx, [{mode: ast::by_ref, ty: inner_t}],
+    let fn_mode = ast::expl(ast::by_ref);
+    let f_t = type_of_fn(ccx, [{mode: fn_mode, ty: inner_t}],
                          nil_res, *param_bounds);
     ret base::get_extern_const(ccx.externs, ccx.llmod,
                                 csearch::get_symbol(ccx.sess.cstore,

branches/try/src/comp/middle/trans/impl.rs

@@ -63,7 +63,8 @@ fn trans_impl(ccx: @crate_ctxt, path: path, name: ast::ident,
 fn trans_self_arg(bcx: @block_ctxt, base: @ast::expr) -> result {
     let tz = [], tr = [];
     let basety = expr_ty(bcx, base);
-    let {bcx, val} = trans_arg_expr(bcx, {mode: ast::by_ref, ty: basety},
+    let m_by_ref = ast::expl(ast::by_ref);
+    let {bcx, val} = trans_arg_expr(bcx, {mode: m_by_ref, ty: basety},
                                     T_ptr(type_of_or_i8(bcx, basety)), tz,
                                     tr, base);
     rslt(bcx, PointerCast(bcx, val, T_opaque_cbox_ptr(bcx_ccx(bcx))))

branches/try/src/comp/middle/tstate/auxiliary.rs

@@ -1089,10 +1089,12 @@ fn callee_modes(fcx: fn_ctxt, callee: node_id) -> [mode] {
 }
 
 fn callee_arg_init_ops(fcx: fn_ctxt, callee: node_id) -> [init_op] {
-    fn mode_to_op(m: mode) -> init_op {
-        alt m { by_move { init_move } _ { init_assign } }
+    vec::map(callee_modes(fcx, callee)) {|m|
+        alt ty::resolved_mode(fcx.ccx.tcx, m) {
+          by_move { init_move }
+          by_copy | by_ref | by_val | by_mut_ref { init_assign }
+        }
     }
-    vec::map(callee_modes(fcx, callee), mode_to_op)
 }
 
 fn anon_bindings(ops: [init_op], es: [@expr]) -> [binding] {

branches/try/src/comp/middle/tstate/pre_post_conditions.rs

@@ -276,12 +276,11 @@ fn handle_var_def(fcx: fn_ctxt, rslt: pre_and_post, def: def, name: ident) {
 
 fn forget_args_moved_in(fcx: fn_ctxt, parent: @expr, modes: [mode],
                         operands: [@expr]) {
-    let i = 0u;
-    for mode: mode in modes {
-        if mode == by_move {
-            forget_in_postcond(fcx, parent.id, operands[i].id);
+    vec::iteri(modes) {|i,mode|
+        alt ty::resolved_mode(fcx.ccx.tcx, mode) {
+          by_move { forget_in_postcond(fcx, parent.id, operands[i].id); }
+          by_ref | by_val | by_mut_ref | by_copy { }
         }
-        i += 1u;
     }
 }