From a26837c47872066b8bfb4e455fcf75fc573e862f Mon Sep 17 00:00:00 2001 From: Patrick Walton Date: Tue, 4 Sep 2012 11:54:36 -0700 Subject: [PATCH] rustc: "import" -> "use" --- src/rustc/back/link.rs | 34 ++--- src/rustc/back/rpath.rs | 10 +- src/rustc/back/upcall.rs | 8 +- src/rustc/back/x86.rs | 6 +- src/rustc/back/x86_64.rs | 6 +- src/rustc/driver.rs | 2 +- src/rustc/driver/driver.rs | 32 ++--- src/rustc/driver/rustc.rs | 20 +-- src/rustc/driver/session.rs | 18 +-- src/rustc/front/config.rs | 2 +- src/rustc/front/core_inject.rs | 10 +- src/rustc/front/intrinsic_inject.rs | 6 +- src/rustc/front/test.rs | 18 +-- src/rustc/lib/llvm.rs | 4 +- src/rustc/metadata/creader.rs | 22 ++-- src/rustc/metadata/csearch.rs | 24 ++-- src/rustc/metadata/cstore.rs | 10 +- src/rustc/metadata/decoder.rs | 30 ++--- src/rustc/metadata/encoder.rs | 40 +++--- src/rustc/metadata/filesearch.rs | 2 +- src/rustc/metadata/loader.rs | 16 +-- src/rustc/metadata/tydecode.rs | 12 +- src/rustc/metadata/tyencode.rs | 14 +- src/rustc/middle/astencode.rs | 64 ++++----- src/rustc/middle/borrowck.rs | 34 ++--- src/rustc/middle/borrowck/check_loans.rs | 2 +- src/rustc/middle/borrowck/gather_loans.rs | 6 +- src/rustc/middle/borrowck/loan.rs | 2 +- src/rustc/middle/capture.rs | 10 +- src/rustc/middle/check_alt.rs | 24 ++-- src/rustc/middle/check_const.rs | 10 +- src/rustc/middle/check_loop.rs | 6 +- src/rustc/middle/const_eval.rs | 4 +- src/rustc/middle/freevars.rs | 12 +- src/rustc/middle/kind.rs | 20 +-- src/rustc/middle/lang_items.rs | 22 ++-- src/rustc/middle/lint.rs | 26 ++-- src/rustc/middle/liveness.rs | 20 +-- src/rustc/middle/mem_categorization.rs | 12 +- src/rustc/middle/pat_util.rs | 14 +- src/rustc/middle/region.rs | 26 ++-- src/rustc/middle/resolve.rs | 122 +++++++++--------- src/rustc/middle/trans/alt.rs | 34 ++--- src/rustc/middle/trans/base.rs | 68 +++++----- src/rustc/middle/trans/build.rs | 18 +-- src/rustc/middle/trans/closure.rs | 34 ++--- src/rustc/middle/trans/common.rs | 36 +++--- src/rustc/middle/trans/consts.rs | 6 +- src/rustc/middle/trans/debuginfo.rs | 30 ++--- src/rustc/middle/trans/foreign.rs | 26 ++-- src/rustc/middle/trans/impl.rs | 36 +++--- src/rustc/middle/trans/reachable.rs | 14 +- src/rustc/middle/trans/reflect.rs | 22 ++-- src/rustc/middle/trans/shape.rs | 36 +++--- src/rustc/middle/trans/tvec.rs | 20 +-- src/rustc/middle/trans/type_of.rs | 12 +- src/rustc/middle/trans/type_use.rs | 16 +-- src/rustc/middle/trans/uniq.rs | 12 +- src/rustc/middle/tstate/annotate.rs | 14 +- src/rustc/middle/tstate/auxiliary.rs | 26 ++-- src/rustc/middle/tstate/ck.rs | 32 ++--- src/rustc/middle/tstate/collect_locals.rs | 22 ++-- .../middle/tstate/pre_post_conditions.rs | 26 ++-- src/rustc/middle/tstate/states.rs | 28 ++-- src/rustc/middle/ty.rs | 34 ++--- src/rustc/middle/typeck.rs | 48 +++---- src/rustc/middle/typeck/astconv.rs | 6 +- src/rustc/middle/typeck/check.rs | 20 +-- src/rustc/middle/typeck/check/alt.rs | 2 +- src/rustc/middle/typeck/check/demand.rs | 2 +- src/rustc/middle/typeck/check/method.rs | 18 +-- src/rustc/middle/typeck/check/regionck.rs | 22 ++-- src/rustc/middle/typeck/check/regionmanip.rs | 2 +- src/rustc/middle/typeck/check/vtable.rs | 10 +- src/rustc/middle/typeck/check/writeback.rs | 6 +- src/rustc/middle/typeck/coherence.rs | 60 ++++----- src/rustc/middle/typeck/collect.rs | 6 +- src/rustc/middle/typeck/infer.rs | 54 ++++---- src/rustc/middle/typeck/infer/assignment.rs | 4 +- src/rustc/middle/typeck/infer/combine.rs | 2 +- src/rustc/middle/typeck/infer/glb.rs | 6 +- src/rustc/middle/typeck/infer/integral.rs | 2 +- src/rustc/middle/typeck/infer/lattice.rs | 6 +- src/rustc/middle/typeck/infer/lub.rs | 6 +- .../typeck/infer/region_var_bindings.rs | 22 ++-- src/rustc/middle/typeck/infer/resolve.rs | 4 +- src/rustc/middle/typeck/infer/sub.rs | 6 +- src/rustc/middle/typeck/infer/to_str.rs | 4 +- src/rustc/middle/typeck/infer/unify.rs | 6 +- src/rustc/middle/typeck/rscope.rs | 4 +- src/rustc/util/common.rs | 12 +- src/rustc/util/ppaux.rs | 42 +++--- 92 files changed, 883 insertions(+), 883 deletions(-) diff --git a/src/rustc/back/link.rs b/src/rustc/back/link.rs index 8cc2da7fc73..e6380fd1be6 100644 --- a/src/rustc/back/link.rs +++ b/src/rustc/back/link.rs @@ -1,21 +1,21 @@ -import libc::{c_int, c_uint, c_char}; -import driver::session; -import session::session; -import lib::llvm::llvm; -import syntax::attr; -import middle::ty; -import metadata::{encoder, cstore}; -import middle::trans::common::crate_ctxt; -import metadata::common::link_meta; -import std::map::hashmap; -import std::sha1::sha1; -import syntax::ast; -import syntax::print::pprust; -import lib::llvm::{ModuleRef, mk_pass_manager, mk_target_data, True, False, +use libc::{c_int, c_uint, c_char}; +use driver::session; +use session::session; +use lib::llvm::llvm; +use syntax::attr; +use middle::ty; +use metadata::{encoder, cstore}; +use middle::trans::common::crate_ctxt; +use metadata::common::link_meta; +use std::map::hashmap; +use std::sha1::sha1; +use syntax::ast; +use syntax::print::pprust; +use lib::llvm::{ModuleRef, mk_pass_manager, mk_target_data, True, False, PassManagerRef, FileType}; -import metadata::filesearch; -import syntax::ast_map::{path, path_mod, path_name}; -import io::{Writer, WriterUtil}; +use metadata::filesearch; +use syntax::ast_map::{path, path_mod, path_name}; +use io::{Writer, WriterUtil}; enum output_type { output_type_none, diff --git a/src/rustc/back/rpath.rs b/src/rustc/back/rpath.rs index 032eb6342e1..b77a667f7d3 100644 --- a/src/rustc/back/rpath.rs +++ b/src/rustc/back/rpath.rs @@ -1,8 +1,8 @@ -import std::map; -import std::map::hashmap; -import metadata::cstore; -import driver::session; -import metadata::filesearch; +use std::map; +use std::map::hashmap; +use metadata::cstore; +use driver::session; +use metadata::filesearch; export get_rpath_flags; diff --git a/src/rustc/back/upcall.rs b/src/rustc/back/upcall.rs index 4d9975e3039..8f6e48574b5 100644 --- a/src/rustc/back/upcall.rs +++ b/src/rustc/back/upcall.rs @@ -1,11 +1,11 @@ -import driver::session; -import middle::trans::base; -import middle::trans::common::{T_fn, T_i1, T_i8, T_i32, +use driver::session; +use middle::trans::base; +use middle::trans::common::{T_fn, T_i1, T_i8, T_i32, T_int, T_nil, T_opaque_vec, T_ptr, T_unique_ptr, T_size_t, T_void, T_vec2}; -import lib::llvm::{type_names, ModuleRef, ValueRef, TypeRef}; +use lib::llvm::{type_names, ModuleRef, ValueRef, TypeRef}; type upcalls = {_fail: ValueRef, diff --git a/src/rustc/back/x86.rs b/src/rustc/back/x86.rs index 78270f31e37..8d4b50f9ac4 100644 --- a/src/rustc/back/x86.rs +++ b/src/rustc/back/x86.rs @@ -1,6 +1,6 @@ -import driver::session; -import session::sess_os_to_meta_os; -import metadata::loader::meta_section_name; +use driver::session; +use session::sess_os_to_meta_os; +use metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { return { diff --git a/src/rustc/back/x86_64.rs b/src/rustc/back/x86_64.rs index 18c2232c0fc..ec2f5b18490 100644 --- a/src/rustc/back/x86_64.rs +++ b/src/rustc/back/x86_64.rs @@ -1,6 +1,6 @@ -import driver::session; -import session::sess_os_to_meta_os; -import metadata::loader::meta_section_name; +use driver::session; +use session::sess_os_to_meta_os; +use metadata::loader::meta_section_name; fn get_target_strs(target_os: session::os) -> target_strs::t { return { diff --git a/src/rustc/driver.rs b/src/rustc/driver.rs index 5a79913d3d2..cbe6345a9f1 100644 --- a/src/rustc/driver.rs +++ b/src/rustc/driver.rs @@ -1,4 +1,4 @@ -import syntax::diagnostic; +use syntax::diagnostic; export diagnostic; export driver; diff --git a/src/rustc/driver/driver.rs b/src/rustc/driver/driver.rs index a1864357d60..345678bb661 100644 --- a/src/rustc/driver/driver.rs +++ b/src/rustc/driver/driver.rs @@ -1,20 +1,20 @@ // -*- rust -*- -import metadata::{creader, cstore, filesearch}; -import session::{session, session_, OptLevel, No, Less, Default, Aggressive}; -import syntax::parse; -import syntax::{ast, codemap}; -import syntax::attr; -import middle::{trans, freevars, kind, ty, typeck, lint}; -import syntax::print::{pp, pprust}; -import util::ppaux; -import back::link; -import result::{Ok, Err}; -import std::getopts; -import io::WriterUtil; -import getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; -import back::{x86, x86_64}; -import std::map::hashmap; -import lib::llvm::llvm; +use metadata::{creader, cstore, filesearch}; +use session::{session, session_, OptLevel, No, Less, Default, Aggressive}; +use syntax::parse; +use syntax::{ast, codemap}; +use syntax::attr; +use middle::{trans, freevars, kind, ty, typeck, lint}; +use syntax::print::{pp, pprust}; +use util::ppaux; +use back::link; +use result::{Ok, Err}; +use std::getopts; +use io::WriterUtil; +use getopts::{optopt, optmulti, optflag, optflagopt, opt_present}; +use back::{x86, x86_64}; +use std::map::hashmap; +use lib::llvm::llvm; enum pp_mode {ppm_normal, ppm_expanded, ppm_typed, ppm_identified, ppm_expanded_identified } diff --git a/src/rustc/driver/rustc.rs b/src/rustc/driver/rustc.rs index f55688bd234..c6b8bc2d7b9 100644 --- a/src/rustc/driver/rustc.rs +++ b/src/rustc/driver/rustc.rs @@ -6,18 +6,18 @@ use std(vers = "0.4"); use rustc(vers = "0.4"); use syntax(vers = "0.4"); -import core::*; +use core::*; // -*- rust -*- -import result::{Ok, Err}; -import std::getopts; -import std::map::hashmap; -import getopts::{opt_present}; -import rustc::driver::driver::*; -import syntax::codemap; -import syntax::diagnostic; -import rustc::driver::session; -import rustc::middle::lint; +use result::{Ok, Err}; +use std::getopts; +use std::map::hashmap; +use getopts::{opt_present}; +use rustc::driver::driver::*; +use syntax::codemap; +use syntax::diagnostic; +use rustc::driver::session; +use rustc::middle::lint; fn version(argv0: ~str) { let mut vers = ~"unknown version"; diff --git a/src/rustc/driver/session.rs b/src/rustc/driver/session.rs index a1785355af8..290c6e94654 100644 --- a/src/rustc/driver/session.rs +++ b/src/rustc/driver/session.rs @@ -1,13 +1,13 @@ -import syntax::{ast, codemap}; -import syntax::ast::node_id; -import codemap::span; -import syntax::ast::{int_ty, uint_ty, float_ty}; -import syntax::parse::parse_sess; -import metadata::filesearch; -import back::target_strs; -import back::link; -import middle::lint; +use syntax::{ast, codemap}; +use syntax::ast::node_id; +use codemap::span; +use syntax::ast::{int_ty, uint_ty, float_ty}; +use syntax::parse::parse_sess; +use metadata::filesearch; +use back::target_strs; +use back::link; +use middle::lint; enum os { os_win32, os_macos, os_linux, os_freebsd, } diff --git a/src/rustc/front/config.rs b/src/rustc/front/config.rs index 50ed5f6132c..79b9baa77dd 100644 --- a/src/rustc/front/config.rs +++ b/src/rustc/front/config.rs @@ -1,4 +1,4 @@ -import syntax::{ast, fold, attr}; +use syntax::{ast, fold, attr}; export strip_unconfigured_items; export metas_in_cfg; diff --git a/src/rustc/front/core_inject.rs b/src/rustc/front/core_inject.rs index bcfdca40ac2..e68a98f4ff5 100644 --- a/src/rustc/front/core_inject.rs +++ b/src/rustc/front/core_inject.rs @@ -1,8 +1,8 @@ -import driver::session::session; -import syntax::codemap; -import syntax::ast; -import syntax::ast_util::*; -import syntax::attr; +use driver::session::session; +use syntax::codemap; +use syntax::ast; +use syntax::ast_util::*; +use syntax::attr; export maybe_inject_libcore_ref; diff --git a/src/rustc/front/intrinsic_inject.rs b/src/rustc/front/intrinsic_inject.rs index 3c3195f1e83..cc184543b00 100644 --- a/src/rustc/front/intrinsic_inject.rs +++ b/src/rustc/front/intrinsic_inject.rs @@ -1,6 +1,6 @@ -import driver::session::session; -import syntax::parse; -import syntax::ast; +use driver::session::session; +use syntax::parse; +use syntax::ast; export inject_intrinsic; diff --git a/src/rustc/front/test.rs b/src/rustc/front/test.rs index e2c7d3e522a..62fed099e40 100644 --- a/src/rustc/front/test.rs +++ b/src/rustc/front/test.rs @@ -1,15 +1,15 @@ // Code that generates a test runner to run all the tests in a crate -import syntax::{ast, ast_util}; -import syntax::ast_util::*; +use syntax::{ast, ast_util}; +use syntax::ast_util::*; //import syntax::ast_util::dummy_sp; -import syntax::fold; -import syntax::print::pprust; -import syntax::codemap::span; -import driver::session; -import session::session; -import syntax::attr; -import dvec::DVec; +use syntax::fold; +use syntax::print::pprust; +use syntax::codemap::span; +use driver::session; +use session::session; +use syntax::attr; +use dvec::DVec; export modify_for_testing; diff --git a/src/rustc/lib/llvm.rs b/src/rustc/lib/llvm.rs index ddce3c9640e..6da8a9d57c9 100644 --- a/src/rustc/lib/llvm.rs +++ b/src/rustc/lib/llvm.rs @@ -1,6 +1,6 @@ -import std::map::hashmap; +use std::map::hashmap; -import libc::{c_char, c_int, c_uint, c_longlong, c_ulonglong}; +use libc::{c_char, c_int, c_uint, c_longlong, c_ulonglong}; type Opcode = u32; type Bool = c_uint; diff --git a/src/rustc/metadata/creader.rs b/src/rustc/metadata/creader.rs index 4f3df6cac70..df02a8640dc 100644 --- a/src/rustc/metadata/creader.rs +++ b/src/rustc/metadata/creader.rs @@ -1,16 +1,16 @@ //! Validates all used crates and extern libraries and loads their metadata -import syntax::diagnostic::span_handler; -import syntax::{ast, ast_util}; -import syntax::attr; -import syntax::visit; -import syntax::codemap::span; -import std::map::{hashmap, int_hash}; -import syntax::print::pprust; -import filesearch::filesearch; -import common::*; -import dvec::DVec; -import syntax::parse::token::ident_interner; +use syntax::diagnostic::span_handler; +use syntax::{ast, ast_util}; +use syntax::attr; +use syntax::visit; +use syntax::codemap::span; +use std::map::{hashmap, int_hash}; +use syntax::print::pprust; +use filesearch::filesearch; +use common::*; +use dvec::DVec; +use syntax::parse::token::ident_interner; export read_crates; diff --git a/src/rustc/metadata/csearch.rs b/src/rustc/metadata/csearch.rs index 0c98541a363..69fc8b81b23 100644 --- a/src/rustc/metadata/csearch.rs +++ b/src/rustc/metadata/csearch.rs @@ -1,17 +1,17 @@ // Searching for information from the cstore -import std::{ebml}; -import syntax::ast; -import syntax::ast_util; -import syntax::ast_map; -import middle::ty; -import option::{Some, None}; -import syntax::diagnostic::span_handler; -import syntax::diagnostic::expect; -import ast_util::dummy_sp; -import common::*; -import std::map::hashmap; -import dvec::DVec; +use std::{ebml}; +use syntax::ast; +use syntax::ast_util; +use syntax::ast_map; +use middle::ty; +use option::{Some, None}; +use syntax::diagnostic::span_handler; +use syntax::diagnostic::expect; +use ast_util::dummy_sp; +use common::*; +use std::map::hashmap; +use dvec::DVec; export class_dtor; export get_symbol; diff --git a/src/rustc/metadata/cstore.rs b/src/rustc/metadata/cstore.rs index 5664cf1bfa7..ce20569116d 100644 --- a/src/rustc/metadata/cstore.rs +++ b/src/rustc/metadata/cstore.rs @@ -1,11 +1,11 @@ // The crate store - a central repo for information collected about external // crates and libraries -import std::map; -import std::map::hashmap; -import syntax::{ast, attr}; -import syntax::ast_util::new_def_hash; -import syntax::parse::token::ident_interner; +use std::map; +use std::map::hashmap; +use syntax::{ast, attr}; +use syntax::ast_util::new_def_hash; +use syntax::parse::token::ident_interner; export cstore; export cnum_map; diff --git a/src/rustc/metadata/decoder.rs b/src/rustc/metadata/decoder.rs index ee3abe1b089..d9ecc114062 100644 --- a/src/rustc/metadata/decoder.rs +++ b/src/rustc/metadata/decoder.rs @@ -1,21 +1,21 @@ // Decoding metadata from a single crate's metadata -import std::{ebml, map}; -import std::map::{hashmap, str_hash}; -import io::WriterUtil; -import dvec::DVec; -import syntax::{ast, ast_util}; -import syntax::attr; -import middle::ty; -import syntax::ast_map; -import tydecode::{parse_ty_data, parse_def_id, parse_bounds_data, +use std::{ebml, map}; +use std::map::{hashmap, str_hash}; +use io::WriterUtil; +use dvec::DVec; +use syntax::{ast, ast_util}; +use syntax::attr; +use middle::ty; +use syntax::ast_map; +use tydecode::{parse_ty_data, parse_def_id, parse_bounds_data, parse_ident}; -import syntax::print::pprust; -import cmd=cstore::crate_metadata; -import util::ppaux::ty_to_str; -import syntax::diagnostic::span_handler; -import common::*; -import syntax::parse::token::ident_interner; +use syntax::print::pprust; +use cmd=cstore::crate_metadata; +use util::ppaux::ty_to_str; +use syntax::diagnostic::span_handler; +use common::*; +use syntax::parse::token::ident_interner; export class_dtor; diff --git a/src/rustc/metadata/encoder.rs b/src/rustc/metadata/encoder.rs index a22b425c277..3d114ce4c6b 100644 --- a/src/rustc/metadata/encoder.rs +++ b/src/rustc/metadata/encoder.rs @@ -1,26 +1,26 @@ // Metadata encoding -import util::ppaux::ty_to_str; +use util::ppaux::ty_to_str; -import std::{ebml, map}; -import std::map::hashmap; -import io::WriterUtil; -import ebml::Writer; -import syntax::ast::*; -import syntax::print::pprust; -import syntax::{ast_util, visit}; -import syntax::ast_util::*; -import common::*; -import middle::ty; -import middle::ty::node_id_to_type; -import middle::resolve; -import syntax::ast_map; -import syntax::attr; -import std::serialization::serializer; -import std::ebml::serializer; -import str::to_bytes; -import syntax::ast; -import syntax::diagnostic::span_handler; +use std::{ebml, map}; +use std::map::hashmap; +use io::WriterUtil; +use ebml::Writer; +use syntax::ast::*; +use syntax::print::pprust; +use syntax::{ast_util, visit}; +use syntax::ast_util::*; +use common::*; +use middle::ty; +use middle::ty::node_id_to_type; +use middle::resolve; +use syntax::ast_map; +use syntax::attr; +use std::serialization::serializer; +use std::ebml::serializer; +use str::to_bytes; +use syntax::ast; +use syntax::diagnostic::span_handler; export encode_parms; export encode_metadata; diff --git a/src/rustc/metadata/filesearch.rs b/src/rustc/metadata/filesearch.rs index c0639a7bb8a..26363806da0 100644 --- a/src/rustc/metadata/filesearch.rs +++ b/src/rustc/metadata/filesearch.rs @@ -2,7 +2,7 @@ // FIXME (#2658): I'm not happy how this module turned out. Should // probably just be folded into cstore. -import result::Result; +use result::Result; export filesearch; export mk_filesearch; export pick; diff --git a/src/rustc/metadata/loader.rs b/src/rustc/metadata/loader.rs index 22eaa690295..c6f53377f1f 100644 --- a/src/rustc/metadata/loader.rs +++ b/src/rustc/metadata/loader.rs @@ -1,13 +1,13 @@ //! Finds crate binaries and loads their metadata -import syntax::diagnostic::span_handler; -import syntax::{ast, attr}; -import syntax::print::pprust; -import syntax::codemap::span; -import lib::llvm::{False, llvm, mk_object_file, mk_section_iter}; -import filesearch::filesearch; -import io::WriterUtil; -import syntax::parse::token::ident_interner; +use syntax::diagnostic::span_handler; +use syntax::{ast, attr}; +use syntax::print::pprust; +use syntax::codemap::span; +use lib::llvm::{False, llvm, mk_object_file, mk_section_iter}; +use filesearch::filesearch; +use io::WriterUtil; +use syntax::parse::token::ident_interner; export os; export os_macos, os_win32, os_linux, os_freebsd; diff --git a/src/rustc/metadata/tydecode.rs b/src/rustc/metadata/tydecode.rs index 34676df489e..163bb5db81b 100644 --- a/src/rustc/metadata/tydecode.rs +++ b/src/rustc/metadata/tydecode.rs @@ -3,12 +3,12 @@ // tjc note: Would be great to have a `match check` macro equivalent // for some of these -import syntax::ast; -import syntax::ast::*; -import syntax::ast_util; -import syntax::ast_util::respan; -import middle::ty; -import std::map::hashmap; +use syntax::ast; +use syntax::ast::*; +use syntax::ast_util; +use syntax::ast_util::respan; +use middle::ty; +use std::map::hashmap; export parse_ty_data, parse_def_id, parse_ident; export parse_bounds_data; diff --git a/src/rustc/metadata/tyencode.rs b/src/rustc/metadata/tyencode.rs index ed313238e68..42a258e836f 100644 --- a/src/rustc/metadata/tyencode.rs +++ b/src/rustc/metadata/tyencode.rs @@ -1,12 +1,12 @@ // Type encoding -import io::WriterUtil; -import std::map::hashmap; -import syntax::ast::*; -import syntax::diagnostic::span_handler; -import middle::ty; -import middle::ty::vid; -import syntax::print::pprust::*; +use io::WriterUtil; +use std::map::hashmap; +use syntax::ast::*; +use syntax::diagnostic::span_handler; +use middle::ty; +use middle::ty::vid; +use syntax::print::pprust::*; export ctxt; export ty_abbrev; diff --git a/src/rustc/middle/astencode.rs b/src/rustc/middle/astencode.rs index 3f329bc9b76..08dd70f757b 100644 --- a/src/rustc/middle/astencode.rs +++ b/src/rustc/middle/astencode.rs @@ -1,45 +1,45 @@ -import util::ppaux::ty_to_str; +use util::ppaux::ty_to_str; -import syntax::ast; -import syntax::fold; -import syntax::fold::*; -import syntax::visit; -import syntax::ast_map; -import syntax::ast_util; -import syntax::codemap::span; -import std::ebml; -import std::ebml::Writer; -import std::ebml::get_doc; -import std::map::hashmap; -import std::serialization::serializer; -import std::serialization::deserializer; -import std::serialization::serializer_helpers; -import std::serialization::deserializer_helpers; -import std::prettyprint::serializer; -import middle::{ty, typeck}; -import middle::typeck::{method_origin, method_map_entry, +use syntax::ast; +use syntax::fold; +use syntax::fold::*; +use syntax::visit; +use syntax::ast_map; +use syntax::ast_util; +use syntax::codemap::span; +use std::ebml; +use std::ebml::Writer; +use std::ebml::get_doc; +use std::map::hashmap; +use std::serialization::serializer; +use std::serialization::deserializer; +use std::serialization::serializer_helpers; +use std::serialization::deserializer_helpers; +use std::prettyprint::serializer; +use middle::{ty, typeck}; +use middle::typeck::{method_origin, method_map_entry, serialize_method_map_entry, deserialize_method_map_entry, vtable_res, vtable_origin}; -import driver::session::session; -import middle::freevars::{freevar_entry, +use driver::session::session; +use middle::freevars::{freevar_entry, serialize_freevar_entry, deserialize_freevar_entry}; -import c = metadata::common; -import e = metadata::encoder; -import cstore = metadata::cstore; -import metadata::encoder; -import metadata::decoder; -import metadata::tyencode; -import metadata::tydecode; +use c = metadata::common; +use e = metadata::encoder; +use cstore = metadata::cstore; +use metadata::encoder; +use metadata::decoder; +use metadata::tyencode; +use metadata::tydecode; // used in testing: -import syntax::diagnostic; -import syntax::codemap; -import syntax::parse; -import syntax::print::pprust; +use syntax::diagnostic; +use syntax::codemap; +use syntax::parse; +use syntax::print::pprust; export maps; export encode_inlined_item; diff --git a/src/rustc/middle/borrowck.rs b/src/rustc/middle/borrowck.rs index 25902d86674..c5679351941 100644 --- a/src/rustc/middle/borrowck.rs +++ b/src/rustc/middle/borrowck.rs @@ -214,23 +214,23 @@ Borrowck results in two maps. given a memory location and not used as immediates. */ -import syntax::ast; -import syntax::ast::{mutability, m_mutbl, m_imm, m_const}; -import syntax::visit; -import syntax::ast_util; -import syntax::ast_map; -import syntax::codemap::span; -import util::ppaux::{ty_to_str, region_to_str, explain_region}; -import std::map::{int_hash, hashmap, set}; -import std::list; -import std::list::{list, cons, nil}; -import result::{Result, Ok, Err}; -import syntax::print::pprust; -import util::common::indenter; -import ty::to_str; -import driver::session::session; -import dvec::DVec; -import mem_categorization::*; +use syntax::ast; +use syntax::ast::{mutability, m_mutbl, m_imm, m_const}; +use syntax::visit; +use syntax::ast_util; +use syntax::ast_map; +use syntax::codemap::span; +use util::ppaux::{ty_to_str, region_to_str, explain_region}; +use std::map::{int_hash, hashmap, set}; +use std::list; +use std::list::{list, cons, nil}; +use result::{Result, Ok, Err}; +use syntax::print::pprust; +use util::common::indenter; +use ty::to_str; +use driver::session::session; +use dvec::DVec; +use mem_categorization::*; export check_crate, root_map, mutbl_map; diff --git a/src/rustc/middle/borrowck/check_loans.rs b/src/rustc/middle/borrowck/check_loans.rs index b5fd72b3667..906efa43a4a 100644 --- a/src/rustc/middle/borrowck/check_loans.rs +++ b/src/rustc/middle/borrowck/check_loans.rs @@ -7,7 +7,7 @@ // 3. assignments do not affect things loaned out as immutable // 4. moves to dnot affect things loaned out in any way -import dvec::DVec; +use dvec::DVec; export check_loans; diff --git a/src/rustc/middle/borrowck/gather_loans.rs b/src/rustc/middle/borrowck/gather_loans.rs index 08f01f41941..ef01e254c86 100644 --- a/src/rustc/middle/borrowck/gather_loans.rs +++ b/src/rustc/middle/borrowck/gather_loans.rs @@ -6,9 +6,9 @@ // their associated scopes. In phase two, checking loans, we will then make // sure that all of these loans are honored. -import mem_categorization::{opt_deref_kind}; -import preserve::{preserve_condition, pc_ok, pc_if_pure}; -import ty::ty_region; +use mem_categorization::{opt_deref_kind}; +use preserve::{preserve_condition, pc_ok, pc_if_pure}; +use ty::ty_region; export gather_loans; diff --git a/src/rustc/middle/borrowck/loan.rs b/src/rustc/middle/borrowck/loan.rs index e775bc7c50b..353022214c5 100644 --- a/src/rustc/middle/borrowck/loan.rs +++ b/src/rustc/middle/borrowck/loan.rs @@ -3,7 +3,7 @@ // of the scope S, presuming that the returned set of loans `Ls` are honored. export public_methods; -import result::{Result, Ok, Err}; +use result::{Result, Ok, Err}; impl borrowck_ctxt { fn loan(cmt: cmt, diff --git a/src/rustc/middle/capture.rs b/src/rustc/middle/capture.rs index 8f78d286fe6..3a0f67c66b8 100644 --- a/src/rustc/middle/capture.rs +++ b/src/rustc/middle/capture.rs @@ -1,8 +1,8 @@ -import syntax::{ast, ast_util}; -import driver::session::session; -import syntax::codemap::span; -import std::map; -import std::map::hashmap; +use syntax::{ast, ast_util}; +use driver::session::session; +use syntax::codemap::span; +use std::map; +use std::map::hashmap; export capture_mode; export capture_var; diff --git a/src/rustc/middle/check_alt.rs b/src/rustc/middle/check_alt.rs index a91bb25c1ac..660a502df26 100644 --- a/src/rustc/middle/check_alt.rs +++ b/src/rustc/middle/check_alt.rs @@ -1,16 +1,16 @@ -import syntax::ast::*; -import syntax::ast_util::{variant_def_ids, dummy_sp, unguarded_pat}; -import const_eval::{eval_const_expr, const_val, const_int, const_bool, +use syntax::ast::*; +use syntax::ast_util::{variant_def_ids, dummy_sp, unguarded_pat}; +use const_eval::{eval_const_expr, const_val, const_int, const_bool, compare_const_vals}; -import syntax::codemap::span; -import syntax::print::pprust::pat_to_str; -import util::ppaux::ty_to_str; -import pat_util::*; -import syntax::visit; -import driver::session::session; -import middle::ty; -import middle::ty::*; -import std::map::hashmap; +use syntax::codemap::span; +use syntax::print::pprust::pat_to_str; +use util::ppaux::ty_to_str; +use pat_util::*; +use syntax::visit; +use driver::session::session; +use middle::ty; +use middle::ty::*; +use std::map::hashmap; fn check_crate(tcx: ty::ctxt, crate: @crate) { visit::visit_crate(*crate, (), visit::mk_vt(@{ diff --git a/src/rustc/middle/check_const.rs b/src/rustc/middle/check_const.rs index cc426b5cb74..b0c410211c1 100644 --- a/src/rustc/middle/check_const.rs +++ b/src/rustc/middle/check_const.rs @@ -1,8 +1,8 @@ -import syntax::ast::*; -import syntax::{visit, ast_util, ast_map}; -import driver::session::session; -import std::map::hashmap; -import dvec::DVec; +use syntax::ast::*; +use syntax::{visit, ast_util, ast_map}; +use driver::session::session; +use std::map::hashmap; +use dvec::DVec; fn check_crate(sess: session, crate: @crate, ast_map: ast_map::map, def_map: resolve::DefMap, diff --git a/src/rustc/middle/check_loop.rs b/src/rustc/middle/check_loop.rs index 1fef670c0ba..79f8cf24da0 100644 --- a/src/rustc/middle/check_loop.rs +++ b/src/rustc/middle/check_loop.rs @@ -1,6 +1,6 @@ -import syntax::ast::*; -import syntax::visit; -import driver::session::session; +use syntax::ast::*; +use syntax::visit; +use driver::session::session; type ctx = {in_loop: bool, can_ret: bool}; diff --git a/src/rustc/middle/const_eval.rs b/src/rustc/middle/const_eval.rs index 8eaeef0d120..90bfbc4117b 100644 --- a/src/rustc/middle/const_eval.rs +++ b/src/rustc/middle/const_eval.rs @@ -1,5 +1,5 @@ -import syntax::{ast,ast_util,visit}; -import ast::*; +use syntax::{ast,ast_util,visit}; +use ast::*; // // This pass classifies expressions by their constant-ness. diff --git a/src/rustc/middle/freevars.rs b/src/rustc/middle/freevars.rs index 143c494684a..59d97e0351a 100644 --- a/src/rustc/middle/freevars.rs +++ b/src/rustc/middle/freevars.rs @@ -1,12 +1,12 @@ // A pass that annotates for each loops and functions with the free // variables that they contain. -import syntax::print::pprust::path_to_str; -import std::map::*; -import option::*; -import syntax::{ast, ast_util, visit}; -import syntax::ast::{serialize_span, deserialize_span}; -import syntax::codemap::span; +use syntax::print::pprust::path_to_str; +use std::map::*; +use option::*; +use syntax::{ast, ast_util, visit}; +use syntax::ast::{serialize_span, deserialize_span}; +use syntax::codemap::span; export annotate_freevars; export freevar_map; diff --git a/src/rustc/middle/kind.rs b/src/rustc/middle/kind.rs index 98beb59ec0a..3fc02702ab4 100644 --- a/src/rustc/middle/kind.rs +++ b/src/rustc/middle/kind.rs @@ -1,13 +1,13 @@ -import syntax::{visit, ast_util}; -import syntax::ast::*; -import syntax::codemap::span; -import ty::{kind, kind_copyable, kind_noncopyable, kind_const}; -import driver::session::session; -import std::map::hashmap; -import util::ppaux::{ty_to_str, tys_to_str}; -import syntax::print::pprust::expr_to_str; -import freevars::freevar_entry; -import lint::{non_implicitly_copyable_typarams,implicit_copies}; +use syntax::{visit, ast_util}; +use syntax::ast::*; +use syntax::codemap::span; +use ty::{kind, kind_copyable, kind_noncopyable, kind_const}; +use driver::session::session; +use std::map::hashmap; +use util::ppaux::{ty_to_str, tys_to_str}; +use syntax::print::pprust::expr_to_str; +use freevars::freevar_entry; +use lint::{non_implicitly_copyable_typarams,implicit_copies}; // Kind analysis pass. // diff --git a/src/rustc/middle/lang_items.rs b/src/rustc/middle/lang_items.rs index 488602019b3..55f7113de08 100644 --- a/src/rustc/middle/lang_items.rs +++ b/src/rustc/middle/lang_items.rs @@ -9,18 +9,18 @@ // // * Functions called by the compiler itself. -import driver::session::session; -import metadata::csearch::{each_path, get_item_attrs}; -import metadata::cstore::{iter_crate_data}; -import metadata::decoder::{dl_def, dl_field, dl_impl}; -import syntax::ast::{crate, def_id, def_ty, lit_str, meta_item, meta_list}; -import syntax::ast::{meta_name_value, meta_word}; -import syntax::ast_util::{local_def}; -import syntax::visit::{default_simple_visitor, mk_simple_visitor}; -import syntax::visit::{visit_crate, visit_item}; +use driver::session::session; +use metadata::csearch::{each_path, get_item_attrs}; +use metadata::cstore::{iter_crate_data}; +use metadata::decoder::{dl_def, dl_field, dl_impl}; +use syntax::ast::{crate, def_id, def_ty, lit_str, meta_item, meta_list}; +use syntax::ast::{meta_name_value, meta_word}; +use syntax::ast_util::{local_def}; +use syntax::visit::{default_simple_visitor, mk_simple_visitor}; +use syntax::visit::{visit_crate, visit_item}; -import std::map::{hashmap, str_hash}; -import str_eq = str::eq; +use std::map::{hashmap, str_hash}; +use str_eq = str::eq; struct LanguageItems { mut const_trait: Option; diff --git a/src/rustc/middle/lint.rs b/src/rustc/middle/lint.rs index 403b98e380a..5acf2155477 100644 --- a/src/rustc/middle/lint.rs +++ b/src/rustc/middle/lint.rs @@ -1,16 +1,16 @@ -import driver::session; -import driver::session::session; -import middle::ty; -import syntax::{ast, ast_util, visit}; -import syntax::attr; -import syntax::codemap::span; -import std::map::{map,hashmap,int_hash,hash_from_strs}; -import std::smallintmap::{map,smallintmap}; -import io::WriterUtil; -import util::ppaux::{ty_to_str}; -import middle::pat_util::{pat_bindings}; -import syntax::ast_util::{path_to_ident}; -import syntax::print::pprust::{expr_to_str, mode_to_str, pat_to_str}; +use driver::session; +use driver::session::session; +use middle::ty; +use syntax::{ast, ast_util, visit}; +use syntax::attr; +use syntax::codemap::span; +use std::map::{map,hashmap,int_hash,hash_from_strs}; +use std::smallintmap::{map,smallintmap}; +use io::WriterUtil; +use util::ppaux::{ty_to_str}; +use middle::pat_util::{pat_bindings}; +use syntax::ast_util::{path_to_ident}; +use syntax::print::pprust::{expr_to_str, mode_to_str, pat_to_str}; export lint, ctypes, unused_imports, while_true, path_statement, old_vecs; export unrecognized_lint, non_implicitly_copyable_typarams; export vecs_implicitly_copyable, implicit_copies; diff --git a/src/rustc/middle/liveness.rs b/src/rustc/middle/liveness.rs index ae52965f21b..e90e4335247 100644 --- a/src/rustc/middle/liveness.rs +++ b/src/rustc/middle/liveness.rs @@ -100,16 +100,16 @@ * - `self_var`: a variable representing 'self' */ -import dvec::DVec; -import std::map::{hashmap, int_hash, str_hash, uint_hash}; -import syntax::{visit, ast_util}; -import syntax::print::pprust::{expr_to_str}; -import visit::vt; -import syntax::codemap::span; -import syntax::ast::*; -import driver::session::session; -import io::WriterUtil; -import capture::{cap_move, cap_drop, cap_copy, cap_ref}; +use dvec::DVec; +use std::map::{hashmap, int_hash, str_hash, uint_hash}; +use syntax::{visit, ast_util}; +use syntax::print::pprust::{expr_to_str}; +use visit::vt; +use syntax::codemap::span; +use syntax::ast::*; +use driver::session::session; +use io::WriterUtil; +use capture::{cap_move, cap_drop, cap_copy, cap_ref}; export check_crate; export last_use_map; diff --git a/src/rustc/middle/mem_categorization.rs b/src/rustc/middle/mem_categorization.rs index 453555f3045..99d0e6372e0 100644 --- a/src/rustc/middle/mem_categorization.rs +++ b/src/rustc/middle/mem_categorization.rs @@ -36,12 +36,12 @@ * then an index to jump forward to the relevant item. */ -import syntax::ast; -import syntax::ast::{m_imm, m_const, m_mutbl}; -import syntax::codemap::span; -import syntax::print::pprust; -import util::ppaux::{ty_to_str, region_to_str}; -import util::common::indenter; +use syntax::ast; +use syntax::ast::{m_imm, m_const, m_mutbl}; +use syntax::codemap::span; +use syntax::print::pprust; +use util::ppaux::{ty_to_str, region_to_str}; +use util::common::indenter; enum categorization { cat_rvalue, // result of eval'ing some misc expr diff --git a/src/rustc/middle/pat_util.rs b/src/rustc/middle/pat_util.rs index 9b473c32256..6c52204f12d 100644 --- a/src/rustc/middle/pat_util.rs +++ b/src/rustc/middle/pat_util.rs @@ -1,10 +1,10 @@ -import syntax::ast::*; -import syntax::ast_util; -import syntax::ast_util::{path_to_ident, respan, walk_pat}; -import syntax::fold; -import syntax::fold::*; -import syntax::codemap::span; -import std::map::hashmap; +use syntax::ast::*; +use syntax::ast_util; +use syntax::ast_util::{path_to_ident, respan, walk_pat}; +use syntax::fold; +use syntax::fold::*; +use syntax::codemap::span; +use std::map::hashmap; export pat_binding_ids, pat_bindings, pat_id_map; export pat_is_variant; diff --git a/src/rustc/middle/region.rs b/src/rustc/middle/region.rs index bc0f3971e82..e5f6a136935 100644 --- a/src/rustc/middle/region.rs +++ b/src/rustc/middle/region.rs @@ -7,20 +7,20 @@ region parameterized. */ -import driver::session::session; -import middle::ty; -import syntax::{ast, visit}; -import syntax::codemap::span; -import syntax::print::pprust; -import syntax::ast_util::new_def_hash; -import syntax::ast_map; -import dvec::DVec; -import metadata::csearch; -import ty::{region_variance, rv_covariant, rv_invariant, rv_contravariant}; +use driver::session::session; +use middle::ty; +use syntax::{ast, visit}; +use syntax::codemap::span; +use syntax::print::pprust; +use syntax::ast_util::new_def_hash; +use syntax::ast_map; +use dvec::DVec; +use metadata::csearch; +use ty::{region_variance, rv_covariant, rv_invariant, rv_contravariant}; -import std::list; -import std::list::list; -import std::map::{hashmap, int_hash}; +use std::list; +use std::list::list; +use std::map::{hashmap, int_hash}; type parent = Option; diff --git a/src/rustc/middle/resolve.rs b/src/rustc/middle/resolve.rs index c2f7bd2ae29..25fbe1b99ad 100644 --- a/src/rustc/middle/resolve.rs +++ b/src/rustc/middle/resolve.rs @@ -1,67 +1,67 @@ -import driver::session::session; -import metadata::csearch::{each_path, get_method_names_if_trait}; -import metadata::cstore::find_use_stmt_cnum; -import metadata::decoder::{def_like, dl_def, dl_field, dl_impl}; -import middle::lang_items::LanguageItems; -import middle::lint::{deny, allow, forbid, level, unused_imports, warn}; -import middle::pat_util::{pat_bindings}; -import syntax::ast::{_mod, add, arm}; -import syntax::ast::{bind_by_ref, bind_by_implicit_ref, bind_by_value}; -import syntax::ast::{bitand, bitor, bitxor}; -import syntax::ast::{blk, bound_const, bound_copy, bound_owned, bound_send}; -import syntax::ast::{bound_trait, binding_mode, +use driver::session::session; +use metadata::csearch::{each_path, get_method_names_if_trait}; +use metadata::cstore::find_use_stmt_cnum; +use metadata::decoder::{def_like, dl_def, dl_field, dl_impl}; +use middle::lang_items::LanguageItems; +use middle::lint::{deny, allow, forbid, level, unused_imports, warn}; +use middle::pat_util::{pat_bindings}; +use syntax::ast::{_mod, add, arm}; +use syntax::ast::{bind_by_ref, bind_by_implicit_ref, bind_by_value}; +use syntax::ast::{bitand, bitor, bitxor}; +use syntax::ast::{blk, bound_const, bound_copy, bound_owned, bound_send}; +use syntax::ast::{bound_trait, binding_mode, capture_clause, class_ctor, class_dtor}; -import syntax::ast::{crate, crate_num, decl_item}; -import syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn}; -import syntax::ast::{def_foreign_mod, def_id, def_label, def_local, def_mod}; -import syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param}; -import syntax::ast::{def_typaram_binder, def_static_method}; -import syntax::ast::{def_upvar, def_use, def_variant, expr, expr_assign_op}; -import syntax::ast::{expr_binary, expr_cast, expr_field, expr_fn}; -import syntax::ast::{expr_fn_block, expr_index, expr_path}; -import syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param}; -import syntax::ast::{def_upvar, def_use, def_variant, div, eq}; -import syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op}; -import syntax::ast::{expr_binary, expr_break, expr_cast, expr_field, expr_fn}; -import syntax::ast::{expr_fn_block, expr_index, expr_loop}; -import syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl}; -import syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge}; -import syntax::ast::{gt, ident, impure_fn, inherited, item, item_class}; -import syntax::ast::{item_const, item_enum, item_fn, item_foreign_mod}; -import syntax::ast::{item_impl, item_mac, item_mod, item_trait, item_ty, le}; -import syntax::ast::{local, local_crate, lt, method, module_ns, mul, ne, neg}; -import syntax::ast::{node_id, pat, pat_enum, pat_ident, path, prim_ty}; -import syntax::ast::{pat_box, pat_lit, pat_range, pat_rec, pat_struct}; -import syntax::ast::{pat_tup, pat_uniq, pat_wild, private, provided, public}; -import syntax::ast::{required, rem, self_ty_, shl, shr, stmt_decl}; -import syntax::ast::{struct_field, struct_variant_kind, sty_static, subtract}; -import syntax::ast::{trait_ref, tuple_variant_kind, ty, ty_bool, ty_char}; -import syntax::ast::{ty_f, ty_f32, ty_f64, ty_float, ty_i, ty_i16, ty_i32}; -import syntax::ast::{ty_i64, ty_i8, ty_int, ty_param, ty_path, ty_str, ty_u}; -import syntax::ast::{ty_u16, ty_u32, ty_u64, ty_u8, ty_uint, type_value_ns}; -import syntax::ast::{variant, view_item, view_item_export, view_item_import}; -import syntax::ast::{view_item_use, view_path_glob, view_path_list}; -import syntax::ast::{view_path_simple, visibility, anonymous, named}; -import syntax::ast_util::{def_id_of_def, dummy_sp, local_def, new_def_hash}; -import syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method}; -import syntax::attr::{attr_metas, contains_name}; -import syntax::print::pprust::{pat_to_str, path_to_str}; -import syntax::codemap::span; -import syntax::visit::{default_visitor, fk_method, mk_vt, visit_block}; -import syntax::visit::{visit_crate, visit_expr, visit_expr_opt, visit_fn}; -import syntax::visit::{visit_foreign_item, visit_item, visit_method_helper}; -import syntax::visit::{visit_mod, visit_ty, vt}; +use syntax::ast::{crate, crate_num, decl_item}; +use syntax::ast::{def, def_arg, def_binding, def_class, def_const, def_fn}; +use syntax::ast::{def_foreign_mod, def_id, def_label, def_local, def_mod}; +use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param}; +use syntax::ast::{def_typaram_binder, def_static_method}; +use syntax::ast::{def_upvar, def_use, def_variant, expr, expr_assign_op}; +use syntax::ast::{expr_binary, expr_cast, expr_field, expr_fn}; +use syntax::ast::{expr_fn_block, expr_index, expr_path}; +use syntax::ast::{def_prim_ty, def_region, def_self, def_ty, def_ty_param}; +use syntax::ast::{def_upvar, def_use, def_variant, div, eq}; +use syntax::ast::{enum_variant_kind, expr, expr_again, expr_assign_op}; +use syntax::ast::{expr_binary, expr_break, expr_cast, expr_field, expr_fn}; +use syntax::ast::{expr_fn_block, expr_index, expr_loop}; +use syntax::ast::{expr_path, expr_struct, expr_unary, fn_decl}; +use syntax::ast::{foreign_item, foreign_item_const, foreign_item_fn, ge}; +use syntax::ast::{gt, ident, impure_fn, inherited, item, item_class}; +use syntax::ast::{item_const, item_enum, item_fn, item_foreign_mod}; +use syntax::ast::{item_impl, item_mac, item_mod, item_trait, item_ty, le}; +use syntax::ast::{local, local_crate, lt, method, module_ns, mul, ne, neg}; +use syntax::ast::{node_id, pat, pat_enum, pat_ident, path, prim_ty}; +use syntax::ast::{pat_box, pat_lit, pat_range, pat_rec, pat_struct}; +use syntax::ast::{pat_tup, pat_uniq, pat_wild, private, provided, public}; +use syntax::ast::{required, rem, self_ty_, shl, shr, stmt_decl}; +use syntax::ast::{struct_field, struct_variant_kind, sty_static, subtract}; +use syntax::ast::{trait_ref, tuple_variant_kind, ty, ty_bool, ty_char}; +use syntax::ast::{ty_f, ty_f32, ty_f64, ty_float, ty_i, ty_i16, ty_i32}; +use syntax::ast::{ty_i64, ty_i8, ty_int, ty_param, ty_path, ty_str, ty_u}; +use syntax::ast::{ty_u16, ty_u32, ty_u64, ty_u8, ty_uint, type_value_ns}; +use syntax::ast::{variant, view_item, view_item_export, view_item_import}; +use syntax::ast::{view_item_use, view_path_glob, view_path_list}; +use syntax::ast::{view_path_simple, visibility, anonymous, named}; +use syntax::ast_util::{def_id_of_def, dummy_sp, local_def, new_def_hash}; +use syntax::ast_util::{path_to_ident, walk_pat, trait_method_to_ty_method}; +use syntax::attr::{attr_metas, contains_name}; +use syntax::print::pprust::{pat_to_str, path_to_str}; +use syntax::codemap::span; +use syntax::visit::{default_visitor, fk_method, mk_vt, visit_block}; +use syntax::visit::{visit_crate, visit_expr, visit_expr_opt, visit_fn}; +use syntax::visit::{visit_foreign_item, visit_item, visit_method_helper}; +use syntax::visit::{visit_mod, visit_ty, vt}; -import box::ptr_eq; -import dvec::DVec; -import option::{get, is_some}; -import str::{connect, split_str}; -import vec::pop; -import syntax::parse::token::ident_interner; +use box::ptr_eq; +use dvec::DVec; +use option::{get, is_some}; +use str::{connect, split_str}; +use vec::pop; +use syntax::parse::token::ident_interner; -import std::list::{cons, list, nil}; -import std::map::{hashmap, int_hash, uint_hash}; -import str_eq = str::eq; +use std::list::{cons, list, nil}; +use std::map::{hashmap, int_hash, uint_hash}; +use str_eq = str::eq; // Definition mapping type DefMap = hashmap; diff --git a/src/rustc/middle/trans/alt.rs b/src/rustc/middle/trans/alt.rs index e1a6d79c8a6..8b884792578 100644 --- a/src/rustc/middle/trans/alt.rs +++ b/src/rustc/middle/trans/alt.rs @@ -1,21 +1,21 @@ -import driver::session::session; -import lib::llvm::llvm; -import lib::llvm::{ValueRef, BasicBlockRef}; -import pat_util::*; -import build::*; -import base::*; -import syntax::ast; -import syntax::ast_util; -import syntax::ast_util::{dummy_sp, path_to_ident}; -import syntax::ast::def_id; -import syntax::codemap::span; -import syntax::print::pprust::pat_to_str; -import middle::resolve::DefMap; -import back::abi; -import std::map::hashmap; -import dvec::DVec; +use driver::session::session; +use lib::llvm::llvm; +use lib::llvm::{ValueRef, BasicBlockRef}; +use pat_util::*; +use build::*; +use base::*; +use syntax::ast; +use syntax::ast_util; +use syntax::ast_util::{dummy_sp, path_to_ident}; +use syntax::ast::def_id; +use syntax::codemap::span; +use syntax::print::pprust::pat_to_str; +use middle::resolve::DefMap; +use back::abi; +use std::map::hashmap; +use dvec::DVec; -import common::*; +use common::*; // An option identifying a branch (either a literal, a enum variant or a // range) diff --git a/src/rustc/middle/trans/base.rs b/src/rustc/middle/trans/base.rs index f3a60fd3a6d..836948aff02 100644 --- a/src/rustc/middle/trans/base.rs +++ b/src/rustc/middle/trans/base.rs @@ -13,46 +13,46 @@ // 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 libc::{c_uint, c_ulonglong}; -import std::{map, time, list}; -import std::map::hashmap; -import std::map::{int_hash, str_hash}; -import driver::session; -import session::session; -import syntax::attr; -import back::{link, abi, upcall}; -import syntax::{ast, ast_util, codemap, ast_map}; -import ast_util::{local_def, path_to_ident}; -import syntax::visit; -import syntax::codemap::span; -import syntax::print::pprust::{expr_to_str, stmt_to_str, path_to_str}; -import pat_util::*; -import visit::vt; -import util::common::is_main_name; -import lib::llvm::{llvm, mk_target_data, mk_type_names}; -import lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef}; -import lib::llvm::{True, False}; -import link::{mangle_internal_name_by_type_only, +use libc::{c_uint, c_ulonglong}; +use std::{map, time, list}; +use std::map::hashmap; +use std::map::{int_hash, str_hash}; +use driver::session; +use session::session; +use syntax::attr; +use back::{link, abi, upcall}; +use syntax::{ast, ast_util, codemap, ast_map}; +use ast_util::{local_def, path_to_ident}; +use syntax::visit; +use syntax::codemap::span; +use syntax::print::pprust::{expr_to_str, stmt_to_str, path_to_str}; +use pat_util::*; +use visit::vt; +use util::common::is_main_name; +use lib::llvm::{llvm, mk_target_data, mk_type_names}; +use lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef}; +use lib::llvm::{True, False}; +use 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::{csearch, cstore, decoder, encoder}; -import metadata::common::link_meta; -import util::ppaux; -import util::ppaux::{ty_to_str, ty_to_short_str}; -import syntax::diagnostic::expect; +use metadata::{csearch, cstore, decoder, encoder}; +use metadata::common::link_meta; +use util::ppaux; +use util::ppaux::{ty_to_str, ty_to_short_str}; +use syntax::diagnostic::expect; -import build::*; -import shape::*; -import type_of::*; -import common::*; -import common::result; -import syntax::ast_map::{path, path_mod, path_name}; -import syntax::parse::token::special_idents; +use build::*; +use shape::*; +use type_of::*; +use common::*; +use common::result; +use syntax::ast_map::{path, path_mod, path_name}; +use syntax::parse::token::special_idents; -import std::smallintmap; -import option::{is_none, is_some}; +use std::smallintmap; +use option::{is_none, is_some}; // Destinations diff --git a/src/rustc/middle/trans/build.rs b/src/rustc/middle/trans/build.rs index 400a5ed2b82..12b8f58117d 100644 --- a/src/rustc/middle/trans/build.rs +++ b/src/rustc/middle/trans/build.rs @@ -1,13 +1,13 @@ -import std::map::{hashmap, str_hash}; -import libc::{c_uint, c_int}; -import lib::llvm::llvm; -import syntax::codemap; -import codemap::span; -import lib::llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, ModuleRef}; -import lib::llvm::{Opcode, IntPredicate, RealPredicate, True, False, +use std::map::{hashmap, str_hash}; +use libc::{c_uint, c_int}; +use lib::llvm::llvm; +use syntax::codemap; +use codemap::span; +use lib::llvm::{ValueRef, TypeRef, BasicBlockRef, BuilderRef, ModuleRef}; +use lib::llvm::{Opcode, IntPredicate, RealPredicate, True, False, CallConv, TypeKind, AtomicBinOp, AtomicOrdering}; -import common::*; -import driver::session::session; +use common::*; +use driver::session::session; fn B(cx: block) -> BuilderRef { let b = cx.fcx.ccx.builder.B; diff --git a/src/rustc/middle/trans/closure.rs b/src/rustc/middle/trans/closure.rs index 17424dcc023..4e46286894d 100644 --- a/src/rustc/middle/trans/closure.rs +++ b/src/rustc/middle/trans/closure.rs @@ -1,22 +1,22 @@ -import libc::c_uint; -import syntax::ast; -import syntax::ast_util; -import lib::llvm::llvm; -import lib::llvm::{ValueRef, TypeRef}; -import common::*; -import build::*; -import base::*; -import type_of::*; -import back::abi; -import syntax::codemap::span; -import syntax::print::pprust::expr_to_str; -import back::link::{ +use libc::c_uint; +use syntax::ast; +use syntax::ast_util; +use lib::llvm::llvm; +use lib::llvm::{ValueRef, TypeRef}; +use common::*; +use build::*; +use base::*; +use type_of::*; +use back::abi; +use syntax::codemap::span; +use syntax::print::pprust::expr_to_str; +use back::link::{ mangle_internal_name_by_path, mangle_internal_name_by_path_and_seq}; -import util::ppaux::ty_to_str; -import syntax::ast_map::{path, path_mod, path_name}; -import driver::session::session; -import std::map::hashmap; +use util::ppaux::ty_to_str; +use syntax::ast_map::{path, path_mod, path_name}; +use driver::session::session; +use std::map::hashmap; // ___Good to know (tm)__________________________________________________ // diff --git a/src/rustc/middle/trans/common.rs b/src/rustc/middle/trans/common.rs index dc5bf00b59d..71e1ba8ac16 100644 --- a/src/rustc/middle/trans/common.rs +++ b/src/rustc/middle/trans/common.rs @@ -3,25 +3,25 @@ */ -import libc::c_uint; -import vec::unsafe::to_ptr; -import std::map::{hashmap,set}; -import syntax::{ast, ast_map}; -import driver::session; -import session::session; -import middle::ty; -import back::{link, abi, upcall}; -import syntax::codemap::span; -import lib::llvm::{llvm, target_data, type_names, associate_type, +use libc::c_uint; +use vec::unsafe::to_ptr; +use std::map::{hashmap,set}; +use syntax::{ast, ast_map}; +use driver::session; +use session::session; +use middle::ty; +use back::{link, abi, upcall}; +use syntax::codemap::span; +use lib::llvm::{llvm, target_data, type_names, associate_type, name_has_type}; -import lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef, BuilderRef}; -import lib::llvm::{True, False, Bool}; -import metadata::{csearch}; -import metadata::common::link_meta; -import syntax::ast_map::path; -import util::ppaux::ty_to_str; -import syntax::parse::token::ident_interner; -import syntax::ast::ident; +use lib::llvm::{ModuleRef, ValueRef, TypeRef, BasicBlockRef, BuilderRef}; +use lib::llvm::{True, False, Bool}; +use metadata::{csearch}; +use metadata::common::link_meta; +use syntax::ast_map::path; +use util::ppaux::ty_to_str; +use syntax::parse::token::ident_interner; +use syntax::ast::ident; type namegen = fn@(~str) -> ident; fn new_namegen(intr: ident_interner) -> namegen { diff --git a/src/rustc/middle/trans/consts.rs b/src/rustc/middle/trans/consts.rs index a82afc66cfa..ec3e55fb2ae 100644 --- a/src/rustc/middle/trans/consts.rs +++ b/src/rustc/middle/trans/consts.rs @@ -1,6 +1,6 @@ -import common::*; -import syntax::{ast, ast_util, codemap, ast_map}; -import base::get_insn_ctxt; +use common::*; +use syntax::{ast, ast_util, codemap, ast_map}; +use base::get_insn_ctxt; fn const_lit(cx: @crate_ctxt, e: @ast::expr, lit: ast::lit) -> ValueRef { diff --git a/src/rustc/middle/trans/debuginfo.rs b/src/rustc/middle/trans/debuginfo.rs index 1362c67041b..2e5b06f0a55 100644 --- a/src/rustc/middle/trans/debuginfo.rs +++ b/src/rustc/middle/trans/debuginfo.rs @@ -1,18 +1,18 @@ -import std::map; -import std::map::hashmap; -import lib::llvm::llvm; -import lib::llvm::ValueRef; -import trans::common::*; -import trans::base; -import trans::build::B; -import middle::ty; -import syntax::{ast, codemap, ast_util, ast_map}; -import syntax::parse::token::ident_interner; -import codemap::span; -import ast::ty; -import pat_util::*; -import util::ppaux::ty_to_str; -import driver::session::session; +use std::map; +use std::map::hashmap; +use lib::llvm::llvm; +use lib::llvm::ValueRef; +use trans::common::*; +use trans::base; +use trans::build::B; +use middle::ty; +use syntax::{ast, codemap, ast_util, ast_map}; +use syntax::parse::token::ident_interner; +use codemap::span; +use ast::ty; +use pat_util::*; +use util::ppaux::ty_to_str; +use driver::session::session; export create_local_var; export create_function; diff --git a/src/rustc/middle/trans/foreign.rs b/src/rustc/middle/trans/foreign.rs index 6452fee3d53..504aea89214 100644 --- a/src/rustc/middle/trans/foreign.rs +++ b/src/rustc/middle/trans/foreign.rs @@ -1,22 +1,22 @@ // The classification code for the x86_64 ABI is taken from the clay language // https://github.com/jckarter/clay/blob/master/compiler/src/externals.cpp -import driver::session::{session, arch_x86_64}; -import syntax::codemap::span; -import libc::c_uint; -import syntax::{attr, ast_map}; -import lib::llvm::{ llvm, TypeRef, ValueRef, Integer, Pointer, Float, Double, +use driver::session::{session, arch_x86_64}; +use syntax::codemap::span; +use libc::c_uint; +use syntax::{attr, ast_map}; +use lib::llvm::{ llvm, TypeRef, ValueRef, Integer, Pointer, Float, Double, Struct, Array, ModuleRef, CallConv, Attribute, StructRetAttribute, ByValAttribute, SequentiallyConsistent, Acquire, Release, Xchg }; -import syntax::{ast, ast_util}; -import back::{link, abi}; -import common::*; -import build::*; -import base::*; -import type_of::*; -import std::map::hashmap; -import util::ppaux::ty_to_str; +use syntax::{ast, ast_util}; +use back::{link, abi}; +use common::*; +use build::*; +use base::*; +use type_of::*; +use std::map::hashmap; +use util::ppaux::ty_to_str; export link_name, trans_foreign_mod, register_foreign_fn, trans_foreign_fn, trans_intrinsic; diff --git a/src/rustc/middle/trans/impl.rs b/src/rustc/middle/trans/impl.rs index 6ffeb861270..af5dcfe3f6b 100644 --- a/src/rustc/middle/trans/impl.rs +++ b/src/rustc/middle/trans/impl.rs @@ -1,22 +1,22 @@ -import libc::c_uint; -import base::*; -import common::*; -import type_of::*; -import build::*; -import driver::session::session; -import syntax::{ast, ast_map}; -import ast_map::{path, path_mod, path_name, node_id_to_str}; -import driver::session::expect; -import syntax::ast_util::local_def; -import metadata::csearch; -import back::{link, abi}; -import lib::llvm::llvm; -import lib::llvm::{ValueRef, TypeRef}; -import lib::llvm::llvm::LLVMGetParam; -import std::map::hashmap; -import util::ppaux::{ty_to_str, tys_to_str}; +use libc::c_uint; +use base::*; +use common::*; +use type_of::*; +use build::*; +use driver::session::session; +use syntax::{ast, ast_map}; +use ast_map::{path, path_mod, path_name, node_id_to_str}; +use driver::session::expect; +use syntax::ast_util::local_def; +use metadata::csearch; +use back::{link, abi}; +use lib::llvm::llvm; +use lib::llvm::{ValueRef, TypeRef}; +use lib::llvm::llvm::LLVMGetParam; +use std::map::hashmap; +use util::ppaux::{ty_to_str, tys_to_str}; -import syntax::print::pprust::expr_to_str; +use syntax::print::pprust::expr_to_str; /** The main "translation" pass for methods. Generates code diff --git a/src/rustc/middle/trans/reachable.rs b/src/rustc/middle/trans/reachable.rs index 981a8125655..1885d8cdb22 100644 --- a/src/rustc/middle/trans/reachable.rs +++ b/src/rustc/middle/trans/reachable.rs @@ -5,13 +5,13 @@ // makes all other generics or inline functions that it references // reachable as well. -import syntax::ast::*; -import syntax::{visit, ast_util, ast_map}; -import syntax::ast_util::def_id_of_def; -import syntax::attr; -import syntax::print::pprust::expr_to_str; -import std::map::hashmap; -import driver::session::*; +use syntax::ast::*; +use syntax::{visit, ast_util, ast_map}; +use syntax::ast_util::def_id_of_def; +use syntax::attr; +use syntax::print::pprust::expr_to_str; +use std::map::hashmap; +use driver::session::*; export map, find_reachable; diff --git a/src/rustc/middle/trans/reflect.rs b/src/rustc/middle/trans/reflect.rs index 7825d412ddd..786d5eec5cb 100644 --- a/src/rustc/middle/trans/reflect.rs +++ b/src/rustc/middle/trans/reflect.rs @@ -1,14 +1,14 @@ -import std::map::{hashmap,str_hash}; -import driver::session::session; -import lib::llvm::{TypeRef, ValueRef}; -import syntax::ast; -import back::abi; -import common::*; -import build::*; -import base::*; -import type_of::*; -import ast::def_id; -import util::ppaux::ty_to_str; +use std::map::{hashmap,str_hash}; +use driver::session::session; +use lib::llvm::{TypeRef, ValueRef}; +use syntax::ast; +use back::abi; +use common::*; +use build::*; +use base::*; +use type_of::*; +use ast::def_id; +use util::ppaux::ty_to_str; enum reflector = { visitor_val: ValueRef, diff --git a/src/rustc/middle/trans/shape.rs b/src/rustc/middle/trans/shape.rs index 2dd5d968cee..0ff538b3f90 100644 --- a/src/rustc/middle/trans/shape.rs +++ b/src/rustc/middle/trans/shape.rs @@ -1,26 +1,26 @@ // A "shape" is a compact encoding of a type that is used by interpreted glue. // This substitutes for the runtime tags used by e.g. MLs. -import lib::llvm::llvm; -import lib::llvm::{True, False, ModuleRef, TypeRef, ValueRef}; -import driver::session; -import driver::session::session; -import trans::base; -import middle::trans::common::*; -import back::abi; -import middle::ty; -import middle::ty::field; -import syntax::ast; -import syntax::ast_util::{dummy_sp, new_def_hash}; -import syntax::util::interner; -import util::ppaux::ty_to_str; -import syntax::codemap::span; -import dvec::DVec; +use lib::llvm::llvm; +use lib::llvm::{True, False, ModuleRef, TypeRef, ValueRef}; +use driver::session; +use driver::session::session; +use trans::base; +use middle::trans::common::*; +use back::abi; +use middle::ty; +use middle::ty::field; +use syntax::ast; +use syntax::ast_util::{dummy_sp, new_def_hash}; +use syntax::util::interner; +use util::ppaux::ty_to_str; +use syntax::codemap::span; +use dvec::DVec; -import std::map::hashmap; -import option::is_some; +use std::map::hashmap; +use option::is_some; -import ty_ctxt = middle::ty::ctxt; +use ty_ctxt = middle::ty::ctxt; type nominal_id = @{did: ast::def_id, parent_id: Option, tps: ~[ty::t]}; diff --git a/src/rustc/middle/trans/tvec.rs b/src/rustc/middle/trans/tvec.rs index 523d5b66305..0473c62c99c 100644 --- a/src/rustc/middle/trans/tvec.rs +++ b/src/rustc/middle/trans/tvec.rs @@ -1,16 +1,16 @@ -import syntax::ast; -import driver::session::session; -import lib::llvm::{ValueRef, TypeRef}; -import back::abi; -import base::{call_memmove, +use syntax::ast; +use driver::session::session; +use lib::llvm::{ValueRef, TypeRef}; +use back::abi; +use base::{call_memmove, INIT, copy_val, load_if_immediate, get_tydesc, sub_block, do_spill_noroot, dest, non_gc_box_cast, move_val, lval_owned}; -import syntax::codemap::span; -import shape::llsize_of; -import build::*; -import common::*; -import util::ppaux::ty_to_str; +use syntax::codemap::span; +use shape::llsize_of; +use build::*; +use common::*; +use util::ppaux::ty_to_str; // Boxed vector types are in some sense currently a "shorthand" for a box // containing an unboxed vector. This expands a boxed vector type into such an diff --git a/src/rustc/middle/trans/type_of.rs b/src/rustc/middle/trans/type_of.rs index 0ea48a1d844..2a4322eb215 100644 --- a/src/rustc/middle/trans/type_of.rs +++ b/src/rustc/middle/trans/type_of.rs @@ -1,9 +1,9 @@ -import common::*; -import lib::llvm::{TypeRef}; -import syntax::ast; -import lib::llvm::llvm; -import driver::session::session; -import std::map::hashmap; +use common::*; +use lib::llvm::{TypeRef}; +use syntax::ast; +use lib::llvm::llvm; +use driver::session::session; +use std::map::hashmap; export type_of; export type_of_dtor; diff --git a/src/rustc/middle/trans/type_use.rs b/src/rustc/middle/trans/type_use.rs index f2d3f4d4718..3a09b2f0fdc 100644 --- a/src/rustc/middle/trans/type_use.rs +++ b/src/rustc/middle/trans/type_use.rs @@ -17,14 +17,14 @@ // much information, but have the disadvantage of being very // invasive.) -import std::map::hashmap; -import std::list; -import std::list::{list, cons, nil}; -import driver::session::session; -import metadata::csearch; -import syntax::ast::*, syntax::ast_util, syntax::visit; -import syntax::ast_map; -import common::*; +use std::map::hashmap; +use std::list; +use std::list::{list, cons, nil}; +use driver::session::session; +use metadata::csearch; +use syntax::ast::*, syntax::ast_util, syntax::visit; +use syntax::ast_map; +use common::*; type type_uses = uint; // Bitmask const use_repr: uint = 1u; // Dependency on size/alignment and take/drop glue diff --git a/src/rustc/middle/trans/uniq.rs b/src/rustc/middle/trans/uniq.rs index 214fa0547ae..cd6710f274c 100644 --- a/src/rustc/middle/trans/uniq.rs +++ b/src/rustc/middle/trans/uniq.rs @@ -1,9 +1,9 @@ -import syntax::ast; -import lib::llvm::ValueRef; -import common::*; -import build::*; -import base::*; -import shape::llsize_of; +use syntax::ast; +use lib::llvm::ValueRef; +use common::*; +use build::*; +use base::*; +use shape::llsize_of; export make_free_glue, autoderef, duplicate; diff --git a/src/rustc/middle/tstate/annotate.rs b/src/rustc/middle/tstate/annotate.rs index 8dcbe2251b8..a8dbbcab2b8 100644 --- a/src/rustc/middle/tstate/annotate.rs +++ b/src/rustc/middle/tstate/annotate.rs @@ -1,11 +1,11 @@ -import syntax::ast::*; -import syntax::visit; -import syntax::codemap::span; -import syntax::print::pprust::stmt_to_str; -import aux::{num_constraints, get_fn_info, crate_ctxt, add_node}; -import ann::empty_ann; -import pat_util::pat_binding_ids; +use syntax::ast::*; +use syntax::visit; +use syntax::codemap::span; +use syntax::print::pprust::stmt_to_str; +use aux::{num_constraints, get_fn_info, crate_ctxt, add_node}; +use ann::empty_ann; +use pat_util::pat_binding_ids; fn collect_ids_expr(e: @expr, rs: @mut ~[node_id]) { vec::push(*rs, e.id); } diff --git a/src/rustc/middle/tstate/auxiliary.rs b/src/rustc/middle/tstate/auxiliary.rs index 7920d376ffb..849d4416692 100644 --- a/src/rustc/middle/tstate/auxiliary.rs +++ b/src/rustc/middle/tstate/auxiliary.rs @@ -1,23 +1,23 @@ -import option::*; -import pat_util::*; -import syntax::ast::*; -import syntax::ast_util::*; -import syntax::{visit, codemap}; -import codemap::span; -import std::map::{hashmap, int_hash}; -import syntax::print::pprust::path_to_str; -import tstate::ann::{pre_and_post, pre_and_post_state, empty_ann, prestate, +use option::*; +use pat_util::*; +use syntax::ast::*; +use syntax::ast_util::*; +use syntax::{visit, codemap}; +use codemap::span; +use std::map::{hashmap, int_hash}; +use syntax::print::pprust::path_to_str; +use tstate::ann::{pre_and_post, pre_and_post_state, empty_ann, prestate, poststate, precond, postcond, set_prestate, set_poststate, set_in_poststate_, extend_prestate, extend_poststate, set_precondition, set_postcondition, ts_ann, clear_in_postcond, clear_in_poststate_}; -import driver::session::session; -import dvec::{dvec, extensions}; -import tritv::{trit, tfalse, ttrue, dont_care, t}; +use driver::session::session; +use dvec::{dvec, extensions}; +use tritv::{trit, tfalse, ttrue, dont_care, t}; -import syntax::print::pprust::{constr_args_to_str, lit_to_str}; +use syntax::print::pprust::{constr_args_to_str, lit_to_str}; // Used to communicate which operands should be invalidated // to helper functions diff --git a/src/rustc/middle/tstate/ck.rs b/src/rustc/middle/tstate/ck.rs index c37f067e698..b0b99fcf96c 100644 --- a/src/rustc/middle/tstate/ck.rs +++ b/src/rustc/middle/tstate/ck.rs @@ -1,22 +1,22 @@ -import syntax::ast; -import ast::{stmt, fn_ident, node_id, crate, return_val, noreturn, expr}; -import syntax::{visit, print}; -import syntax::codemap::span; -import middle::ty; -import tstate::ann::{precond, prestate, +use syntax::ast; +use ast::{stmt, fn_ident, node_id, crate, return_val, noreturn, expr}; +use syntax::{visit, print}; +use syntax::codemap::span; +use middle::ty; +use tstate::ann::{precond, prestate, implies, ann_precond, ann_prestate}; -import aux::*; +use aux::*; -import util::ppaux::ty_to_str; -import bitvectors::*; -import annotate::annotate_crate; -import collect_locals::mk_f_to_fn_info; -import pre_post_conditions::fn_pre_post; -import states::find_pre_post_state_fn; -import syntax::print::pprust::expr_to_str; -import driver::session::session; -import std::map::hashmap; +use util::ppaux::ty_to_str; +use bitvectors::*; +use annotate::annotate_crate; +use collect_locals::mk_f_to_fn_info; +use pre_post_conditions::fn_pre_post; +use states::find_pre_post_state_fn; +use syntax::print::pprust::expr_to_str; +use driver::session::session; +use std::map::hashmap; fn check_states_expr(e: @expr, fcx: fn_ctxt, v: visit::vt) { visit::visit_expr(e, fcx, v); diff --git a/src/rustc/middle/tstate/collect_locals.rs b/src/rustc/middle/tstate/collect_locals.rs index ec27dfea6ed..3a1a54b7946 100644 --- a/src/rustc/middle/tstate/collect_locals.rs +++ b/src/rustc/middle/tstate/collect_locals.rs @@ -1,14 +1,14 @@ -import option::*; -import pat_util::*; -import syntax::ast::*; -import syntax::ast_util::*; -import syntax::visit; -import syntax::codemap::span; -import syntax::ast_util::respan; -import driver::session::session; -import aux::*; -import std::map::hashmap; -import dvec::{dvec, extensions}; +use option::*; +use pat_util::*; +use syntax::ast::*; +use syntax::ast_util::*; +use syntax::visit; +use syntax::codemap::span; +use syntax::ast_util::respan; +use driver::session::session; +use aux::*; +use std::map::hashmap; +use dvec::{dvec, extensions}; type ctxt = {cs: @mut ~[sp_constr], tcx: ty::ctxt}; diff --git a/src/rustc/middle/tstate/pre_post_conditions.rs b/src/rustc/middle/tstate/pre_post_conditions.rs index d1e49caa99a..5314a0a3d54 100644 --- a/src/rustc/middle/tstate/pre_post_conditions.rs +++ b/src/rustc/middle/tstate/pre_post_conditions.rs @@ -1,19 +1,19 @@ -import tstate::ann::*; -import aux::*; -import bitvectors::{bit_num, seq_preconds, seq_postconds, +use tstate::ann::*; +use aux::*; +use bitvectors::{bit_num, seq_preconds, seq_postconds, intersect_states, relax_precond_block, gen}; -import tritv::*; +use tritv::*; -import pat_util::*; -import syntax::ast::*; -import syntax::ast_util::*; -import syntax::print::pprust::{expr_to_str, stmt_to_str}; -import syntax::visit; -import util::common::{field_exprs, has_nonlocal_exits}; -import syntax::codemap::span; -import driver::session::session; -import std::map::hashmap; +use pat_util::*; +use syntax::ast::*; +use syntax::ast_util::*; +use syntax::print::pprust::{expr_to_str, stmt_to_str}; +use syntax::visit; +use util::common::{field_exprs, has_nonlocal_exits}; +use syntax::codemap::span; +use driver::session::session; +use std::map::hashmap; fn find_pre_post_mod(_m: _mod) -> _mod { debug!("implement find_pre_post_mod!"); diff --git a/src/rustc/middle/tstate/states.rs b/src/rustc/middle/tstate/states.rs index d0422a6c0a5..369f328a72b 100644 --- a/src/rustc/middle/tstate/states.rs +++ b/src/rustc/middle/tstate/states.rs @@ -1,18 +1,18 @@ -import ann::*; -import aux::*; -import tritv::*; +use ann::*; +use aux::*; +use tritv::*; -import syntax::print::pprust::block_to_str; -import bitvectors::*; -import pat_util::*; -import syntax::ast::*; -import syntax::ast_util::*; -import syntax::print::pprust::{expr_to_str, stmt_to_str}; -import syntax::codemap::span; -import middle::ty::{expr_ty, type_is_bot}; -import util::common::{field_exprs, has_nonlocal_exits, may_break}; -import driver::session::session; -import std::map::hashmap; +use syntax::print::pprust::block_to_str; +use bitvectors::*; +use pat_util::*; +use syntax::ast::*; +use syntax::ast_util::*; +use syntax::print::pprust::{expr_to_str, stmt_to_str}; +use syntax::codemap::span; +use middle::ty::{expr_ty, type_is_bot}; +use util::common::{field_exprs, has_nonlocal_exits, may_break}; +use driver::session::session; +use std::map::hashmap; fn forbid_upvar(fcx: fn_ctxt, rhs_id: node_id, sp: span, t: oper_type) { match t { diff --git a/src/rustc/middle/ty.rs b/src/rustc/middle/ty.rs index d467f3b5be5..f473244eda8 100644 --- a/src/rustc/middle/ty.rs +++ b/src/rustc/middle/ty.rs @@ -1,23 +1,23 @@ // #[warn(deprecated_mode)]; #[warn(deprecated_pattern)]; -import std::{map, smallintmap}; -import result::Result; -import std::map::hashmap; -import driver::session; -import session::session; -import syntax::{ast, ast_map}; -import syntax::ast_util; -import syntax::ast_util::{is_local, local_def, new_def_hash}; -import syntax::codemap::span; -import metadata::csearch; -import util::ppaux::{region_to_str, explain_region, vstore_to_str}; -import middle::lint; -import middle::lint::{get_lint_level, allow}; -import syntax::ast::*; -import syntax::print::pprust::*; -import util::ppaux::{ty_to_str, proto_ty_to_str, tys_to_str}; -import std::serialization::{serialize_Option, +use std::{map, smallintmap}; +use result::Result; +use std::map::hashmap; +use driver::session; +use session::session; +use syntax::{ast, ast_map}; +use syntax::ast_util; +use syntax::ast_util::{is_local, local_def, new_def_hash}; +use syntax::codemap::span; +use metadata::csearch; +use util::ppaux::{region_to_str, explain_region, vstore_to_str}; +use middle::lint; +use middle::lint::{get_lint_level, allow}; +use syntax::ast::*; +use syntax::print::pprust::*; +use util::ppaux::{ty_to_str, proto_ty_to_str, tys_to_str}; +use std::serialization::{serialize_Option, deserialize_Option}; export tv_vid, tvi_vid, region_vid, vid; diff --git a/src/rustc/middle/typeck.rs b/src/rustc/middle/typeck.rs index 1fa619a1ca3..9a838d4bc24 100644 --- a/src/rustc/middle/typeck.rs +++ b/src/rustc/middle/typeck.rs @@ -38,33 +38,33 @@ independently: */ -import result::Result; -import syntax::{ast, ast_util, ast_map}; -import ast::spanned; -import ast::{required, provided}; -import syntax::ast_map::node_id_to_str; -import syntax::ast_util::{local_def, respan, split_trait_methods}; -import syntax::visit; -import metadata::csearch; -import driver::session::session; -import util::common::may_break; -import syntax::codemap::span; -import pat_util::{pat_is_variant, pat_id_map}; -import middle::ty; -import middle::ty::{arg, field, node_type_table, mk_nil, +use result::Result; +use syntax::{ast, ast_util, ast_map}; +use ast::spanned; +use ast::{required, provided}; +use syntax::ast_map::node_id_to_str; +use syntax::ast_util::{local_def, respan, split_trait_methods}; +use syntax::visit; +use metadata::csearch; +use driver::session::session; +use util::common::may_break; +use syntax::codemap::span; +use pat_util::{pat_is_variant, pat_id_map}; +use middle::ty; +use middle::ty::{arg, field, node_type_table, mk_nil, ty_param_bounds_and_ty, lookup_public_fields, vstore_uniq}; -import std::smallintmap; -import std::map; -import std::map::{hashmap, int_hash}; -import std::serialization::{serialize_uint, deserialize_uint}; -import vec::each; -import syntax::print::pprust::*; -import util::ppaux::{ty_to_str, tys_to_str, region_to_str, +use std::smallintmap; +use std::map; +use std::map::{hashmap, int_hash}; +use std::serialization::{serialize_uint, deserialize_uint}; +use vec::each; +use syntax::print::pprust::*; +use util::ppaux::{ty_to_str, tys_to_str, region_to_str, bound_region_to_str, vstore_to_str}; -import util::common::{indent, indenter}; -import std::list; -import list::{list, nil, cons}; +use util::common::{indent, indenter}; +use std::list; +use list::{list, nil, cons}; export check_crate; export infer; diff --git a/src/rustc/middle/typeck/astconv.rs b/src/rustc/middle/typeck/astconv.rs index d4d31cebff3..df0b2e1c221 100644 --- a/src/rustc/middle/typeck/astconv.rs +++ b/src/rustc/middle/typeck/astconv.rs @@ -42,9 +42,9 @@ * an rptr (`&r.T`) use the region `r` that appears in the rptr. */ -import check::fn_ctxt; -import rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope}; -import rscope::{in_binding_rscope, region_scope, type_rscope}; +use check::fn_ctxt; +use rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope}; +use rscope::{in_binding_rscope, region_scope, type_rscope}; trait ast_conv { fn tcx() -> ty::ctxt; diff --git a/src/rustc/middle/typeck/check.rs b/src/rustc/middle/typeck/check.rs index f93fc3a01fb..b56a8efa606 100644 --- a/src/rustc/middle/typeck/check.rs +++ b/src/rustc/middle/typeck/check.rs @@ -66,18 +66,18 @@ type parameter). */ -import astconv::{ast_conv, ast_path_to_ty, ast_ty_to_ty}; -import astconv::{ast_region_to_region}; -import middle::ty::{tv_vid, vid}; -import regionmanip::{replace_bound_regions_in_fn_ty}; -import rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope}; -import rscope::{in_binding_rscope, region_scope, type_rscope, +use astconv::{ast_conv, ast_path_to_ty, ast_ty_to_ty}; +use astconv::{ast_region_to_region}; +use middle::ty::{tv_vid, vid}; +use regionmanip::{replace_bound_regions_in_fn_ty}; +use rscope::{anon_rscope, binding_rscope, empty_rscope, in_anon_rscope}; +use rscope::{in_binding_rscope, region_scope, type_rscope, bound_self_region}; -import syntax::ast::ty_i; -import typeck::infer::{resolve_type, force_tvar}; -import result::{Result, Ok, Err}; +use syntax::ast::ty_i; +use typeck::infer::{resolve_type, force_tvar}; +use result::{Result, Ok, Err}; -import std::map::{str_hash, uint_hash}; +use std::map::{str_hash, uint_hash}; type self_info = { self_ty: ty::t, diff --git a/src/rustc/middle/typeck/check/alt.rs b/src/rustc/middle/typeck/check/alt.rs index 00562144ef6..31202da4500 100644 --- a/src/rustc/middle/typeck/check/alt.rs +++ b/src/rustc/middle/typeck/check/alt.rs @@ -1,4 +1,4 @@ -import syntax::print::pprust; +use syntax::print::pprust; fn check_alt(fcx: @fn_ctxt, expr: @ast::expr, diff --git a/src/rustc/middle/typeck/check/demand.rs b/src/rustc/middle/typeck/check/demand.rs index 55272b8c419..8575bc6906a 100644 --- a/src/rustc/middle/typeck/check/demand.rs +++ b/src/rustc/middle/typeck/check/demand.rs @@ -1,4 +1,4 @@ -import check::fn_ctxt; +use check::fn_ctxt; // Requires that the two types unify, and prints an error message if they // don't. diff --git a/src/rustc/middle/typeck/check/method.rs b/src/rustc/middle/typeck/check/method.rs index b3dc032f0bf..994200b7f01 100644 --- a/src/rustc/middle/typeck/check/method.rs +++ b/src/rustc/middle/typeck/check/method.rs @@ -1,15 +1,15 @@ /* Code to handle method lookups (which can be quite complex) */ -import coherence::get_base_type_def_id; -import middle::resolve::{Impl, MethodInfo}; -import middle::ty::{mk_box, mk_rptr, mk_uniq}; -import syntax::ast::{def_id, +use coherence::get_base_type_def_id; +use middle::resolve::{Impl, MethodInfo}; +use middle::ty::{mk_box, mk_rptr, mk_uniq}; +use syntax::ast::{def_id, sty_static, sty_box, sty_by_ref, sty_region, sty_uniq}; -import syntax::ast::{sty_value, by_ref, by_copy}; -import syntax::ast_map; -import syntax::ast_map::node_id_to_str; -import syntax::ast_util::{dummy_sp, new_def_hash}; -import dvec::DVec; +use syntax::ast::{sty_value, by_ref, by_copy}; +use syntax::ast_map; +use syntax::ast_map::node_id_to_str; +use syntax::ast_util::{dummy_sp, new_def_hash}; +use dvec::DVec; enum method_lookup_mode { subtyping_mode, diff --git a/src/rustc/middle/typeck/check/regionck.rs b/src/rustc/middle/typeck/check/regionck.rs index 01286bff38a..540a7e9a479 100644 --- a/src/rustc/middle/typeck/check/regionck.rs +++ b/src/rustc/middle/typeck/check/regionck.rs @@ -17,17 +17,17 @@ this point a bit better. */ -import util::ppaux; -import ppaux::{note_and_explain_region, ty_to_str}; -import syntax::print::pprust; -import infer::{resolve_and_force_all_but_regions, fres}; -import syntax::ast::{def_arg, def_binding, def_local, def_self, def_upvar}; -import middle::freevars::get_freevars; -import middle::kind::check_owned; -import middle::pat_util::pat_bindings; -import middle::ty::{encl_region, proto_bare, proto_vstore, re_scope}; -import middle::ty::{ty_fn_proto, vstore_box, vstore_fixed, vstore_slice}; -import middle::ty::{vstore_uniq}; +use util::ppaux; +use ppaux::{note_and_explain_region, ty_to_str}; +use syntax::print::pprust; +use infer::{resolve_and_force_all_but_regions, fres}; +use syntax::ast::{def_arg, def_binding, def_local, def_self, def_upvar}; +use middle::freevars::get_freevars; +use middle::kind::check_owned; +use middle::pat_util::pat_bindings; +use middle::ty::{encl_region, proto_bare, proto_vstore, re_scope}; +use middle::ty::{ty_fn_proto, vstore_box, vstore_fixed, vstore_slice}; +use middle::ty::{vstore_uniq}; enum rcx { rcx_({fcx: @fn_ctxt, mut errors_reported: uint}) } type rvt = visit::vt<@rcx>; diff --git a/src/rustc/middle/typeck/check/regionmanip.rs b/src/rustc/middle/typeck/check/regionmanip.rs index 61a59c5dccd..b0dd57890a9 100644 --- a/src/rustc/middle/typeck/check/regionmanip.rs +++ b/src/rustc/middle/typeck/check/regionmanip.rs @@ -1,7 +1,7 @@ // #[warn(deprecated_mode)]; // #[warn(deprecated_pattern)]; -import syntax::print::pprust::{expr_to_str}; +use syntax::print::pprust::{expr_to_str}; // Helper functions related to manipulating region types. diff --git a/src/rustc/middle/typeck/check/vtable.rs b/src/rustc/middle/typeck/check/vtable.rs index f22730cb575..7409ae738ea 100644 --- a/src/rustc/middle/typeck/check/vtable.rs +++ b/src/rustc/middle/typeck/check/vtable.rs @@ -1,9 +1,9 @@ -import check::{fn_ctxt, impl_self_ty}; -import infer::{resolve_type, resolve_and_force_all_but_regions, +use check::{fn_ctxt, impl_self_ty}; +use infer::{resolve_type, resolve_and_force_all_but_regions, fixup_err_to_str}; -import ast_util::new_def_hash; -import syntax::print::pprust; -import result::{Result, Ok, Err}; +use ast_util::new_def_hash; +use syntax::print::pprust; +use result::{Result, Ok, Err}; // vtable resolution looks for places where trait bounds are // subsituted in and figures out which vtable is used. There is some diff --git a/src/rustc/middle/typeck/check/writeback.rs b/src/rustc/middle/typeck/check/writeback.rs index dfb807de9ca..694b0ae03b8 100644 --- a/src/rustc/middle/typeck/check/writeback.rs +++ b/src/rustc/middle/typeck/check/writeback.rs @@ -2,11 +2,11 @@ // unresolved type variables and replaces "ty_var" types with their // substitutions. -import check::{fn_ctxt, lookup_local}; -import infer::{resolve_type, resolve_region, resolve_all, force_all}; +use check::{fn_ctxt, lookup_local}; +use infer::{resolve_type, resolve_region, resolve_all, force_all}; export resolve_type_vars_in_fn; export resolve_type_vars_in_expr; -import result::{Result, Ok, Err}; +use result::{Result, Ok, Err}; fn resolve_type_vars_in_type(fcx: @fn_ctxt, sp: span, typ: ty::t) -> Option diff --git a/src/rustc/middle/typeck/coherence.rs b/src/rustc/middle/typeck/coherence.rs index e8f4c2b5f0d..3820b9110f4 100644 --- a/src/rustc/middle/typeck/coherence.rs +++ b/src/rustc/middle/typeck/coherence.rs @@ -4,37 +4,37 @@ // has at most one implementation for each type. Then we build a mapping from // each trait in the system to its implementations. -import metadata::csearch::{each_path, get_impl_traits, get_impls_for_mod}; -import metadata::cstore::{cstore, iter_crate_data}; -import metadata::decoder::{dl_def, dl_field, dl_impl}; -import middle::resolve::{Impl, MethodInfo}; -import middle::ty::{get, lookup_item_type, subst, t, ty_box}; -import middle::ty::{ty_uniq, ty_ptr, ty_rptr, ty_enum}; -import middle::ty::{ty_class, ty_nil, ty_bot, ty_bool, ty_int, ty_uint}; -import middle::ty::{ty_float, ty_estr, ty_evec, ty_rec}; -import middle::ty::{ty_fn, ty_trait, ty_tup, ty_var, ty_var_integral}; -import middle::ty::{ty_param, ty_self, ty_type, ty_opaque_box}; -import middle::ty::{ty_opaque_closure_ptr, ty_unboxed_vec, type_is_var}; -import middle::typeck::infer::{infer_ctxt, can_mk_subty}; -import middle::typeck::infer::{new_infer_ctxt, resolve_ivar, resolve_type}; -import syntax::ast::{crate, def_id, def_mod}; -import syntax::ast::{item, item_class, item_const, item_enum, item_fn}; -import syntax::ast::{item_foreign_mod, item_impl, item_mac, item_mod}; -import syntax::ast::{item_trait, item_ty, local_crate, method, node_id}; -import syntax::ast::{trait_ref}; -import syntax::ast_map::node_item; -import syntax::ast_util::{def_id_of_def, dummy_sp, new_def_hash}; -import syntax::codemap::span; -import syntax::visit::{default_simple_visitor, default_visitor}; -import syntax::visit::{mk_simple_visitor, mk_vt, visit_crate, visit_item}; -import syntax::visit::{visit_mod}; -import util::ppaux::ty_to_str; +use metadata::csearch::{each_path, get_impl_traits, get_impls_for_mod}; +use metadata::cstore::{cstore, iter_crate_data}; +use metadata::decoder::{dl_def, dl_field, dl_impl}; +use middle::resolve::{Impl, MethodInfo}; +use middle::ty::{get, lookup_item_type, subst, t, ty_box}; +use middle::ty::{ty_uniq, ty_ptr, ty_rptr, ty_enum}; +use middle::ty::{ty_class, ty_nil, ty_bot, ty_bool, ty_int, ty_uint}; +use middle::ty::{ty_float, ty_estr, ty_evec, ty_rec}; +use middle::ty::{ty_fn, ty_trait, ty_tup, ty_var, ty_var_integral}; +use middle::ty::{ty_param, ty_self, ty_type, ty_opaque_box}; +use middle::ty::{ty_opaque_closure_ptr, ty_unboxed_vec, type_is_var}; +use middle::typeck::infer::{infer_ctxt, can_mk_subty}; +use middle::typeck::infer::{new_infer_ctxt, resolve_ivar, resolve_type}; +use syntax::ast::{crate, def_id, def_mod}; +use syntax::ast::{item, item_class, item_const, item_enum, item_fn}; +use syntax::ast::{item_foreign_mod, item_impl, item_mac, item_mod}; +use syntax::ast::{item_trait, item_ty, local_crate, method, node_id}; +use syntax::ast::{trait_ref}; +use syntax::ast_map::node_item; +use syntax::ast_util::{def_id_of_def, dummy_sp, new_def_hash}; +use syntax::codemap::span; +use syntax::visit::{default_simple_visitor, default_visitor}; +use syntax::visit::{mk_simple_visitor, mk_vt, visit_crate, visit_item}; +use syntax::visit::{visit_mod}; +use util::ppaux::ty_to_str; -import dvec::DVec; -import result::Ok; -import std::map::{hashmap, int_hash}; -import uint::range; -import vec::{len, push}; +use dvec::DVec; +use result::Ok; +use std::map::{hashmap, int_hash}; +use uint::range; +use vec::{len, push}; fn get_base_type(inference_context: infer_ctxt, span: span, original_type: t) -> Option { diff --git a/src/rustc/middle/typeck/collect.rs b/src/rustc/middle/typeck/collect.rs index 72faac19aba..d3b407db13d 100644 --- a/src/rustc/middle/typeck/collect.rs +++ b/src/rustc/middle/typeck/collect.rs @@ -20,9 +20,9 @@ are represented as `ty_param()` instances. */ -import astconv::{ast_conv, ty_of_fn_decl, ty_of_arg, ast_ty_to_ty}; -import ast_util::trait_method_to_ty_method; -import rscope::*; +use astconv::{ast_conv, ty_of_fn_decl, ty_of_arg, ast_ty_to_ty}; +use ast_util::trait_method_to_ty_method; +use rscope::*; fn collect_item_types(ccx: @crate_ctxt, crate: @ast::crate) { diff --git a/src/rustc/middle/typeck/infer.rs b/src/rustc/middle/typeck/infer.rs index ac3b04284b3..c630ae432ad 100644 --- a/src/rustc/middle/typeck/infer.rs +++ b/src/rustc/middle/typeck/infer.rs @@ -246,39 +246,39 @@ section on "Type Combining" below for details. #[warn(deprecated_mode)]; #[warn(deprecated_pattern)]; -import std::smallintmap; -import std::smallintmap::smallintmap; -import std::map::hashmap; -import middle::ty; -import middle::ty::{tv_vid, tvi_vid, region_vid, vid, +use std::smallintmap; +use std::smallintmap::smallintmap; +use std::map::hashmap; +use middle::ty; +use middle::ty::{tv_vid, tvi_vid, region_vid, vid, ty_int, ty_uint, get, terr_fn}; -import syntax::{ast, ast_util}; -import syntax::ast::{ret_style, purity}; -import util::ppaux::{ty_to_str, mt_to_str}; -import result::{Result, Ok, Err, map_vec, map_vec2, iter_vec2}; -import ty::{mk_fn, type_is_bot}; -import check::regionmanip::{replace_bound_regions_in_fn_ty}; -import driver::session::session; -import util::common::{indent, indenter}; -import ast::{unsafe_fn, impure_fn, pure_fn, extern_fn}; -import ast::{m_const, m_imm, m_mutbl}; -import dvec::DVec; -import region_var_bindings::{RegionVarBindings}; -import ast_util::dummy_sp; -import cmp::Eq; +use syntax::{ast, ast_util}; +use syntax::ast::{ret_style, purity}; +use util::ppaux::{ty_to_str, mt_to_str}; +use result::{Result, Ok, Err, map_vec, map_vec2, iter_vec2}; +use ty::{mk_fn, type_is_bot}; +use check::regionmanip::{replace_bound_regions_in_fn_ty}; +use driver::session::session; +use util::common::{indent, indenter}; +use ast::{unsafe_fn, impure_fn, pure_fn, extern_fn}; +use ast::{m_const, m_imm, m_mutbl}; +use dvec::DVec; +use region_var_bindings::{RegionVarBindings}; +use ast_util::dummy_sp; +use cmp::Eq; // From submodules: -import resolve::{resolve_nested_tvar, resolve_rvar, resolve_ivar, resolve_all, +use resolve::{resolve_nested_tvar, resolve_rvar, resolve_ivar, resolve_all, force_tvar, force_rvar, force_ivar, force_all, not_regions, resolve_and_force_all_but_regions, resolver}; -import unify::{vals_and_bindings, root}; -import integral::{int_ty_set, int_ty_set_all}; -import combine::{combine_fields, eq_tys}; -import assignment::Assign; +use unify::{vals_and_bindings, root}; +use integral::{int_ty_set, int_ty_set_all}; +use combine::{combine_fields, eq_tys}; +use assignment::Assign; -import sub::Sub; -import lub::Lub; -import glb::Glb; +use sub::Sub; +use lub::Lub; +use glb::Glb; export infer_ctxt; export new_infer_ctxt; diff --git a/src/rustc/middle/typeck/infer/assignment.rs b/src/rustc/middle/typeck/infer/assignment.rs index 620929f4bd9..6faee7ad411 100644 --- a/src/rustc/middle/typeck/infer/assignment.rs +++ b/src/rustc/middle/typeck/infer/assignment.rs @@ -48,8 +48,8 @@ // A. But this upper-bound might be stricter than what is truly // needed. -import to_str::to_str; -import combine::combine_fields; +use to_str::to_str; +use combine::combine_fields; fn to_ares(+c: cres) -> ares { match c { diff --git a/src/rustc/middle/typeck/infer/combine.rs b/src/rustc/middle/typeck/infer/combine.rs index 21e95c21beb..4585be3e74a 100644 --- a/src/rustc/middle/typeck/infer/combine.rs +++ b/src/rustc/middle/typeck/infer/combine.rs @@ -44,7 +44,7 @@ // terms of error reporting, although we do not do that properly right // now. -import to_str::to_str; +use to_str::to_str; trait combine { fn infcx() -> infer_ctxt; diff --git a/src/rustc/middle/typeck/infer/glb.rs b/src/rustc/middle/typeck/infer/glb.rs index 26a9cd0ebd6..7ef0bf91943 100644 --- a/src/rustc/middle/typeck/infer/glb.rs +++ b/src/rustc/middle/typeck/infer/glb.rs @@ -1,6 +1,6 @@ -import combine::*; -import lattice::*; -import to_str::to_str; +use combine::*; +use lattice::*; +use to_str::to_str; enum Glb = combine_fields; // "greatest lower bound" (common subtype) diff --git a/src/rustc/middle/typeck/infer/integral.rs b/src/rustc/middle/typeck/infer/integral.rs index 96a4a8ab779..fdab9f6a169 100644 --- a/src/rustc/middle/typeck/infer/integral.rs +++ b/src/rustc/middle/typeck/infer/integral.rs @@ -4,7 +4,7 @@ Code related to integral type inference. */ -import to_str::to_str; +use to_str::to_str; // Bitvector to represent sets of integral types enum int_ty_set = uint; diff --git a/src/rustc/middle/typeck/infer/lattice.rs b/src/rustc/middle/typeck/infer/lattice.rs index 82f69df7fe6..482cd4d7703 100644 --- a/src/rustc/middle/typeck/infer/lattice.rs +++ b/src/rustc/middle/typeck/infer/lattice.rs @@ -1,6 +1,6 @@ -import combine::*; -import unify::*; -import to_str::to_str; +use combine::*; +use unify::*; +use to_str::to_str; // ______________________________________________________________________ // Lattice operations on variables diff --git a/src/rustc/middle/typeck/infer/lub.rs b/src/rustc/middle/typeck/infer/lub.rs index d33b127d4d5..21e2a9febec 100644 --- a/src/rustc/middle/typeck/infer/lub.rs +++ b/src/rustc/middle/typeck/infer/lub.rs @@ -1,6 +1,6 @@ -import combine::*; -import lattice::*; -import to_str::to_str; +use combine::*; +use lattice::*; +use to_str::to_str; enum Lub = combine_fields; // "subtype", "subregion" etc diff --git a/src/rustc/middle/typeck/infer/region_var_bindings.rs b/src/rustc/middle/typeck/infer/region_var_bindings.rs index cd4fde69ce9..c0714294491 100644 --- a/src/rustc/middle/typeck/infer/region_var_bindings.rs +++ b/src/rustc/middle/typeck/infer/region_var_bindings.rs @@ -305,18 +305,18 @@ because `&x` was created alone, but is relatable to `&A`. #[warn(deprecated_mode)]; #[warn(deprecated_pattern)]; -import dvec::DVec; -import result::Result; -import result::{Ok, Err}; -import std::map::{hashmap, uint_hash}; -import std::cell::{Cell, empty_cell}; -import std::list::{list, nil, cons}; +use dvec::DVec; +use result::Result; +use result::{Ok, Err}; +use std::map::{hashmap, uint_hash}; +use std::cell::{Cell, empty_cell}; +use std::list::{list, nil, cons}; -import ty::{region, region_vid, hash_region}; -import region::is_subregion_of; -import syntax::codemap; -import to_str::to_str; -import util::ppaux::note_and_explain_region; +use ty::{region, region_vid, hash_region}; +use region::is_subregion_of; +use syntax::codemap; +use to_str::to_str; +use util::ppaux::note_and_explain_region; export RegionVarBindings; export make_subregion; diff --git a/src/rustc/middle/typeck/infer/resolve.rs b/src/rustc/middle/typeck/infer/resolve.rs index a921ca7bddd..7364b744527 100644 --- a/src/rustc/middle/typeck/infer/resolve.rs +++ b/src/rustc/middle/typeck/infer/resolve.rs @@ -34,8 +34,8 @@ // future). If you want to resolve everything but one type, you are // probably better off writing `resolve_all - resolve_ivar`. -import integral::*; -import to_str::to_str; +use integral::*; +use to_str::to_str; const resolve_nested_tvar: uint = 0b00000001; const resolve_rvar: uint = 0b00000010; diff --git a/src/rustc/middle/typeck/infer/sub.rs b/src/rustc/middle/typeck/infer/sub.rs index 93d7d1a41ed..2363c2a8251 100644 --- a/src/rustc/middle/typeck/infer/sub.rs +++ b/src/rustc/middle/typeck/infer/sub.rs @@ -1,6 +1,6 @@ -import combine::*; -import unify::*; -import to_str::to_str; +use combine::*; +use unify::*; +use to_str::to_str; enum Sub = combine_fields; // "subtype", "subregion" etc diff --git a/src/rustc/middle/typeck/infer/to_str.rs b/src/rustc/middle/typeck/infer/to_str.rs index 80a2d631b9a..f66685d766b 100644 --- a/src/rustc/middle/typeck/infer/to_str.rs +++ b/src/rustc/middle/typeck/infer/to_str.rs @@ -1,5 +1,5 @@ -import integral::{int_ty_set}; -import unify::{var_value, redirect, root}; +use integral::{int_ty_set}; +use unify::{var_value, redirect, root}; trait to_str { fn to_str(cx: infer_ctxt) -> ~str; diff --git a/src/rustc/middle/typeck/infer/unify.rs b/src/rustc/middle/typeck/infer/unify.rs index ed9daafeba3..690c6d8d8d0 100644 --- a/src/rustc/middle/typeck/infer/unify.rs +++ b/src/rustc/middle/typeck/infer/unify.rs @@ -1,6 +1,6 @@ -import combine::combine; -import integral::*; -import to_str::to_str; +use combine::combine; +use integral::*; +use to_str::to_str; enum var_value { redirect(V), diff --git a/src/rustc/middle/typeck/rscope.rs b/src/rustc/middle/typeck/rscope.rs index 42a16ad5ab3..32864a2d51f 100644 --- a/src/rustc/middle/typeck/rscope.rs +++ b/src/rustc/middle/typeck/rscope.rs @@ -1,5 +1,5 @@ -import result::Result; -import syntax::parse::token::special_idents; +use result::Result; +use syntax::parse::token::special_idents; trait region_scope { fn anon_region(span: span) -> Result; diff --git a/src/rustc/util/common.rs b/src/rustc/util/common.rs index 7bac59f018e..7cef04c3e58 100644 --- a/src/rustc/util/common.rs +++ b/src/rustc/util/common.rs @@ -1,9 +1,9 @@ -import std::map::hashmap; -import syntax::ast; -import ast::{ty, pat}; -import syntax::codemap::{span}; -import syntax::visit; -import syntax::print; +use std::map::hashmap; +use syntax::ast; +use ast::{ty, pat}; +use syntax::codemap::{span}; +use syntax::visit; +use syntax::print; fn indent(op: fn() -> R) -> R { // Use in conjunction with the log post-processor like `src/etc/indenter` diff --git a/src/rustc/util/ppaux.rs b/src/rustc/util/ppaux.rs index 2d2cc7ee99a..2b452f1d8b1 100644 --- a/src/rustc/util/ppaux.rs +++ b/src/rustc/util/ppaux.rs @@ -1,25 +1,25 @@ -import std::map::hashmap; -import middle::ty; -import middle::ty::{arg, canon_mode}; -import middle::ty::{bound_region, br_anon, br_named, br_self, br_cap_avoid}; -import middle::ty::{ck_block, ck_box, ck_uniq, ctxt, field, method}; -import middle::ty::{mt, t}; -import middle::ty::{re_bound, re_free, re_scope, re_var, re_static, region}; -import middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_enum}; -import middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_trait, ty_int}; -import middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param}; -import middle::ty::{ty_ptr, ty_rec, ty_rptr, ty_self, ty_tup}; -import middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral}; -import middle::ty::{ty_unboxed_vec, vid}; -import metadata::encoder; -import syntax::codemap; -import syntax::codemap::span; -import syntax::print::pprust; -import syntax::print::pprust::{path_to_str, proto_to_str, +use std::map::hashmap; +use middle::ty; +use middle::ty::{arg, canon_mode}; +use middle::ty::{bound_region, br_anon, br_named, br_self, br_cap_avoid}; +use middle::ty::{ck_block, ck_box, ck_uniq, ctxt, field, method}; +use middle::ty::{mt, t}; +use middle::ty::{re_bound, re_free, re_scope, re_var, re_static, region}; +use middle::ty::{ty_bool, ty_bot, ty_box, ty_class, ty_enum}; +use middle::ty::{ty_estr, ty_evec, ty_float, ty_fn, ty_trait, ty_int}; +use middle::ty::{ty_nil, ty_opaque_box, ty_opaque_closure_ptr, ty_param}; +use middle::ty::{ty_ptr, ty_rec, ty_rptr, ty_self, ty_tup}; +use middle::ty::{ty_type, ty_uniq, ty_uint, ty_var, ty_var_integral}; +use middle::ty::{ty_unboxed_vec, vid}; +use metadata::encoder; +use syntax::codemap; +use syntax::codemap::span; +use syntax::print::pprust; +use syntax::print::pprust::{path_to_str, proto_to_str, mode_to_str, purity_to_str}; -import syntax::{ast, ast_util}; -import syntax::ast_map; -import driver::session::session; +use syntax::{ast, ast_util}; +use syntax::ast_map; +use driver::session::session; fn note_and_explain_region(cx: ctxt, prefix: ~str, region: ty::region) { match explain_region_and_span(cx, region) {