Parse and typecheck by-value and by-ref arg specs

Add sprinkle && throughout the compiler to make it typecheck again.

Issue #1008

Author: marijnh

src/comp/front/attr.rs

@@ -57,7 +57,7 @@ fn get_attr_name(attr: ast::attribute) -> ast::ident {
 fn find_meta_items_by_name(metas: [@ast::meta_item], name: ast::ident) ->
    [@ast::meta_item] {
     let filter =
-        bind fn (m: @ast::meta_item, name: ast::ident) ->
+        bind fn (&&m: @ast::meta_item, name: ast::ident) ->
                 option::t<@ast::meta_item> {
                  if get_meta_item_name(m) == name {
                      option::some(m)
@@ -134,7 +134,7 @@ fn contains_name(metas: [@ast::meta_item], name: ast::ident) -> bool {
 
 // FIXME: This needs to sort by meta_item variant in addition to the item name
 fn sort_meta_items(items: [@ast::meta_item]) -> [@ast::meta_item] {
-    fn lteq(ma: @ast::meta_item, mb: @ast::meta_item) -> bool {
+    fn lteq(&&ma: @ast::meta_item, &&mb: @ast::meta_item) -> bool {
         fn key(m: @ast::meta_item) -> ast::ident {
             alt m.node {
               ast::meta_word(name) { name }
@@ -160,7 +160,7 @@ fn remove_meta_items_by_name(items: [@ast::meta_item], name: str) ->
    [@ast::meta_item] {
 
     let filter =
-        bind fn (item: @ast::meta_item, name: str) ->
+        bind fn (&&item: @ast::meta_item, name: str) ->
                 option::t<@ast::meta_item> {
                  if get_meta_item_name(item) != name {
                      option::some(item)

src/comp/front/config.rs

@@ -20,7 +20,7 @@ fn strip_unconfigured_items(crate: @ast::crate) -> @ast::crate {
     ret res;
 }
 
-fn filter_item(cfg: ast::crate_cfg, item: @ast::item) ->
+fn filter_item(cfg: ast::crate_cfg, &&item: @ast::item) ->
    option::t<@ast::item> {
     if item_in_cfg(cfg, item) { option::some(item) } else { option::none }
 }
@@ -29,11 +29,11 @@ fn fold_mod(cfg: ast::crate_cfg, m: ast::_mod, fld: fold::ast_fold) ->
    ast::_mod {
     let filter = bind filter_item(cfg, _);
     let filtered_items = vec::filter_map(filter, m.items);
-    ret {view_items: vec::map(fld.fold_view_item, m.view_items),
-         items: vec::map(fld.fold_item, filtered_items)};
+    ret {view_items: vec::map_imm(fld.fold_view_item, m.view_items),
+         items: vec::map_imm(fld.fold_item, filtered_items)};
 }
 
-fn filter_native_item(cfg: ast::crate_cfg, item: @ast::native_item) ->
+fn filter_native_item(cfg: ast::crate_cfg, &&item: @ast::native_item) ->
    option::t<@ast::native_item> {
     if native_item_in_cfg(cfg, item) {
         option::some(item)
@@ -46,11 +46,11 @@ fn fold_native_mod(cfg: ast::crate_cfg, nm: ast::native_mod,
     let filtered_items = vec::filter_map(filter, nm.items);
     ret {native_name: nm.native_name,
          abi: nm.abi,
-         view_items: vec::map(fld.fold_view_item, nm.view_items),
+         view_items: vec::map_imm(fld.fold_view_item, nm.view_items),
          items: filtered_items};
 }
 
-fn filter_stmt(cfg: ast::crate_cfg, stmt: @ast::stmt) ->
+fn filter_stmt(cfg: ast::crate_cfg, &&stmt: @ast::stmt) ->
    option::t<@ast::stmt> {
     alt stmt.node {
       ast::stmt_decl(decl, _) {
@@ -71,8 +71,8 @@ fn fold_block(cfg: ast::crate_cfg, b: ast::blk_, fld: fold::ast_fold) ->
    ast::blk_ {
     let filter = bind filter_stmt(cfg, _);
     let filtered_stmts = vec::filter_map(filter, b.stmts);
-    ret {stmts: vec::map(fld.fold_stmt, filtered_stmts),
-         expr: option::map(fld.fold_expr, b.expr),
+    ret {stmts: vec::map_imm(fld.fold_stmt, filtered_stmts),
+         expr: option::map_imm(fld.fold_expr, b.expr),
          id: b.id,
          rules: b.rules};
 }
@@ -97,21 +97,20 @@ fn in_cfg(cfg: ast::crate_cfg, attrs: [ast::attribute]) -> bool {
     // Pull the inner meta_items from the #[cfg(meta_item, ...)]  attributes,
     // so we can match against them. This is the list of configurations for
     // which the item is valid
-    let item_cfg_metas =
-        {
-            fn extract_metas(inner_items: [@ast::meta_item],
-                             cfg_item: @ast::meta_item) -> [@ast::meta_item] {
-                alt cfg_item.node {
-                  ast::meta_list(name, items) {
-                    assert (name == "cfg");
-                    inner_items + items
-                  }
-                  _ { inner_items }
-                }
+    let item_cfg_metas = {
+        fn extract_metas(inner_items: [@ast::meta_item],
+                         &&cfg_item: @ast::meta_item) -> [@ast::meta_item] {
+            alt cfg_item.node {
+              ast::meta_list(name, items) {
+                assert (name == "cfg");
+                inner_items + items
+              }
+              _ { inner_items }
             }
-            let cfg_metas = attr::attr_metas(item_cfg_attrs);
-            vec::foldl(extract_metas, [], cfg_metas)
-        };
+        }
+        let cfg_metas = attr::attr_metas(item_cfg_attrs);
+        vec::foldl(extract_metas, [], cfg_metas)
+    };
 
     for cfg_mi: @ast::meta_item in item_cfg_metas {
         if attr::contains(cfg, cfg_mi) { ret true; }

src/comp/front/test.rs

@@ -56,7 +56,7 @@ fn fold_mod(_cx: test_ctxt, m: ast::_mod, fld: fold::ast_fold) -> ast::_mod {
     // the one we're going to add.  FIXME: This is sloppy. Instead we should
     // have some mechanism to indicate to the translation pass which function
     // we want to be main.
-    fn nomain(item: @ast::item) -> option::t<@ast::item> {
+    fn nomain(&&item: @ast::item) -> option::t<@ast::item> {
         alt item.node {
           ast::item_fn(f, _) {
             if item.ident == "main" {

src/comp/lib/llvm.rs

@@ -909,9 +909,9 @@ obj type_names(type_names: std::map::hashmap<TypeRef, str>,
 fn mk_type_names() -> type_names {
     let nt = std::map::new_str_hash::<TypeRef>();
 
-    fn hash(t: TypeRef) -> uint { ret t as uint; }
+    fn hash(&&t: TypeRef) -> uint { ret t as uint; }
 
-    fn eq(a: TypeRef, b: TypeRef) -> bool { ret a as uint == b as uint; }
+    fn eq(&&a: TypeRef, &&b: TypeRef) -> bool { ret a as uint == b as uint; }
 
     let hasher: std::map::hashfn<TypeRef> = hash;
     let eqer: std::map::eqfn<TypeRef> = eq;

src/comp/metadata/common.rs

@@ -65,7 +65,7 @@ const tag_crate_dep: uint = 0x26u;
 const tag_items_data_item_inlineness: uint = 0x27u;
 
 // djb's cdb hashes.
-fn hash_node_id(node_id: int) -> uint { ret 177573u ^ (node_id as uint); }
+fn hash_node_id(&&node_id: int) -> uint { ret 177573u ^ (node_id as uint); }
 
 fn hash_path(s: str) -> uint {
     let h = 5381u;

src/comp/metadata/encoder.rs

@@ -427,7 +427,7 @@ fn encode_index<T>(ebml_w: ebml::writer, buckets: [@[entry<T>]],
 
 fn write_str(writer: io::writer, s: str) { writer.write_str(s); }
 
-fn write_int(writer: io::writer, n: int) {
+fn write_int(writer: io::writer, &&n: int) {
     writer.write_be_uint(n as uint, 4u);
 }
 

src/comp/metadata/tydecode.rs

@@ -380,14 +380,13 @@ 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 = ast::by_ref;
-        if peek(st) as char == '&' {
-            mode = ast::by_mut_ref;
-            st.pos += 1u;
-        } else if peek(st) as char == '-' {
-            mode = ast::by_move;
-            st.pos += 1u;
-        }
+        let mode = alt peek(st) as char {
+          '&' { ast::by_mut_ref }
+          '-' { ast::by_move }
+          '=' { ast::by_ref }
+          '+' { ast::by_val }
+        };
+        st.pos += 1u;
         inputs += [{mode: mode, ty: parse_ty(st, sd)}];
     }
     st.pos += 1u; // eat the ']'

src/comp/metadata/tyencode.rs

@@ -207,7 +207,8 @@ fn enc_ty_fn(w: io::writer, cx: @ctxt, args: [ty::arg], out: ty::t,
         alt arg.mode {
           by_mut_ref. { w.write_char('&'); }
           by_move. { w.write_char('-'); }
-          by_ref. { }
+          by_ref. { w.write_char('='); }
+          by_val. { w.write_char('+'); }
         }
         enc_ty(w, cx, arg.ty);
     }

src/comp/middle/alias.rs

@@ -251,10 +251,8 @@ fn check_call(cx: ctx, f: @ast::expr, args: [@ast::expr]) -> [binding] {
                        mutable ok: valid,
                        mutable copied: alt arg_t.mode {
                          ast::by_move. { copied }
-                         ast::by_ref. {
-                           i + 1u == by_ref ? not_allowed : not_copied
-                         }
                          ast::by_mut_ref. { not_allowed }
+                         _ { i + 1u == by_ref ? not_allowed : not_copied }
                        }}];
         i += 1u;
     }

src/comp/middle/ast_map.rs

@@ -76,7 +76,7 @@ fn map_expr(cx: ctx, ex: @expr) {
 }
 
 fn new_smallintmap_int_adapter<@V>() -> std::map::hashmap<int, V> {
-    let key_idx = fn (key: int) -> uint { key as uint };
+    let key_idx = fn (&&key: int) -> uint { key as uint };
     let idx_key = fn (idx: uint) -> int { idx as int };
     ret new_smallintmap_adapter(key_idx, idx_key);
 }

src/comp/middle/check_alt.rs

@@ -11,7 +11,7 @@ fn check_crate(tcx: ty::ctxt, crate: @crate) {
     tcx.sess.abort_if_errors();
 }
 
-fn check_expr(tcx: ty::ctxt, ex: @expr, s: (), v: visit::vt<()>) {
+fn check_expr(tcx: ty::ctxt, ex: @expr, &&s: (), v: visit::vt<()>) {
     visit::visit_expr(ex, s, v);
     alt ex.node { expr_alt(_, arms) { check_arms(tcx, arms); } _ { } }
 }
@@ -123,7 +123,7 @@ fn pattern_supersedes(tcx: ty::ctxt, a: @pat, b: @pat) -> bool {
     }
 }
 
-fn check_local(tcx: ty::ctxt, loc: @local, s: (), v: visit::vt<()>) {
+fn check_local(tcx: ty::ctxt, loc: @local, &&s: (), v: visit::vt<()>) {
     visit::visit_local(loc, s, v);
     if is_refutable(tcx, loc.node.pat) {
         tcx.sess.span_err(loc.node.pat.span,

src/comp/middle/freevars.rs

@@ -29,10 +29,10 @@ fn collect_freevars(def_map: resolve::def_map, walker: fn(visit::vt<int>)) ->
     let seen = new_int_hash();
     let refs = @mutable [];
 
-    fn ignore_item(_i: @ast::item, _depth: int, _v: visit::vt<int>) { }
+    fn ignore_item(_i: @ast::item, &&_depth: int, _v: visit::vt<int>) { }
 
     let walk_expr =
-        lambda (expr: @ast::expr, depth: int, v: visit::vt<int>) {
+        lambda (expr: @ast::expr, &&depth: int, v: visit::vt<int>) {
             alt expr.node {
               ast::expr_fn(f) {
                 if f.proto == ast::proto_block ||

src/comp/middle/mut.rs

@@ -131,7 +131,7 @@ fn mk_err(cx: @ctx, span: syntax::codemap::span, msg: msg, name: str) {
     });
 }
 
-fn visit_decl(cx: @ctx, d: @decl, e: (), v: visit::vt<()>) {
+fn visit_decl(cx: @ctx, d: @decl, &&e: (), v: visit::vt<()>) {
     visit::visit_decl(d, e, v);
     alt d.node {
       decl_local(locs) {
@@ -148,7 +148,7 @@ fn visit_decl(cx: @ctx, d: @decl, e: (), v: visit::vt<()>) {
     }
 }
 
-fn visit_expr(cx: @ctx, ex: @expr, e: (), v: visit::vt<()>) {
+fn visit_expr(cx: @ctx, ex: @expr, &&e: (), v: visit::vt<()>) {
     alt ex.node {
       expr_call(f, args) { check_call(cx, f, args); }
       expr_swap(lhs, rhs) {
@@ -225,7 +225,7 @@ fn check_call(cx: @ctx, f: @expr, args: [@expr]) {
         alt 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. {}
+          _ {}
         }
         i += 1u;
     }

src/comp/middle/resolve.rs

@@ -1239,7 +1239,7 @@ fn mie_span(mie: mod_index_entry) -> span {
         };
 }
 
-fn check_item(e: @env, i: @ast::item, x: (), v: vt<()>) {
+fn check_item(e: @env, i: @ast::item, &&x: (), v: vt<()>) {
     fn typaram_names(tps: [ast::ty_param]) -> [ident] {
         let x: [ast::ident] = [];
         for tp: ast::ty_param in tps { x += [tp.ident]; }
@@ -1276,7 +1276,7 @@ fn check_pat(ch: checker, p: @ast::pat) {
     }
 }
 
-fn check_arm(e: @env, a: ast::arm, x: (), v: vt<()>) {
+fn check_arm(e: @env, a: ast::arm, &&x: (), v: vt<()>) {
     visit::visit_arm(a, x, v);
     let ch0 = checker(*e, "binding");
     check_pat(ch0, a.pats[0]);
@@ -1306,7 +1306,7 @@ fn check_arm(e: @env, a: ast::arm, x: (), v: vt<()>) {
     }
 }
 
-fn check_block(e: @env, b: ast::blk, x: (), v: vt<()>) {
+fn check_block(e: @env, b: ast::blk, &&x: (), v: vt<()>) {
     visit::visit_block(b, x, v);
     let values = checker(*e, "value");
     let types = checker(*e, "type");
@@ -1359,7 +1359,7 @@ fn check_fn(e: env, sp: span, f: ast::_fn) {
     ensure_unique(e, sp, f.decl.inputs, arg_name, "argument");
 }
 
-fn check_expr(e: @env, ex: @ast::expr, x: (), v: vt<()>) {
+fn check_expr(e: @env, ex: @ast::expr, &&x: (), v: vt<()>) {
     alt ex.node {
       ast::expr_rec(fields, _) {
         fn field_name(f: ast::field) -> ident { ret f.node.ident; }
@@ -1370,7 +1370,7 @@ fn check_expr(e: @env, ex: @ast::expr, x: (), v: vt<()>) {
     visit::visit_expr(ex, x, v);
 }
 
-fn check_ty(e: @env, ty: @ast::ty, x: (), v: vt<()>) {
+fn check_ty(e: @env, ty: @ast::ty, &&x: (), v: vt<()>) {
     alt ty.node {
       ast::ty_rec(fields) {
         fn field_name(f: ast::ty_field) -> ident { ret f.node.ident; }

src/comp/middle/trans.rs

@@ -3699,7 +3699,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 == ast::by_ref {
+    } else if arg.mode == ast::by_ref || arg.mode == ast::by_val {
         let copied = false;
         if !lv.is_mem && type_is_immediate(ccx, e_ty) {
             val = do_spill_noroot(bcx, val);
@@ -4439,9 +4439,9 @@ fn lval_to_dps(bcx: @block_ctxt, e: @ast::expr, dest: dest) -> @block_ctxt {
 // latter group "immediates" and, in some circumstances when we know we have a
 // pointer (or need one), perform load/store operations based on the
 // immediate-ness of the type.
+// FIXME simply call the version in ty.rs immediately
 fn type_is_immediate(ccx: @crate_ctxt, t: ty::t) -> bool {
-    ret ty::type_is_scalar(ccx.tcx, t) || ty::type_is_boxed(ccx.tcx, t) ||
-        ty::type_is_unique_box(ccx.tcx, t) || ty::type_is_native(ccx.tcx, t);
+    ty::type_is_immediate(ccx.tcx, t)
 }
 
 fn do_spill(cx: @block_ctxt, v: ValueRef, t: ty::t) -> result {
@@ -5144,7 +5144,11 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
     for aarg: ast::arg in args {
         let arg_ty = arg_tys[arg_n].ty;
         alt aarg.mode {
-          ast::by_ref. {
+          ast::by_move. {
+            add_clean(bcx, fcx.llargs.get(aarg.id), arg_ty);
+          }
+          ast::by_mut_ref. { }
+          _ {
             let mutated =
                 !ignore_mut && fcx.lcx.ccx.mut_map.contains_key(aarg.id);
 
@@ -5160,10 +5164,6 @@ fn copy_args_to_allocas(fcx: @fn_ctxt, bcx: @block_ctxt, args: [ast::arg],
                 add_clean(bcx, alloc, arg_ty);
             }
           }
-          ast::by_move. {
-            add_clean(bcx, fcx.llargs.get(aarg.id), arg_ty);
-          }
-          _ { }
         }
         arg_n += 1u;
     }
@@ -5790,7 +5790,7 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str,
     }
     fn convert_arg_to_i32(cx: @block_ctxt, v: ValueRef, t: ty::t,
                           mode: ty::mode) -> ValueRef {
-        if mode == ast::by_ref {
+        if mode == ast::by_ref || mode == ast::by_val {
             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)
@@ -5845,7 +5845,7 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str,
     let i = arg_n;
     for arg: ty::arg in args {
         let llarg = llvm::LLVMGetParam(fcx.llfn, i);
-        if arg.mode == ast::by_ref {
+        if arg.mode == ast::by_ref || arg.mode == ast::by_val {
             llarg = load_if_immediate(bcx, llarg, arg.ty);
         }
         assert (llarg as int != 0);

src/comp/middle/trans_objects.rs

@@ -41,7 +41,8 @@ fn trans_obj(cx: @local_ctxt, sp: span, ob: ast::_obj, ctor_id: ast::node_id,
     // we're creating.
     let fn_args: [ast::arg] = [];
     for f: ast::obj_field in ob.fields {
-        fn_args += [{mode: ast::by_ref, ty: f.ty, ident: f.ident, id: f.id}];
+        fn_args += [{mode: ast::by_ref, ty: f.ty, ident: f.ident,
+                     id: f.id}];
     }
     let fcx = new_fn_ctxt(cx, sp, llctor_decl);
 
@@ -397,7 +398,7 @@ tag vtbl_mthd {
 }
 
 // Alphabetize ast::methods by ident.  A helper for create_vtbl.
-fn ast_mthd_lteq(a: @ast::method, b: @ast::method) -> bool {
+fn ast_mthd_lteq(&&a: @ast::method, &&b: @ast::method) -> bool {
     ret str::lteq(a.node.ident, b.node.ident);
 }