---

yaml
---
r: 3503
b: refs/heads/master
c: d8db9a0
h: refs/heads/master
i:
  3501: 2a0757c
  3499: 786fbe0
  3495: 0c9e06d
  3487: 12149db
v: v3

Author: catamorphism

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: a0cdb238920562467f390f0df69392bf70779384
+refs/heads/master: d8db9a0fe1356ebdd702665e1844822a8a884b23

trunk/src/comp/back/link.rs

@@ -137,7 +137,6 @@ mod write {
         if (is_object_or_assembly_or_exe(opts.output_type)) {
             let int LLVMAssemblyFile = 0;
             let int LLVMObjectFile = 1;
-            let int LLVMNullFile = 2;
             let int LLVMOptNone = 0;        // -O0
             let int LLVMOptLess = 1;        // -O1
             let int LLVMOptDefault = 2;     // -O2, -Os

trunk/src/comp/front/fold.rs

@@ -138,7 +138,6 @@ fn noop_fold_crate(&crate_ c, ast_fold fld) -> crate_ {
 
 fn noop_fold_crate_directive(&crate_directive_ cd, ast_fold fld) 
     -> crate_directive_ {
-    auto fold_meta_item = bind fold_meta_item_(_,fld);
     ret alt(cd) {
         case(cdir_expr(?e)) { cdir_expr(fld.fold_expr(e)) }
         case(cdir_let(?id, ?e, ?cds)) {

trunk/src/comp/front/lexer.rs

@@ -148,7 +148,6 @@ fn consume_block_comment(&reader rdr) {
 
 fn digits_to_string(str s) -> int {
     let int accum_int = 0;
-    let int i = 0;
     for (u8 c in s) {
         accum_int *= 10;
         accum_int += dec_digit_val(c as char);

trunk/src/comp/front/parser.rs

@@ -456,7 +456,7 @@ fn parse_ty(&parser p) -> @ast::ty {
     let ast::ty_ t;
     // FIXME: do something with this
 
-    let ast::layer lyr = parse_layer(p);
+    parse_layer(p);
     if (eat_word(p, "bool")) {
         t = ast::ty_bool;
     } else if (eat_word(p, "int")) {
@@ -863,31 +863,26 @@ fn parse_bottom_expr(&parser p) -> @ast::expr {
         ex = ast::expr_fail(msg);
     } else if (eat_word(p, "log")) {
         auto e = parse_expr(p);
-        auto hi = e.span.hi;
         ex = ast::expr_log(1, e);
     } else if (eat_word(p, "log_err")) {
         auto e = parse_expr(p);
-        auto hi = e.span.hi;
         ex = ast::expr_log(0, e);
     } else if (eat_word(p, "assert")) {
         auto e = parse_expr(p);
-        auto hi = e.span.hi;
         ex = ast::expr_assert(e);
     } else if (eat_word(p, "check")) {
         /* Should be a predicate (pure boolean function) applied to 
            arguments that are all either slot variables or literals.
            but the typechecker enforces that. */
 
         auto e = parse_expr(p);
-        auto hi = e.span.hi;
         ex = ast::expr_check(ast::checked, e);
     } else if (eat_word(p, "claim")) {
         /* Same rules as check, except that if check-claims
          is enabled (a command-line flag), then the parser turns
         claims into check */
 
         auto e = parse_expr(p);
-        auto hi = e.span.hi;
         ex = ast::expr_check(ast::unchecked, e);
     } else if (eat_word(p, "ret")) {
         alt (p.peek()) {
@@ -1253,7 +1248,6 @@ fn parse_if_expr_1(&parser p) -> tup(@ast::expr,
 }
 
 fn parse_if_expr(&parser p) -> @ast::expr {
-    auto lo = p.get_last_lo_pos();
     if (eat_word(p, "check")) {
             auto q = parse_if_expr_1(p);
             ret mk_expr(p, q._3, q._4, ast::expr_if_check(q._0, q._1, q._2));
@@ -1282,7 +1276,6 @@ fn parse_else_expr(&parser p) -> @ast::expr {
 }
 
 fn parse_head_local(&parser p) -> @ast::local {
-    auto lo = p.get_lo_pos();
     if (is_word(p, "auto")) {
         ret parse_auto_local(p);
     } else { 
@@ -1507,11 +1500,9 @@ fn parse_source_stmt(&parser p) -> @ast::stmt {
     auto lo = p.get_lo_pos();
     if (eat_word(p, "let")) {
         auto decl = parse_let(p);
-        auto hi = p.get_span();
         ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
     } else if (eat_word(p, "auto")) {
         auto decl = parse_auto(p);
-        auto hi = p.get_span();
         ret @spanned(lo, decl.span.hi, ast::stmt_decl(decl, p.get_id()));
     } else {
 
@@ -1918,7 +1909,7 @@ fn parse_item_native_fn(&parser p) -> @ast::native_item {
 }
 
 fn parse_native_item(&parser p) -> @ast::native_item {
-    let ast::layer lyr = parse_layer(p);
+    parse_layer(p);
     if (eat_word(p, "type")) {
         ret parse_item_native_type(p);
     } else if (eat_word(p, "fn")) {
@@ -2010,7 +2001,7 @@ fn parse_item_tag(&parser p, vec[ast::attribute] attrs) -> @ast::item {
                 }
                 auto vhi = p.get_hi_pos();
                 expect(p, token::SEMI);
-                auto id = p.get_id();
+                p.get_id();
                 auto vr =
                     rec(name=p.get_str(name),
                         args=args,

trunk/src/comp/metadata/decoder.rs

@@ -93,7 +93,6 @@ fn item_type(&ebml::doc item, int this_cnum, ty::ctxt tcx) -> ty::t {
         ret tup(this_cnum, external_def_id._1);
     }
     auto tp = ebml::get_doc(item, tag_items_data_item_type);
-    auto s = str::unsafe_from_bytes(ebml::doc_data(tp));
     ret parse_ty_data(item.data, this_cnum, tp.start, tp.end - tp.start,
                       bind parse_external_def_id(this_cnum, _), tcx);
 }

trunk/src/comp/metadata/tydecode.rs

@@ -64,7 +64,7 @@ fn parse_ty_data(vec[u8] data, int crate_num, uint pos, uint len, str_def sd,
 
 fn parse_ty_or_bang(@pstate st, str_def sd) -> ty_or_bang {
     alt (peek(st) as char) {
-        case ('!') { auto ignore = next(st); ret a_bang[ty::t]; }
+        case ('!') { next(st); ret a_bang[ty::t]; }
         case (_) { ret a_ty[ty::t](parse_ty(st, sd)); }
     }
 }
@@ -74,7 +74,7 @@ fn parse_constrs(@pstate st, str_def sd) -> vec[@ty::constr_def] {
     alt (peek(st) as char) {
         case (':') {
             do  {
-                auto ignore = next(st);
+                next(st);
                 vec::push(rslt, parse_constr(st, sd));
             } while (peek(st) as char == ';')
         }
@@ -91,10 +91,7 @@ fn parse_path(@pstate st, str_def sd) -> ast::path {
     idents += [parse_ident_(st, sd, is_last)];
     while (true) {
         alt (peek(st) as char) {
-            case (':') {
-                auto ignore = next(st);
-                ignore = next(st);
-            }
+            case (':') { next(st); next(st); }
             case (?c) {
                 if (c == '(') {
                     ret respan(rec(lo=0u, hi=0u),

trunk/src/comp/metadata/tyencode.rs

@@ -61,7 +61,7 @@ fn enc_ty(&io::writer w, &@ctxt cx, &ty::t t) {
                 case (some(?a)) { w.write_str(a.s); ret; }
                 case (none) {
                     auto pos = w.get_buf_writer().tell();
-                    auto ss = enc_sty(w, cx, ty::struct(cx.tcx, t));
+                    enc_sty(w, cx, ty::struct(cx.tcx, t));
                     auto end = w.get_buf_writer().tell();
                     auto len = end - pos;
                     fn estimate_sz(uint u) -> uint {

trunk/src/comp/middle/alias.rs

@@ -392,7 +392,6 @@ fn check_lval(&@ctx cx, &@ast::expr dest, &scope sc, &vt[scope] v) {
                 cx.tcx.sess.span_fatal(dest.span,
                                      "assigning to immutable obj field");
             }
-            auto var_t = ty::expr_ty(*cx.tcx, dest);
             for (restrict r in sc) {
                 if (vec::member(dnum, r.root_vars)) {
                     r.ok = overwritten(dest.span, p);

trunk/src/comp/middle/trans.rs

@@ -766,7 +766,6 @@ fn type_of_native_fn(&@crate_ctxt cx, &span sp, ast::native_abi abi,
     let vec[TypeRef] atys = [];
     if (abi == ast::native_abi_rust) {
         atys += [T_taskptr(cx.tn)];
-        auto t = ty::ty_native_fn(abi, inputs, output);
         auto i = 0u;
         while (i < ty_param_count) {
             atys += [T_ptr(T_tydesc(cx.tn))];
@@ -2684,7 +2683,6 @@ fn iter_structural_ty_full(&@block_ctxt cx, ValueRef av, ValueRef bv,
                         case (ty::ty_fn(_, ?args, _, _, _)) {
                             auto j = 0;
                             for (ty::arg a in args) {
-                                auto v = [C_int(0), C_int(j as int)];
                                 auto rslt =
                                     GEP_tag(variant_cx, llunion_a_ptr, tid,
                                             variant.id, tps, j);
@@ -3636,8 +3634,7 @@ mod ivec {
                 auto p = stack_spill_cx.build.InBoundsGEP(spill_stub, stub_p);
                 stack_spill_cx.build.Load(p)
             };
-        auto heap_len_ptr_spill =
-            {
+        {
                 auto v = [C_int(0), C_uint(abi::ivec_heap_elt_len)];
                 stack_spill_cx.build.InBoundsGEP(heap_ptr_spill, v)
             };
@@ -3673,10 +3670,9 @@ mod ivec {
 
         auto unit_ty = ty::sequence_element_type(cx.fcx.lcx.ccx.tcx, t);
         auto llunitty = type_of_or_i8(cx, unit_ty);
-        auto skip_null;
         alt (ty::struct(cx.fcx.lcx.ccx.tcx, t)) {
-            case (ty::ty_istr) { skip_null = true; }
-            case (ty::ty_ivec(_)) { skip_null = false; }
+            case (ty::ty_istr) {  }
+            case (ty::ty_ivec(_)) {  }
             case (_) {
                 cx.fcx.lcx.ccx.tcx.sess.bug("non-istr/ivec in trans_append");
             }
@@ -3692,10 +3688,8 @@ mod ivec {
         auto no_tydesc_info = none;
 
         rs = get_tydesc(bcx, t, false, no_tydesc_info);
-        auto vec_tydesc = rs.val;
         bcx = rs.bcx;
         rs = get_tydesc(bcx, unit_ty, false, no_tydesc_info);
-        auto unit_tydesc = rs.val;
         bcx = rs.bcx;
         lazily_emit_tydesc_glue(bcx, abi::tydesc_field_copy_glue, none);
         lazily_emit_tydesc_glue(bcx, abi::tydesc_field_drop_glue, none);
@@ -4516,7 +4510,6 @@ fn trans_for_each(&@block_ctxt cx, &@ast::local local, &@ast::expr seq,
     auto decl_ty = node_id_type(lcx.ccx, local.node.id);
     auto decl_id = local.node.id;
     auto upvars = collect_upvars(cx, body, decl_id);
-    auto upvar_count = vec::len(upvars);
 
     auto environment_data = build_environment(cx, upvars);
     auto llenvptr = environment_data._0;
@@ -4791,7 +4784,6 @@ fn lval_generic_fn(&@block_ctxt cx, &ty::ty_param_count_and_ty tpt,
         lv = trans_external_path(cx, fn_id, tpt);
     }
     auto tys = ty::node_id_to_type_params(cx.fcx.lcx.ccx.tcx, id);
-    auto monoty = ty::node_id_to_type(cx.fcx.lcx.ccx.tcx, id);
     if (vec::len[ty::t](tys) != 0u) {
         auto bcx = lv.res.bcx;
         let vec[ValueRef] tydescs = [];
@@ -5299,7 +5291,7 @@ fn trans_bind_thunk(&@local_ctxt cx, &span sp, &ty::t incoming_fty,
                    outgoing_args, outgoing_ret_ty, ty_param_count);
     lltargetfn = bcx.build.PointerCast(lltargetfn, T_ptr(T_ptr(lltargetty)));
     lltargetfn = bcx.build.Load(lltargetfn);
-    auto r = bcx.build.FastCall(lltargetfn, llargs);
+    bcx.build.FastCall(lltargetfn, llargs);
     bcx.build.RetVoid();
     finish_fn(fcx, lltop);
     ret llthunk;
@@ -6459,7 +6451,6 @@ fn trans_port(&@block_ctxt cx, ast::node_id id) -> result {
         case (ty::ty_port(?t)) { unit_ty = t; }
         case (_) { cx.fcx.lcx.ccx.sess.bug("non-port type in trans_port"); }
     }
-    auto llunit_ty = type_of(cx.fcx.lcx.ccx, cx.sp, unit_ty);
     auto bcx = cx;
     auto unit_sz = size_of(bcx, unit_ty);
     bcx = unit_sz.bcx;
@@ -6587,7 +6578,6 @@ fn trans_spawn(&@block_ctxt cx, &ast::spawn_dom dom, &option::t[str] name,
 fn mk_spawn_wrapper(&@block_ctxt cx, &@ast::expr func, &ty::t args_ty) ->
    result {
     auto llmod = cx.fcx.lcx.ccx.llmod;
-    let TypeRef args_ty_tref = type_of(cx.fcx.lcx.ccx, cx.sp, args_ty);
     let TypeRef wrapper_fn_type =
         type_of_fn(cx.fcx.lcx.ccx, cx.sp, ast::proto_fn,
                    [rec(mode=ty::mo_alias(false), ty=args_ty)], ty::idx_nil,
@@ -6669,8 +6659,6 @@ fn deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t, ValueRef target_task)
     } 
     else if(ty::type_is_structural(tcx, t)) {
         fn inner_deep_copy(&@block_ctxt bcx, ValueRef v, ty::t t) -> result {
-            auto tcx = bcx.fcx.lcx.ccx.tcx;
-    
             log_err "Unimplemented type for deep_copy.";
             fail;
         }
@@ -6841,7 +6829,6 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
 
     // If with_obj (the object being extended) exists, translate it, producing
     // a result.
-    let option::t[result] with_obj_val = none;
     let ty::t with_obj_ty = ty::mk_type(ccx.tcx);
     let TypeRef llwith_obj_ty;
     auto vtbl;
@@ -6857,7 +6844,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
         case (some(?e)) {
             // Translating with_obj returns a ValueRef (pointer to a 2-word
             // value) wrapped in a result.
-            with_obj_val  = some[result](trans_expr(bcx, e));
+            trans_expr(bcx, e);
 
             // TODO: What makes more sense to get the type of an expr --
             // calling ty::expr_ty(ccx.tcx, e) on it or calling
@@ -6992,7 +6979,7 @@ fn trans_anon_obj(@block_ctxt bcx, &span sp, &ast::anon_obj anon_obj,
             // FIXME (part of issue #538): make this work eventually, when we
             // have additional field exprs in the AST.
 
-            auto field_val = load_if_immediate(
+            load_if_immediate(
                 bcx,
                 additional_field_vals.(i).val,
                 additional_field_tys.(i));
@@ -7992,7 +7979,6 @@ fn trans_const_expr(&@crate_ctxt cx, @ast::expr e) -> ValueRef {
 }
 
 fn trans_const(&@crate_ctxt cx, @ast::expr e, ast::node_id id) {
-    auto t = node_id_type(cx, id);
     auto v = trans_const_expr(cx, e);
     // The scalars come back as 1st class LLVM vals
     // which we have to stick into global constants.
@@ -8179,15 +8165,9 @@ fn decl_native_fn_and_pair(&@crate_ctxt ccx, &span sp, vec[str] path,
     auto lltop = bcx.llbb;
     // Declare the function itself.
 
-    auto item = alt (ccx.ast_map.get(id)) {
-        case (ast_map::node_native_item(?i)) { i }
-    };
     auto fn_type = node_id_type(ccx, id); // NB: has no type params
 
     auto abi = ty::ty_fn_abi(ccx.tcx, fn_type);
-    auto llfnty =
-        type_of_native_fn(ccx, sp, abi, ty::ty_fn_args(ccx.tcx, fn_type),
-                          ty::ty_fn_ret(ccx.tcx, fn_type), num_ty_param);
     // FIXME: If the returned type is not nil, then we assume it's 32 bits
     // wide. This is obviously wildly unsafe. We should have a better FFI
     // that allows types of different sizes to be returned.
@@ -8561,11 +8541,11 @@ fn make_common_glue(&session::session sess, &str output) {
                                                 llvm::LLVMGetGlobalContext());
     llvm::LLVMSetDataLayout(llmod, str::buf(x86::get_data_layout()));
     llvm::LLVMSetTarget(llmod, str::buf(x86::get_target_triple()));
-    auto td = mk_target_data(x86::get_data_layout());
+    mk_target_data(x86::get_data_layout());
     auto tn = mk_type_names();
-    auto intrinsics = declare_intrinsics(llmod);
+    declare_intrinsics(llmod);
     llvm::LLVMSetModuleInlineAsm(llmod, str::buf(x86::get_module_asm()));
-    auto glues = make_glues(llmod, tn);
+    make_glues(llmod, tn);
     link::write::run_passes(sess, llmod, output);
 }
 
@@ -8686,7 +8666,7 @@ fn trans_crate(&session::session sess, &@ast::crate crate, &ty::ctxt tcx,
     collect_tag_ctors(ccx, crate);
     trans_constants(ccx, crate);
     trans_mod(cx, crate.node.module);
-    auto crate_map = create_crate_map(ccx);
+    create_crate_map(ccx);
     emit_tydescs(ccx);
     // Translate the metadata:
 

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

@@ -97,7 +97,6 @@ fn log_tritv(&fn_ctxt fcx, &tritv::t v) { log tritv_to_str(fcx, v); }
 fn first_difference_string(&fn_ctxt fcx, &tritv::t expected, &tritv::t actual)
    -> str {
     let str s = "";
-    auto done = false;
     for (norm_constraint c in constraints(fcx)) {
         if (tritv_get(expected, c.bit_num) == ttrue &&
             tritv_get(actual, c.bit_num) != ttrue) {

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

@@ -124,7 +124,8 @@ fn check_states_stmt(&fn_ctxt fcx, &@stmt s) {
     }
 }
 
-fn check_states_against_conditions(&fn_ctxt fcx, &_fn f, &vec[ast::ty_param] tps,
+fn check_states_against_conditions(&fn_ctxt fcx, &_fn f,
+                                   &vec[ast::ty_param] tps,
                                    node_id id, &span sp, &fn_ident i) {
     /* Postorder traversal instead of pre is important
        because we want the smallest possible erroneous statement

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

@@ -60,7 +60,8 @@ fn collect_pred(&@expr e, &ctxt cx, &visit::vt[ctxt] v) {
     visit::visit_expr(e, cx, v);
 }
 
-fn do_nothing(&@item i, &ctxt ignore1, &visit::vt[ctxt] ignore) {
+fn do_nothing(&_fn f, &vec[ty_param] tp, &span sp, &fn_ident i,
+              node_id iid, &ctxt cx, &visit::vt[ctxt] v) {
 }
 
 fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ast::ty_param] tps,
@@ -72,7 +73,7 @@ fn find_locals(&ty::ctxt tcx, &_fn f, &vec[ast::ty_param] tps,
     visitor =
         @rec(visit_local=collect_local,
              visit_expr=collect_pred,
-             visit_item=do_nothing
+             visit_fn=do_nothing
              with *visitor);
     visit::visit_fn(f, tps, sp, i, id, cx, visit::vtor(visitor));
     ret cx;
@@ -119,9 +120,6 @@ fn mk_fn_info(&crate_ctxt ccx, &_fn f, &vec[ast::ty_param] tp,
               node_id id) {
     auto res_map = @new_int_hash[constraint]();
     let uint next = 0u;
-    let vec[arg] f_args = f.decl.inputs;
-    /* ignore args, which we know are initialized;
-       just collect locally declared vars */
 
     let ctxt cx = find_locals(ccx.tcx, f, tp, f_sp, f_name, id);
     /* now we have to add bit nums for both the constraints