Cleanup unused imports

Author: lht

src/comp/back/link.rs

@@ -7,23 +7,18 @@ import metadata::{encoder, cstore};
 import middle::trans_common::crate_ctxt;
 import std::str;
 import std::fs;
-import std::os;
 import std::vec;
 import std::option;
 import std::run;
 import option::some;
 import option::none;
 import std::sha1::sha1;
-import std::sort;
 import syntax::ast;
 import syntax::print::pprust;
 import lib::llvm::llvm::ModuleRef;
-import lib::llvm::llvm::ValueRef;
 import lib::llvm::mk_pass_manager;
 import lib::llvm::mk_target_data;
-import lib::llvm::mk_type_names;
 import lib::llvm::False;
-import lib::llvm::True;
 import util::filesearch;
 
 tag output_type {

src/comp/back/target_strs.rs

@@ -1,9 +1,7 @@
-import std::str;
-
 type t = {
     module_asm: str,
     meta_sect_name: str,
     data_layout: str,
     target_triple: str,
     gcc_args: [str]
-};
+};

src/comp/back/upcall.rs

@@ -1,11 +1,9 @@
 
-import std::str;
 import driver::session;
 import middle::trans;
-import trans::decl_cdecl_fn;
-import middle::trans_common::{T_f32, T_f64, T_fn, T_bool, T_i1, T_i8, T_i32,
-                              T_i64, T_int, T_vec, T_nil, T_opaque_chan_ptr,
-                              T_opaque_vec, T_opaque_port_ptr, T_ptr,
+import middle::trans_common::{T_fn, T_i1, T_i8, T_i32,
+                              T_i64, T_int, T_nil,
+                              T_opaque_vec, T_ptr,
                               T_size_t, T_void, T_float};
 import lib::llvm::type_names;
 import lib::llvm::llvm::ModuleRef;

src/comp/back/x86.rs

@@ -1,6 +1,3 @@
-import lib::llvm::llvm;
-import lib::llvm::llvm::ModuleRef;
-import std::str;
 import driver::session;
 
 fn get_target_strs(target_os: session::os) -> target_strs::t {

src/comp/back/x86_64.rs

@@ -1,6 +1,3 @@
-import lib::llvm::llvm;
-import lib::llvm::llvm::ModuleRef;
-import std::str;
 import driver::session;
 
 fn get_target_strs(target_os: session::os) -> target_strs::t {

src/comp/driver/rustc.rs

@@ -2,20 +2,16 @@
 
 // -*- rust -*-
 import metadata::{creader, cstore};
-import syntax::parse::{parser, token};
+import syntax::parse::{parser};
 import syntax::{ast, codemap};
 import front::attr;
 import middle::{trans, resolve, freevars, kind, ty, typeck, fn_usage};
-import middle::tstate::ck;
 import syntax::print::{pp, pprust};
-import util::{ppaux, common, filesearch};
+import util::{ppaux, filesearch};
 import back::link;
-import lib::llvm;
-import std::{fs, option, str, vec, int, io, run, getopts, result};
-import std::map::mk_hashmap;
+import std::{option, str, vec, int, io, getopts, result};
 import std::option::{some, none};
 import std::getopts::{optopt, optmulti, optflag, optflagopt, opt_present};
-import back::link::output_type;
 import back::{x86, x86_64};
 
 tag pp_mode { ppm_normal; ppm_expanded; ppm_typed; ppm_identified; }

src/comp/driver/session.rs

@@ -3,7 +3,7 @@ import syntax::{ast, codemap};
 import syntax::ast::node_id;
 import codemap::span;
 import syntax::ast::ty_mach;
-import std::{uint, map, option, str};
+import std::{option};
 import std::option::{some, none};
 import syntax::parse::parser::parse_sess;
 import util::filesearch;

src/comp/front/attr.rs

@@ -1,8 +1,7 @@
 // Functions dealing with attributes and meta_items
 
-import std::{vec, str, map, option};
+import std::{vec, map, option};
 import syntax::{ast, ast_util};
-import util::common;
 import driver::session;
 
 export attr_meta;

src/comp/front/test.rs

@@ -1,6 +1,6 @@
 // Code that generates a test runner to run all the tests in a crate
 
-import std::{option, vec, str};
+import std::{option, vec};
 import syntax::{ast, ast_util};
 import syntax::ast_util::*;
 //import syntax::ast_util::dummy_sp;

src/comp/lib/llvm.rs

@@ -1,10 +1,8 @@
 import std::{vec, str, option};
 import std::str::sbuf;
 
-import llvm::{ModuleRef, ContextRef, TypeRef, TypeHandleRef, ValueRef,
-              BasicBlockRef, BuilderRef, ModuleProviderRef, MemoryBufferRef,
-              PassManagerRef, UseRef, TargetDataRef, Linkage, Attribute,
-              Visibility, CallConv, IntPredicate, RealPredicate, Opcode,
+import llvm::{TypeRef, MemoryBufferRef,
+              PassManagerRef, TargetDataRef,
               ObjectFileRef, SectionIteratorRef};
 
 type ULongLong = u64;

src/comp/metadata/creader.rs

@@ -4,11 +4,9 @@ import driver::session;
 import syntax::{ast, ast_util};
 import lib::llvm::{False, llvm, mk_object_file, mk_section_iter};
 import front::attr;
-import middle::resolve;
 import syntax::visit;
 import syntax::codemap::span;
-import back::x86;
-import util::{common, filesearch};
+import util::{filesearch};
 import std::{vec, str, fs, io, option};
 import std::option::{none, some};
 import std::map::{hashmap, new_int_hash};

src/comp/metadata/decoder.rs

@@ -1,13 +1,11 @@
 // Decoding metadata from a single crate's metadata
 
 import std::{ebml, vec, option, str, io};
-import std::map::hashmap;
 import syntax::{ast, ast_util};
 import front::attr;
 import middle::ty;
 import common::*;
 import tydecode::{parse_def_id, parse_ty_data};
-import driver::session;
 import syntax::print::pprust;
 import cstore;
 

src/comp/metadata/encoder.rs

@@ -1,7 +1,6 @@
 // Metadata encoding
 
-import std::{vec, str, uint, io, option, ebml, map};
-import std::option::{some, none};
+import std::{vec, str, uint, io, ebml, map};
 import syntax::ast::*;
 import syntax::ast_util;
 import syntax::ast_util::local_def;

src/comp/metadata/tydecode.rs

@@ -1,6 +1,6 @@
 // Type decoding
 
-import std::{vec, str, uint, option};
+import std::{vec, str, uint};
 import std::option::{none, some};
 import syntax::ast;
 import syntax::ast::*;

src/comp/metadata/tyencode.rs

@@ -1,12 +1,11 @@
 // Type encoding
 
-import std::{str, io, int, uint};
+import std::{io, int, uint};
 import std::map::hashmap;
 import std::option::{some, none};
 import syntax::ast::*;
 import middle::ty;
 import syntax::print::pprust::*;
-import util::common;
 
 export ctxt;
 export ty_abbrev;

src/comp/middle/alias.rs

@@ -1,10 +1,10 @@
 
 import syntax::{ast, ast_util};
-import ast::{ident, fn_ident, node_id, def_id};
+import ast::{ident, fn_ident, node_id};
 import syntax::codemap::span;
 import syntax::visit;
 import visit::vt;
-import std::{vec, str, option};
+import std::{vec, option};
 import std::option::{some, none, is_none};
 
 // This is not an alias-analyser (though it would merit from becoming one, or

src/comp/middle/ast_map.rs

@@ -2,7 +2,6 @@ import std::{smallintmap, option};
 import syntax::ast::*;
 import syntax::ast_util;
 import syntax::{visit, codemap};
-import visit::vt;
 
 tag ast_node {
     node_item(@item);

src/comp/middle/check_const.rs

@@ -1,5 +1,4 @@
 import syntax::ast::*;
-import syntax::ast_util::{variant_def_ids, dummy_sp};
 import syntax::visit;
 
 fn check_crate(tcx: ty::ctxt, crate: @crate) {

src/comp/middle/fn_usage.rs

@@ -1,7 +1,7 @@
 import syntax::ast;
 import syntax::visit;
 import std::option::some;
-import syntax::print::pprust::{expr_to_str, path_to_str};
+import syntax::print::pprust::expr_to_str;
 
 export check_crate_fn_usage;
 

src/comp/middle/freevars.rs

@@ -1,11 +1,10 @@
 // A pass that annotates for each loops and functions with the free
 // variables that they contain.
 
-import std::{map, option, int, str};
+import std::{int};
 import std::map::*;
 import std::option::*;
 import syntax::{ast, ast_util, visit};
-import driver::session;
 import middle::resolve;
 import syntax::codemap::span;
 

src/comp/middle/gc.rs

@@ -1,13 +1,13 @@
 // Routines useful for garbage collection.
 
-import lib::llvm::{True, False};
+import lib::llvm::True;
 import lib::llvm::llvm::ValueRef;
 import middle::trans;
 import middle::trans::{get_tydesc, tps_normal};
 import middle::trans_common::*;
 import middle::ty;
-import std::option::{some, none};
-import std::{ptr, str, unsafe, vec};
+import std::option::none;
+import std::str;
 
 import lll = lib::llvm::llvm;
 import bld = trans_build;

src/comp/middle/kind.rs

@@ -85,7 +85,7 @@
 */
 
 import syntax::{ast, ast_util, visit, codemap};
-import std::{vec, option, str};
+import std::{vec, option};
 import ast::{kind, kind_unique, kind_shared, kind_pinned};
 
 fn kind_lteq(a: kind, b: kind) -> bool {

src/comp/middle/resolve.rs

@@ -2,17 +2,16 @@
 import syntax::{ast, ast_util, codemap};
 import syntax::ast::*;
 import ast::{ident, fn_ident, def, def_id, node_id};
-import syntax::ast_util::{local_def, respan};
+import syntax::ast_util::local_def;
 
 import metadata::{csearch, cstore};
 import driver::session::session;
 import util::common::*;
 import std::map::{new_int_hash, new_str_hash};
 import syntax::codemap::span;
-import middle::ty::constr_table;
 import syntax::visit;
 import visit::vt;
-import std::{vec, int, list, option, str};
+import std::{vec, list, option, str};
 import std::map::hashmap;
 import std::list::{list, nil, cons};
 import std::option::{some, none, is_none};

src/comp/middle/shape.rs

@@ -4,14 +4,12 @@
 import lib::llvm::True;
 import lib::llvm::llvm::{ModuleRef, TypeRef, ValueRef};
 import middle::{trans, trans_common};
-import middle::trans::llsize_of;
-import middle::trans_common::{crate_ctxt, val_ty, C_bytes, C_int,
-                              C_named_struct, C_struct, C_uint, T_i8, T_ptr};
+import middle::trans_common::{crate_ctxt, val_ty, C_bytes,
+                              C_named_struct, C_struct};
 import middle::ty;
-import middle::ty::{field, mt};
+import middle::ty::field;
 import syntax::ast;
 import syntax::ast_util::dummy_sp;
-import syntax::codemap::span;
 import syntax::util::interner;
 import util::common;
 

src/comp/middle/trans.rs

@@ -12,32 +12,29 @@
 //     pcwalton).  You can, instead, find out its TypeRef by calling val_ty,
 //     but many TypeRefs correspond to one ty::t; for instance, tup(int, int,
 //     int) and rec(x=int, y=int, z=int) will have the same TypeRef.
-import std::{int, str, uint, map, option, fs, time, vec};
+import std::{str, uint, map, option, time, vec};
 import std::map::hashmap;
 import std::map::{new_int_hash, new_str_hash};
 import std::option::{some, none};
 import driver::session;
 import middle::{ty, gc};
 import middle::freevars::*;
-import back::{link, x86, abi, upcall};
+import back::{link, abi, upcall};
 import syntax::{ast, ast_util};
 import syntax::visit;
 import syntax::codemap::span;
-import syntax::print::pprust::{expr_to_str, path_to_str};
+import syntax::print::pprust::{expr_to_str};
 import visit::vt;
-import util::common;
 import util::common::*;
-import lib::llvm::{llvm, target_data, type_names,
-                   mk_target_data, mk_type_names};
-import lib::llvm::llvm::{ModuleRef, ValueRef, TypeRef, TypeHandleRef,
-                         BuilderRef, BasicBlockRef};
-import lib::llvm::{Bool, True, False};
+import lib::llvm::{llvm, mk_target_data, mk_type_names};
+import lib::llvm::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef};
+import lib::llvm::{True, False};
 import link::{mangle_internal_name_by_type_only,
               mangle_internal_name_by_seq,
               mangle_internal_name_by_path,
               mangle_internal_name_by_path_and_seq,
               mangle_exported_name};
-import metadata::{creader, csearch, cstore};
+import metadata::{csearch, cstore};
 import util::ppaux::{ty_to_str, ty_to_short_str};
 
 import trans_common::*;

src/comp/middle/trans_alt.rs

@@ -1,12 +1,10 @@
-import std::{str, vec, option, int};
+import std::{str, vec, option};
 import option::{some, none};
-import std::map::hashmap;
 
 import lib::llvm::llvm;
-import lib::llvm::llvm::{ValueRef, TypeRef, BasicBlockRef};
+import lib::llvm::llvm::{ValueRef, BasicBlockRef};
 import trans_build::*;
 import trans::{new_sub_block_ctxt, new_scope_block_ctxt, load_if_immediate};
-import ty::pat_ty;
 import syntax::ast;
 import syntax::ast_util;
 import syntax::ast_util::dummy_sp;

src/comp/middle/trans_build.rs

@@ -3,8 +3,8 @@ import std::str::sbuf;
 import lib::llvm::llvm;
 import llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, Opcode,
               ModuleRef};
-import trans_common::{block_ctxt, T_ptr, T_nil, T_int, T_i8, T_i1,
-                      val_ty, val_str, bcx_ccx, C_i32};
+import trans_common::{block_ctxt, T_ptr, T_nil, T_i8, T_i1,
+                      val_ty, C_i32};
 
 fn B(cx: @block_ctxt) -> BuilderRef {
     let b = *cx.fcx.lcx.ccx.builder;