From d8db9a0fe1356ebdd702665e1844822a8a884b23 Mon Sep 17 00:00:00 2001 From: Tim Chevalier Date: Thu, 30 Jun 2011 09:00:44 -0700 Subject: [PATCH] Kill unused variables --- src/comp/back/link.rs | 1 - src/comp/front/fold.rs | 1 - src/comp/front/lexer.rs | 1 - src/comp/front/parser.rs | 15 ++----- src/comp/metadata/decoder.rs | 1 - src/comp/metadata/tydecode.rs | 9 ++--- src/comp/metadata/tyencode.rs | 2 +- src/comp/middle/alias.rs | 1 - src/comp/middle/trans.rs | 40 +++++-------------- src/comp/middle/tstate/auxiliary.rs | 1 - src/comp/middle/tstate/ck.rs | 3 +- src/comp/middle/tstate/collect_locals.rs | 8 ++-- src/comp/middle/tstate/pre_post_conditions.rs | 6 --- src/comp/middle/tstate/states.rs | 1 - src/comp/middle/ty.rs | 1 - src/comp/middle/typeck.rs | 28 +++++-------- src/comp/middle/walk.rs | 9 ++--- 17 files changed, 37 insertions(+), 91 deletions(-) diff --git a/src/comp/back/link.rs b/src/comp/back/link.rs index e331a0cbd80..0c016afd975 100644 --- a/src/comp/back/link.rs +++ b/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 diff --git a/src/comp/front/fold.rs b/src/comp/front/fold.rs index b6f82ce5be7..340793b9f23 100644 --- a/src/comp/front/fold.rs +++ b/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)) { diff --git a/src/comp/front/lexer.rs b/src/comp/front/lexer.rs index 5b88c46af8f..c688f79d7ca 100644 --- a/src/comp/front/lexer.rs +++ b/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); diff --git a/src/comp/front/parser.rs b/src/comp/front/parser.rs index 9a4e08f8e27..a3d20d23b6b 100644 --- a/src/comp/front/parser.rs +++ b/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,15 +863,12 @@ 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 @@ -879,7 +876,6 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { 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 @@ -887,7 +883,6 @@ fn parse_bottom_expr(&parser p) -> @ast::expr { 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, diff --git a/src/comp/metadata/decoder.rs b/src/comp/metadata/decoder.rs index c6e85b4b19c..b82029c21d2 100644 --- a/src/comp/metadata/decoder.rs +++ b/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); } diff --git a/src/comp/metadata/tydecode.rs b/src/comp/metadata/tydecode.rs index 9a18cabd587..0e19e3d2895 100644 --- a/src/comp/metadata/tydecode.rs +++ b/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), diff --git a/src/comp/metadata/tyencode.rs b/src/comp/metadata/tyencode.rs index 51cd5fcc89a..68168713130 100644 --- a/src/comp/metadata/tyencode.rs +++ b/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 { diff --git a/src/comp/middle/alias.rs b/src/comp/middle/alias.rs index b7f58dc4103..7475d623f71 100644 --- a/src/comp/middle/alias.rs +++ b/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); diff --git a/src/comp/middle/trans.rs b/src/comp/middle/trans.rs index b7022b3d20e..7ee18e68f14 100644 --- a/src/comp/middle/trans.rs +++ b/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: diff --git a/src/comp/middle/tstate/auxiliary.rs b/src/comp/middle/tstate/auxiliary.rs index 02a1798ad1b..9aa529c4e41 100644 --- a/src/comp/middle/tstate/auxiliary.rs +++ b/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) { diff --git a/src/comp/middle/tstate/ck.rs b/src/comp/middle/tstate/ck.rs index ebf5d7bab3c..679ac234a7e 100644 --- a/src/comp/middle/tstate/ck.rs +++ b/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 diff --git a/src/comp/middle/tstate/collect_locals.rs b/src/comp/middle/tstate/collect_locals.rs index f2e271f1afa..2ec43efe0c9 100644 --- a/src/comp/middle/tstate/collect_locals.rs +++ b/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 diff --git a/src/comp/middle/tstate/pre_post_conditions.rs b/src/comp/middle/tstate/pre_post_conditions.rs index 207fd7d3a90..ff3b6b8cf23 100644 --- a/src/comp/middle/tstate/pre_post_conditions.rs +++ b/src/comp/middle/tstate/pre_post_conditions.rs @@ -157,9 +157,6 @@ fn find_pre_post_exprs(&fn_ctxt fcx, &vec[@expr] args, node_id id) { log "find_pre_post_exprs: oper ="; log_expr(*args.(0)); } - auto enclosing = fcx.enclosing; - auto fm = fcx.ccx.fm; - auto nv = num_constraints(enclosing); fn do_one(fn_ctxt fcx, &@expr e) { find_pre_post_expr(fcx, e); } auto f = bind do_one(fcx, _); vec::map[@expr, ()](f, args); @@ -194,7 +191,6 @@ fn find_pre_post_loop(&fn_ctxt fcx, &@local l, &@expr index, &block body, // and alternative maybe_alt fn join_then_else(&fn_ctxt fcx, &@expr antec, &block conseq, &option::t[@expr] maybe_alt, node_id id, &if_ty chck) { - auto num_local_vars = num_constraints(fcx.enclosing); find_pre_post_expr(fcx, antec); find_pre_post_block(fcx, conseq); alt (maybe_alt) { @@ -580,8 +576,6 @@ fn find_pre_post_expr(&fn_ctxt fcx, @expr e) { fn find_pre_post_stmt(&fn_ctxt fcx, &stmt s) { log "stmt ="; log_stmt(s); - auto enclosing = fcx.enclosing; - auto num_local_vars = num_constraints(enclosing); alt (s.node) { case (stmt_decl(?adecl, ?id)) { alt (adecl.node) { diff --git a/src/comp/middle/tstate/states.rs b/src/comp/middle/tstate/states.rs index 44a9240fd5b..dc64f64e6df 100644 --- a/src/comp/middle/tstate/states.rs +++ b/src/comp/middle/tstate/states.rs @@ -670,7 +670,6 @@ fn find_pre_post_state_stmt(&fn_ctxt fcx, &prestate pres, @stmt s) -> bool { returns a boolean flag saying whether any pre- or poststates changed */ fn find_pre_post_state_block(&fn_ctxt fcx, &prestate pres0, &block b) -> bool { - auto num_local_vars = num_constraints(fcx.enclosing); /* First, set the pre-states and post-states for every expression */ auto pres = pres0; diff --git a/src/comp/middle/ty.rs b/src/comp/middle/ty.rs index 84f2dcbc67d..b4d36487db5 100644 --- a/src/comp/middle/ty.rs +++ b/src/comp/middle/ty.rs @@ -689,7 +689,6 @@ fn walk_ty(&ctxt cx, ty_walk walker, t ty) { walk_ty(cx, walker, ret_ty); } case (ty_obj(?methods)) { - let vec[method] new_methods = []; for (method m in methods) { for (arg a in m.inputs) { walk_ty(cx, walker, a.ty); } walk_ty(cx, walker, m.output); diff --git a/src/comp/middle/typeck.rs b/src/comp/middle/typeck.rs index 06c5a2e80ec..524c4262cf2 100644 --- a/src/comp/middle/typeck.rs +++ b/src/comp/middle/typeck.rs @@ -133,7 +133,6 @@ fn instantiate_path(&@fn_ctxt fcx, &ast::path pth, &ty_param_count_and_ty tpt, bind_params_in_type(sp, fcx.ccx.tcx, bind next_ty_var_id(fcx), tpt._1, ty_param_count); auto ty_param_vars = bind_result._0; - auto t = bind_result._1; auto ty_substs_opt; auto ty_substs_len = vec::len[@ast::ty](pth.node.types); if (ty_substs_len > 0u) { @@ -260,7 +259,6 @@ fn ast_ty_to_ty(&ty::ctxt tcx, &ty_getter getter, &@ast::ty ast_ty) -> ty::t { params_opt_and_ty._1); ret typ; } - auto mut = ast::imm; auto typ; auto cname = none[str]; alt (ast_ty.node) { @@ -691,12 +689,11 @@ mod collect { ty_params); } case (ast::item_obj(?object, ?ty_params, ?ctor_id)) { - // This calls ty_of_obj(). - - auto t_obj = ty_of_item(cx, it); // Now we need to call ty_of_obj_ctor(); this is the type that // we write into the table for this item. + ty_of_item(cx, it); + auto tpt = ty_of_obj_ctor(cx, it.ident, object, ctor_id, ty_params); write::ty_only(cx.tcx, ctor_id, tpt._1); @@ -924,7 +921,6 @@ fn are_compatible(&@fn_ctxt fcx, &ty::t expected, &ty::t actual) -> bool { // Returns the types of the arguments to a tag variant. fn variant_arg_types(&@crate_ctxt ccx, &span sp, &ast::def_id vid, &vec[ty::t] tag_ty_params) -> vec[ty::t] { - auto ty_param_count = vec::len[ty::t](tag_ty_params); let vec[ty::t] result = []; auto tpt = ty::lookup_item_type(ccx.tcx, vid); alt (ty::struct(ccx.tcx, tpt._1)) { @@ -1025,12 +1021,14 @@ mod writeback { fn visit_item_post(@mutable bool ignore, &@ast::item item) { *ignore = false; } - fn visit_fn_pre(@mutable bool ignore, &ast::_fn f, &vec[ast::ty_param] tps, - &span sp, &ast::fn_ident i, ast::node_id d) { + fn visit_fn_pre(@mutable bool ignore, &ast::_fn f, + &vec[ast::ty_param] tps, &span sp, + &ast::fn_ident i, ast::node_id d) { *ignore = true; } - fn visit_fn_post(@mutable bool ignore, &ast::_fn f, &vec[ast::ty_param] tps, - &span sp, &ast::fn_ident i, ast::node_id d) { + fn visit_fn_post(@mutable bool ignore, &ast::_fn f, + &vec[ast::ty_param] tps, &span sp, + &ast::fn_ident i, ast::node_id d) { *ignore = false; } fn keep_going(@mutable bool ignore) -> bool { ret !*ignore; } @@ -1555,7 +1553,6 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { write::ty_only_fixup(fcx, id, oper_t); } case (ast::expr_path(?pth)) { - auto t = ty::mk_nil(fcx.ccx.tcx); auto defn = fcx.ccx.tcx.def_map.get(id); auto tpt = ty_param_count_and_ty_for_def(fcx, expr.span, defn); if (ty::def_has_ty_params(defn)) { @@ -1627,7 +1624,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { write::nil_ty(fcx.ccx.tcx, id); } case (ast::expr_log(?l, ?e)) { - auto expr_t = check_expr(fcx, e); + check_expr(fcx, e); write::nil_ty(fcx.ccx.tcx, id); } case (ast::expr_check(_, ?e)) { @@ -1671,10 +1668,9 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { check_expr(fcx, rhs); auto rhs_t = expr_ty(fcx.ccx.tcx, rhs); auto chan_t = ty::mk_chan(fcx.ccx.tcx, rhs_t); - auto item_t; auto lhs_t = expr_ty(fcx.ccx.tcx, lhs); alt (structure_of(fcx, expr.span, lhs_t)) { - case (ty::ty_chan(?it)) { item_t = it; } + case (ty::ty_chan(?it)) { } case (_) { auto s = #fmt("mismatched types: expected chan \ but found %s", @@ -1755,7 +1751,6 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { // Now typecheck the blocks. auto result_ty = next_ty_var(fcx); - let vec[ast::block] blocks = []; for (ast::arm arm in arms) { check_block(fcx, arm.block); auto bty = block_ty(fcx.ccx.tcx, arm.block); @@ -2135,7 +2130,6 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { this_obj=di)); // Typecheck 'with_obj', if it exists. - let option::t[@ast::expr] with_obj = none[@ast::expr]; alt (anon_obj.with_obj) { case (none) { } case (some(?e)) { @@ -2192,7 +2186,7 @@ fn check_expr(&@fn_ctxt fcx, &@ast::expr expr) { for (@ast::method method in anon_obj.methods) { check_method(fcx.ccx, method); } - auto t = next_ty_var(fcx); + next_ty_var(fcx); // Now remove the info from the stack. vec::pop[obj_info](fcx.ccx.obj_infos); diff --git a/src/comp/middle/walk.rs b/src/comp/middle/walk.rs index 707eae8d30f..8821db4914a 100644 --- a/src/comp/middle/walk.rs +++ b/src/comp/middle/walk.rs @@ -39,8 +39,10 @@ type ast_visitor = fn(&@ast::ty) visit_ty_pre, fn(&@ast::ty) visit_ty_post, fn(&@ast::constr) visit_constr, - fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, ast::node_id) visit_fn_pre, - fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, ast::node_id) visit_fn_post); + fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, + ast::node_id) visit_fn_pre, + fn(&ast::_fn, &vec[ast::ty_param], &span, &ast::fn_ident, + ast::node_id) visit_fn_post); fn walk_crate(&ast_visitor v, &ast::crate c) { if (!v.keep_going()) { ret; } @@ -387,8 +389,6 @@ fn walk_expr(&ast_visitor v, @ast::expr e) { case (ast::expr_anon_obj(?anon_obj, _, _)) { // Fields - let option::t[vec[ast::anon_obj_field]] fields = - none[vec[ast::anon_obj_field]]; alt (anon_obj.fields) { case (none) { } case (some(?fields)) { @@ -400,7 +400,6 @@ fn walk_expr(&ast_visitor v, @ast::expr e) { } // with_obj - let option::t[@ast::expr] with_obj = none[@ast::expr]; alt (anon_obj.with_obj) { case (none) { } case (some(?e)) { walk_expr(v, e); }