---

yaml
---
r: 3014
b: refs/heads/master
c: fccf065
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 798bbd2e226c17024252192f939ce5c9ae59a99b
+refs/heads/master: fccf0652661f8f76875655628e6a61d7e00bd856

trunk/src/comp/front/ast.rs

@@ -203,7 +203,7 @@ fn unop_to_str(unop op) -> str {
 
 tag mode {
     val;
-    alias;
+    alias(bool);
 }
 
 type stmt = spanned[stmt_];

trunk/src/comp/front/creader.rs

@@ -328,8 +328,12 @@ fn parse_ty_fn(@pstate st, str_def sd) -> tup(vec[ty::arg], ty::t,
     while (peek(st) as char != ']') {
         auto mode = ty::mo_val;
         if (peek(st) as char == '&') {
-            mode = ty::mo_alias;
-            st.pos = st.pos + 1u;
+            mode = ty::mo_alias(false);
+            st.pos += 1u;
+            if (peek(st) as char == 'm') {
+                mode = ty::mo_alias(true);
+                st.pos += 1u;
+            }
         }
         inputs += [rec(mode=mode, ty=parse_ty(st, sd))];
     }

trunk/src/comp/front/parser.rs

@@ -319,16 +319,10 @@ fn parse_ty_fn(ast::proto proto, &parser p, uint lo)
     -> ast::ty_ {
     fn parse_fn_input_ty(&parser p) -> ast::ty_arg {
         auto lo = p.get_lo_pos();
-        auto mode;
+        auto mode = ast::val;
         if (p.peek() == token::BINOP(token::AND)) {
             p.bump();
-            mode = ast::alias;
-
-            if (eat_word(p, "mutable")) {
-                // TODO: handle mutable alias args
-            }
-        } else {
-            mode = ast::val;
+            mode = ast::alias(eat_word(p, "mutable"));
         }
 
         auto t = parse_ty(p);
@@ -598,11 +592,8 @@ fn parse_ty(&parser p) -> @ast::ty {
 fn parse_arg(&parser p) -> ast::arg {
     let ast::mode m = ast::val;
     if (p.peek() == token::BINOP(token::AND)) {
-        m = ast::alias;
         p.bump();
-
-        // TODO: handle mutable alias args
-        eat_word(p, "mutable");
+        m = ast::alias(eat_word(p, "mutable"));
     }
     let @ast::ty t = parse_ty(p);
     let ast::ident i = parse_value_ident(p);

trunk/src/comp/middle/alias.rs

@@ -23,7 +23,12 @@ type restrict = @rec(vec[def_num] root_vars,
                      vec[uint] depends_on,
                      mutable valid ok);
 
-type scope = vec[restrict];
+type scope = rec(vec[tup(def_num, ast::mode)] args,
+                 vec[restrict] rs);
+fn scope(&scope sc, vec[restrict] add) -> scope {
+    ret rec(args=sc.args, rs=sc.rs + add);
+}
+
 type ctx = rec(@ty::ctxt tcx,
                resolve::def_map dm);
 
@@ -32,13 +37,17 @@ fn check_crate(@ty::ctxt tcx, resolve::def_map dm, &@ast::crate crate) {
     auto v = @rec(visit_fn = visit_fn,
                   visit_expr = bind visit_expr(cx, _, _, _)
                   with *visit::default_visitor[scope]());
-    visit::visit_crate(*crate, [], visit::vtor(v));
+    visit::visit_crate(*crate, rec(args=[], rs=[]), visit::vtor(v));
 }
 
 fn visit_fn(&ast::_fn f, &vec[ast::ty_param] tp, &span sp, &ident name,
             &ast::def_id d_id, &ast::ann a, &scope sc, &vt[scope] v) {
     visit::visit_fn_decl(f.decl, sc, v);
-    vt(v).visit_block(f.body, [], v);
+    auto args = [];
+    for (ast::arg arg in f.decl.inputs) {
+        vec::push(args, tup(arg.id._1, arg.mode));
+    }
+    vt(v).visit_block(f.body, rec(args=args, rs=[]), v);
 }
 
 fn visit_expr(&@ctx cx, &@ast::expr ex, &scope sc, &vt[scope] v) {
@@ -179,12 +188,12 @@ fn check_alt(&ctx cx, &@ast::expr input, &vec[ast::arm] arms,
         auto dnums = arm_defnums(a);
         auto new_sc = sc;
         if (vec::len(dnums) > 0u) {
-            vec::push(new_sc, @rec(root_vars=roots,
-                                   block_defnum=dnums.(0),
-                                   bindings=dnums,
-                                   tys=forbidden_tp,
-                                   depends_on=deps(sc, roots),
-                                   mutable ok=valid));
+            new_sc = scope(sc, [@rec(root_vars=roots,
+                                     block_defnum=dnums.(0),
+                                     bindings=dnums,
+                                     tys=forbidden_tp,
+                                     depends_on=deps(sc, roots),
+                                     mutable ok=valid)]);
         }
         visit::visit_arm(a, new_sc, v);
     }
@@ -225,7 +234,7 @@ fn check_for_each(&ctx cx, &@ast::decl decl, &@ast::expr call,
                                tys=data.unsafe_ts,
                                depends_on=deps(sc, data.root_vars),
                                mutable ok=valid);
-            visit::visit_block(block, sc + [new_sc], v);
+            visit::visit_block(block, scope(sc, [new_sc]), v);
         }
     }
 }
@@ -261,7 +270,7 @@ fn check_for(&ctx cx, &@ast::decl decl, &@ast::expr seq,
                        tys=unsafe,
                        depends_on=deps(sc, root_def),
                        mutable ok=valid);
-    visit::visit_block(block, sc + [new_sc], v);
+    visit::visit_block(block, scope(sc, [new_sc]), v);
 }
 
 fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::ann ann, bool assign,
@@ -270,7 +279,7 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::ann ann, bool assign,
     if (!def_is_local(def)) { ret; }
     auto my_defnum = ast::def_id_of_def(def)._1;
     auto var_t = ty::expr_ty(*cx.tcx, ex);
-    for (restrict r in sc) {
+    for (restrict r in sc.rs) {
         // excludes variables introduced since the alias was made
         if (my_defnum < r.block_defnum) {
             for (ty::t t in r.tys) {
@@ -287,14 +296,29 @@ fn check_var(&ctx cx, &@ast::expr ex, &ast::path p, ast::ann ann, bool assign,
 fn check_assign(&@ctx cx, &@ast::expr dest, &@ast::expr src,
                 &scope sc, &vt[scope] v) {
     visit_expr(cx, src, sc, v);
+    
     alt (dest.node) {
         case (ast::expr_path(?p, ?ann)) {
             auto dnum = ast::def_id_of_def(cx.dm.get(ann.id))._1;
+
+            for (tup(def_num, ast::mode) arg in sc.args) {
+                if (arg._0 == dnum && arg._1 == ast::alias(false)) {
+                    cx.tcx.sess.span_err
+                        (dest.span, "assigning to immutable alias");
+                }
+            }
+
             auto var_t = ty::expr_ty(*cx.tcx, dest);
-            for (restrict r in sc) {
+            for (restrict r in sc.rs) {
                 if (vec::member(dnum, r.root_vars)) {
                     r.ok = overwritten(dest.span, p);
                 }
+                for (def_num bnd in r.bindings) {
+                    if (dnum == bnd) {
+                        cx.tcx.sess.span_err
+                            (dest.span, "assigning to immutable alias");
+                    }
+                }
             }
             check_var(*cx, dest, p, ann, true, sc);
         }
@@ -308,7 +332,7 @@ fn test_scope(&ctx cx, &scope sc, &restrict r, &ast::path p) {
     auto prob = r.ok;
     for (uint dep in r.depends_on) {
         if (prob != valid) { break; }
-        prob = sc.(dep).ok;
+        prob = sc.rs.(dep).ok;
     }
     if (prob != valid) {
         auto msg = alt (prob) {
@@ -328,7 +352,7 @@ fn test_scope(&ctx cx, &scope sc, &restrict r, &ast::path p) {
 fn deps(&scope sc, vec[def_num] roots) -> vec[uint] {
     auto i = 0u;
     auto result = [];
-    for (restrict r in sc) {
+    for (restrict r in sc.rs) {
         for (def_num dn in roots) {
             if (vec::member(dn, r.bindings)) {
                 vec::push(result, i);

trunk/src/comp/middle/metadata.rs

@@ -250,7 +250,13 @@ mod Encode {
                  &ast::controlflow cf, &vec[@ast::constr] constrs) {
         w.write_char('[');
         for (ty::arg arg in args) {
-            if (arg.mode == ty::mo_alias) { w.write_char('&'); }
+            alt (arg.mode) {
+                case (ty::mo_alias(?mut)) {
+                    w.write_char('&');
+                    if (mut) { w.write_char('m'); }
+                }
+                case (ty::mo_val) {}
+            }
             enc_ty(w, cx, arg.ty);
         }
         w.write_char(']');

trunk/src/comp/middle/trans.rs

@@ -691,12 +691,12 @@ fn type_of_explicit_args(&@crate_ctxt cx, &span sp,
     let vec[TypeRef] atys = [];
     for (ty::arg arg in inputs) {
         if (ty::type_has_dynamic_size(cx.tcx, arg.ty)) {
-            assert (arg.mode == ty::mo_alias);
+            assert (arg.mode != ty::mo_val);
             atys += [T_typaram_ptr(cx.tn)];
         } else {
            let TypeRef t;
             alt (arg.mode) {
-                case (ty::mo_alias) {
+                case (ty::mo_alias(_)) {
                     t = T_ptr(type_of_inner(cx, sp, arg.ty));
                 }
                 case (_) {
@@ -762,9 +762,9 @@ fn type_of_fn_full(&@crate_ctxt cx,
         atys +=
             [T_fn_pair(cx.tn,
                        type_of_fn_full(cx, sp, ast::proto_fn, none[TypeRef],
-                                          [rec(mode=ty::mo_alias,
-                                                  ty=output)],
-                                          ty::mk_nil(cx.tcx), 0u))];
+                                       [rec(mode=ty::mo_alias(false),
+                                            ty=output)],
+                                       ty::mk_nil(cx.tcx), 0u))];
     }
 
     // ... then explicit args.
@@ -923,7 +923,7 @@ fn type_of_inner(&@crate_ctxt cx, &span sp, &ty::t t) -> TypeRef {
 fn type_of_arg(@local_ctxt cx, &span sp, &ty::arg arg) -> TypeRef {
     alt (ty::struct(cx.ccx.tcx, arg.ty)) {
         case (ty::ty_param(_)) {
-            if (arg.mode == ty::mo_alias) {
+            if (arg.mode != ty::mo_val) {
                 ret T_typaram_ptr(cx.ccx.tn);
             }
         }
@@ -933,7 +933,7 @@ fn type_of_arg(@local_ctxt cx, &span sp, &ty::arg arg) -> TypeRef {
     }
 
     auto typ;
-    if (arg.mode == ty::mo_alias) {
+    if (arg.mode != ty::mo_val) {
         typ = T_ptr(type_of_inner(cx.ccx, sp, arg.ty));
     } else {
         typ = type_of_inner(cx.ccx, sp, arg.ty);
@@ -4063,7 +4063,7 @@ fn trans_for_each(&@block_ctxt cx,
     auto iter_body_llty =
         type_of_fn_full(lcx.ccx, cx.sp, ast::proto_fn,
                         none[TypeRef],
-                        [rec(mode=ty::mo_alias, ty=decl_ty)],
+                        [rec(mode=ty::mo_alias(false), ty=decl_ty)],
                         ty::mk_nil(lcx.ccx.tcx), 0u);
 
     let ValueRef lliterbody = decl_internal_fastcall_fn(lcx.ccx.llmod,
@@ -4840,7 +4840,7 @@ fn trans_bind_thunk(&@local_ctxt cx,
                     }
                 } else if (ty::type_contains_params(cx.ccx.tcx,
                                                    out_arg.ty)) {
-                    assert (out_arg.mode == ty::mo_alias);
+                    assert (out_arg.mode != ty::mo_val);
                     val = bcx.build.PointerCast(val, llout_arg_ty);
                 }
 
@@ -4853,7 +4853,7 @@ fn trans_bind_thunk(&@local_ctxt cx,
                 let ValueRef passed_arg = llvm::LLVMGetParam(llthunk, a);
 
                 if (ty::type_contains_params(cx.ccx.tcx, out_arg.ty)) {
-                    assert (out_arg.mode == ty::mo_alias);
+                    assert (out_arg.mode != ty::mo_val);
                     passed_arg = bcx.build.PointerCast(passed_arg,
                                                        llout_arg_ty);
                 }
@@ -5098,7 +5098,7 @@ fn trans_arg_expr(&@block_ctxt cx,
         auto re = trans_expr(bcx, e);
         val = re.val;
         bcx = re.bcx;
-    } else if (arg.mode == ty::mo_alias) {
+    } else if (arg.mode != ty::mo_val) {
         let lval_result lv;
         if (ty::is_lval(e)) {
             lv = trans_lval(bcx, e);
@@ -5125,7 +5125,7 @@ fn trans_arg_expr(&@block_ctxt cx,
         bcx = re.bcx;
     }
 
-    if (arg.mode != ty::mo_alias) {
+    if (arg.mode == ty::mo_val) {
         bcx = take_ty(bcx, val, e_ty).bcx;
     }
 
@@ -5930,7 +5930,7 @@ fn trans_put(&@block_ctxt cx, &option::t[@ast::expr] e) -> result {
         case (none) { }
         case (some(?x)) {
             auto e_ty = ty::expr_ty(cx.fcx.lcx.ccx.tcx, x);
-            auto arg = rec(mode=ty::mo_alias, ty=e_ty);
+            auto arg = rec(mode=ty::mo_alias(false), ty=e_ty);
             auto arg_tys = type_of_explicit_args(cx.fcx.lcx.ccx,
                                                  x.span, [arg]);
             auto r = trans_arg_expr(bcx, arg, arg_tys.(0), x);
@@ -6194,7 +6194,7 @@ fn mk_spawn_wrapper(&@block_ctxt cx,
 
     let TypeRef wrapper_fn_type =
         type_of_fn(cx.fcx.lcx.ccx, cx.sp, ast::proto_fn,
-                   [rec(mode = ty::mo_alias, ty = args_ty)],
+                   [rec(mode = ty::mo_alias(false), ty = args_ty)],
                    ty::idx_nil,
                    0u);
 
@@ -6401,7 +6401,7 @@ fn trans_anon_obj(@block_ctxt cx, &span sp,
         case (some(?fields)) {
             addtl_fields = fields;
             for (ast::obj_field f in fields) {
-                addtl_fn_args += [rec(mode=ast::alias, ty=f.ty, 
+                addtl_fn_args += [rec(mode=ast::alias(false), ty=f.ty, 
                                       ident=f.ident, id=f.id)];
             }
         }
@@ -7045,7 +7045,7 @@ fn copy_args_to_allocas(@fn_ctxt fcx,
 
     let uint arg_n = 0u;
     for (ast::arg aarg in args) {
-        if (aarg.mode != ast::alias) {
+        if (aarg.mode == ast::val) {
             auto arg_t = type_of_arg(bcx.fcx.lcx, fcx.sp, arg_tys.(arg_n));
             auto a = alloca(bcx, arg_t);
             auto argval = bcx.fcx.llargs.get(aarg.id);
@@ -7063,7 +7063,7 @@ fn add_cleanups_for_args(&@block_ctxt bcx,
                          vec[ty::arg] arg_tys) {
     let uint arg_n = 0u;
     for (ast::arg aarg in args) {
-        if (aarg.mode != ast::alias) {
+        if (aarg.mode == ast::val) {
             auto argval = bcx.fcx.llargs.get(aarg.id);
             find_scope_cx(bcx).cleanups +=
                 [clean(bind drop_slot(_, argval, arg_tys.(arg_n).ty))];
@@ -7329,7 +7329,8 @@ fn trans_obj(@local_ctxt cx, &span sp, &ast::_obj ob, ast::def_id oid,
     // we're creating.
     let vec[ast::arg] fn_args = [];
     for (ast::obj_field f in ob.fields) {
-        fn_args += [rec(mode=ast::alias, ty=f.ty, ident=f.ident, id=f.id)];
+        fn_args += [rec(mode=ast::alias(false),
+                        ty=f.ty, ident=f.ident, id=f.id)];
     }
     auto fcx = new_fn_ctxt(cx, sp, llctor_decl);
 
@@ -7522,10 +7523,10 @@ fn trans_tag_variant(@local_ctxt cx, ast::def_id tag_id,
     let vec[ast::arg] fn_args = [];
     auto i = 0u;
     for (ast::variant_arg varg in variant.node.args) {
-        fn_args += [rec(mode=ast::alias,
-                           ty=varg.ty,
-                           ident="arg" + uint::to_str(i, 10u),
-                           id=varg.id)];
+        fn_args += [rec(mode=ast::alias(false),
+                        ty=varg.ty,
+                        ident="arg" + uint::to_str(i, 10u),
+                        id=varg.id)];
     }
 
     assert (cx.ccx.item_ids.contains_key(variant.node.id));

trunk/src/comp/middle/ty.rs

@@ -41,7 +41,7 @@ import util::data::interner;
 
 tag mode {
     mo_val;
-    mo_alias;
+    mo_alias(bool);
 }
 
 type arg = rec(mode mode, t ty);