/// standard library and prelude.
pub fn phase_2_configure_and_expand(sess: Session,
loader: &mut CrateLoader,
- mut crate: ast::Crate)
+ mut krate: ast::Crate)
-> (ast::Crate, syntax::ast_map::Map) {
let time_passes = sess.time_passes();
- sess.building_library.set(session::building_library(sess.opts, &crate));
- sess.crate_types.set(session::collect_crate_types(&sess, crate.attrs));
+ sess.building_library.set(session::building_library(sess.opts, &krate));
+ sess.crate_types.set(session::collect_crate_types(&sess, krate.attrs));
time(time_passes, "gated feature checking", (), |_|
- front::feature_gate::check_crate(sess, &crate));
+ front::feature_gate::check_crate(sess, &krate));
- crate = time(time_passes, "crate injection", crate, |crate|
- front::std_inject::maybe_inject_crates_ref(sess, crate));
+ krate = time(time_passes, "crate injection", krate, |krate|
+ front::std_inject::maybe_inject_crates_ref(sess, krate));
// strip before expansion to allow macros to depend on
// configuration variables e.g/ in
//
// baz! should not use this definition unless foo is enabled.
- crate = time(time_passes, "configuration 1", crate, |crate|
- front::config::strip_unconfigured_items(crate));
+ krate = time(time_passes, "configuration 1", krate, |krate|
+ front::config::strip_unconfigured_items(krate));
- crate = time(time_passes, "expansion", crate, |crate| {
+ krate = time(time_passes, "expansion", krate, |krate| {
syntax::ext::expand::expand_crate(sess.parse_sess,
loader,
- crate)
+ krate)
});
// dump the syntax-time crates
sess.cstore.reset();
// strip again, in case expansion added anything with a #[cfg].
- crate = time(time_passes, "configuration 2", crate, |crate|
- front::config::strip_unconfigured_items(crate));
+ krate = time(time_passes, "configuration 2", krate, |krate|
+ front::config::strip_unconfigured_items(krate));
- crate = time(time_passes, "maybe building test harness", crate, |crate|
- front::test::modify_for_testing(sess, crate));
+ krate = time(time_passes, "maybe building test harness", krate, |krate|
+ front::test::modify_for_testing(sess, krate));
- crate = time(time_passes, "prelude injection", crate, |crate|
- front::std_inject::maybe_inject_prelude(sess, crate));
+ krate = time(time_passes, "prelude injection", krate, |krate|
+ front::std_inject::maybe_inject_prelude(sess, krate));
- time(time_passes, "assinging node ids and indexing ast", crate, |crate|
- front::assign_node_ids_and_map::assign_node_ids_and_map(sess, crate))
+ time(time_passes, "assinging node ids and indexing ast", krate, |krate|
+ front::assign_node_ids_and_map::assign_node_ids_and_map(sess, krate))
}
pub struct CrateAnalysis {
/// miscellaneous analysis passes on the crate. Return various
/// structures carrying the results of the analysis.
pub fn phase_3_run_analysis_passes(sess: Session,
- crate: &ast::Crate,
+ krate: &ast::Crate,
ast_map: syntax::ast_map::Map) -> CrateAnalysis {
let time_passes = sess.time_passes();
time(time_passes, "external crate/lib resolution", (), |_|
- creader::read_crates(sess, crate,
+ creader::read_crates(sess, krate,
session::sess_os_to_meta_os(sess.targ_cfg.os),
token::get_ident_interner()));
let lang_items = time(time_passes, "language item collection", (), |_|
- middle::lang_items::collect_language_items(crate, sess));
+ middle::lang_items::collect_language_items(krate, sess));
let middle::resolve::CrateMap {
def_map: def_map,
last_private_map: last_private_map
} =
time(time_passes, "resolution", (), |_|
- middle::resolve::resolve_crate(sess, lang_items, crate));
+ middle::resolve::resolve_crate(sess, lang_items, krate));
let named_region_map = time(time_passes, "lifetime resolution", (),
- |_| middle::resolve_lifetime::crate(sess, crate));
+ |_| middle::resolve_lifetime::krate(sess, krate));
time(time_passes, "looking for entry point", (),
- |_| middle::entry::find_entry_point(sess, crate, ast_map));
+ |_| middle::entry::find_entry_point(sess, krate, ast_map));
sess.macro_registrar_fn.with_mut(|r| *r =
time(time_passes, "looking for macro registrar", (), |_|
syntax::ext::registrar::find_macro_registrar(
- sess.span_diagnostic, crate)));
+ sess.span_diagnostic, krate)));
let freevars = time(time_passes, "freevar finding", (), |_|
- freevars::annotate_freevars(def_map, crate));
+ freevars::annotate_freevars(def_map, krate));
let region_map = time(time_passes, "region resolution", (), |_|
- middle::region::resolve_crate(sess, crate));
+ middle::region::resolve_crate(sess, krate));
let ty_cx = ty::mk_ctxt(sess, def_map, named_region_map, ast_map, freevars,
region_map, lang_items);
// passes are timed inside typeck
- let (method_map, vtable_map) = typeck::check_crate(ty_cx, trait_map, crate);
+ let (method_map, vtable_map) = typeck::check_crate(ty_cx, trait_map, krate);
// These next two const passes can probably be merged
time(time_passes, "const marking", (), |_|
- middle::const_eval::process_crate(crate, ty_cx));
+ middle::const_eval::process_crate(krate, ty_cx));
time(time_passes, "const checking", (), |_|
- middle::check_const::check_crate(sess, crate, ast_map, def_map,
+ middle::check_const::check_crate(sess, krate, ast_map, def_map,
method_map, ty_cx));
let maps = (external_exports, last_private_map);
let (exported_items, public_items) =
time(time_passes, "privacy checking", maps, |(a, b)|
middle::privacy::check_crate(ty_cx, &method_map, &exp_map2,
- a, b, crate));
+ a, b, krate));
time(time_passes, "effect checking", (), |_|
- middle::effect::check_crate(ty_cx, method_map, crate));
+ middle::effect::check_crate(ty_cx, method_map, krate));
time(time_passes, "loop checking", (), |_|
- middle::check_loop::check_crate(ty_cx, crate));
+ middle::check_loop::check_crate(ty_cx, krate));
let middle::moves::MoveMaps {moves_map, moved_variables_set,
capture_map} =
time(time_passes, "compute moves", (), |_|
- middle::moves::compute_moves(ty_cx, method_map, crate));
+ middle::moves::compute_moves(ty_cx, method_map, krate));
time(time_passes, "match checking", (), |_|
middle::check_match::check_crate(ty_cx, method_map,
- moves_map, crate));
+ moves_map, krate));
time(time_passes, "liveness checking", (), |_|
middle::liveness::check_crate(ty_cx, method_map,
- capture_map, crate));
+ capture_map, krate));
let root_map =
time(time_passes, "borrow checking", (), |_|
middle::borrowck::check_crate(ty_cx, method_map,
moves_map, moved_variables_set,
- capture_map, crate));
+ capture_map, krate));
time(time_passes, "kind checking", (), |_|
- kind::check_crate(ty_cx, method_map, crate));
+ kind::check_crate(ty_cx, method_map, krate));
let reachable_map =
time(time_passes, "reachability checking", (), |_|
method_map,
&exported_items,
reachable_map.get(),
- crate)
+ krate)
});
}
time(time_passes, "lint checking", (), |_|
- lint::check_crate(ty_cx, method_map, &exported_items, crate));
+ lint::check_crate(ty_cx, method_map, &exported_items, krate));
CrateAnalysis {
exp_map2: exp_map2,
/// Run the translation phase to LLVM, after which the AST and analysis can
/// be discarded.
pub fn phase_4_translate_to_llvm(sess: Session,
- crate: ast::Crate,
+ krate: ast::Crate,
analysis: &CrateAnalysis,
outputs: &OutputFilenames) -> CrateTranslation {
- time(sess.time_passes(), "translation", crate, |crate|
- trans::base::trans_crate(sess, crate, analysis, outputs))
+ time(sess.time_passes(), "translation", krate, |krate|
+ trans::base::trans_crate(sess, krate, analysis, outputs))
}
/// Run LLVM itself, producing a bitcode file, assembly file or object file
fn write_out_deps(sess: Session,
input: &Input,
outputs: &OutputFilenames,
- crate: &ast::Crate) -> io::IoResult<()> {
- let lm = link::build_link_meta(crate.attrs, outputs,
+ krate: &ast::Crate) -> io::IoResult<()> {
+ let lm = link::build_link_meta(krate.attrs, outputs,
&mut ::util::sha2::Sha256::new());
let mut out_filenames = ~[];
// possible to keep the peak memory usage low
let (outputs, trans) = {
let (expanded_crate, ast_map) = {
- let crate = phase_1_parse_input(sess, cfg, input);
+ let krate = phase_1_parse_input(sess, cfg, input);
if sess.show_span() {
- front::show_span::run(sess, &crate);
+ front::show_span::run(sess, &krate);
return;
}
if stop_after_phase_1(sess) { return; }
let loader = &mut Loader::new(sess);
- phase_2_configure_and_expand(sess, loader, crate)
+ phase_2_configure_and_expand(sess, loader, krate)
};
let outputs = build_output_filenames(input, outdir, output,
expanded_crate.attrs, sess);
cfg: ast::CrateConfig,
input: &Input,
ppm: PpMode) {
- let crate = phase_1_parse_input(sess, cfg, input);
+ let krate = phase_1_parse_input(sess, cfg, input);
- let (crate, ast_map, is_expanded) = match ppm {
+ let (krate, ast_map, is_expanded) = match ppm {
PpmExpanded | PpmExpandedIdentified | PpmTyped => {
let loader = &mut Loader::new(sess);
- let (crate, ast_map) = phase_2_configure_and_expand(sess, loader, crate);
- (crate, Some(ast_map), true)
+ let (krate, ast_map) = phase_2_configure_and_expand(sess, loader, krate);
+ (krate, Some(ast_map), true)
}
- _ => (crate, None, false)
+ _ => (krate, None, false)
};
let annotation = match ppm {
}
PpmTyped => {
let ast_map = ast_map.expect("--pretty=typed missing ast_map");
- let analysis = phase_3_run_analysis_passes(sess, &crate, ast_map);
+ let analysis = phase_3_run_analysis_passes(sess, &krate, ast_map);
~TypedAnnotation {
analysis: analysis
} as ~pprust::PpAnn:
pprust::print_crate(sess.codemap,
token::get_ident_interner(),
sess.span_diagnostic,
- &crate,
+ &krate,
source_name(input),
&mut rdr,
~stdout as ~io::Writer,
diagnostic::expect(sess.diagnostic(), opt, msg)
}
-pub fn building_library(options: &Options, crate: &ast::Crate) -> bool {
+pub fn building_library(options: &Options, krate: &ast::Crate) -> bool {
if options.test { return false }
for output in options.crate_types.iter() {
match *output {
CrateTypeStaticlib | CrateTypeDylib | CrateTypeRlib => return true
}
}
- match syntax::attr::first_attr_value_str_by_name(crate.attrs, "crate_type") {
+ match syntax::attr::first_attr_value_str_by_name(krate.attrs, "crate_type") {
Some(s) => {
s.equiv(&("lib")) ||
s.equiv(&("rlib")) ||
}
}
-pub fn assign_node_ids_and_map(sess: Session, crate: ast::Crate) -> (ast::Crate, ast_map::Map) {
- ast_map::map_crate(sess.diagnostic(), crate, NodeIdAssigner { sess: sess })
+pub fn assign_node_ids_and_map(sess: Session, krate: ast::Crate) -> (ast::Crate, ast_map::Map) {
+ ast_map::map_crate(sess.diagnostic(), krate, NodeIdAssigner { sess: sess })
}
// Support conditional compilation by transforming the AST, stripping out
// any items that do not belong in the current configuration
-pub fn strip_unconfigured_items(crate: ast::Crate) -> ast::Crate {
- let config = crate.config.clone();
- strip_items(crate, |attrs| in_cfg(config, attrs))
+pub fn strip_unconfigured_items(krate: ast::Crate) -> ast::Crate {
+ let config = krate.config.clone();
+ strip_items(krate, |attrs| in_cfg(config, attrs))
}
impl<'a> fold::Folder for Context<'a> {
}
}
-pub fn strip_items(crate: ast::Crate,
+pub fn strip_items(krate: ast::Crate,
in_cfg: |attrs: &[ast::Attribute]| -> bool)
-> ast::Crate {
let mut ctxt = Context {
in_cfg: in_cfg,
};
- ctxt.fold_crate(crate)
+ ctxt.fold_crate(krate)
}
fn filter_view_item<'r>(cx: &Context, view_item: &'r ast::ViewItem)
}
}
-pub fn check_crate(sess: Session, crate: &ast::Crate) {
+pub fn check_crate(sess: Session, krate: &ast::Crate) {
let mut cx = Context {
features: ~[],
sess: sess,
};
- for attr in crate.attrs.iter() {
+ for attr in krate.attrs.iter() {
if !attr.name().equiv(&("feature")) {
continue
}
}
}
- visit::walk_crate(&mut cx, crate, ());
+ visit::walk_crate(&mut cx, krate, ());
sess.abort_if_errors();
}
}
}
-pub fn run(sess: Session, crate: &ast::Crate) {
+pub fn run(sess: Session, krate: &ast::Crate) {
let mut v = ShowSpanVisitor { sess: sess };
- visit::walk_crate(&mut v, crate, ());
+ visit::walk_crate(&mut v, krate, ());
}
pub static VERSION: &'static str = "0.10-pre";
-pub fn maybe_inject_crates_ref(sess: Session, crate: ast::Crate)
+pub fn maybe_inject_crates_ref(sess: Session, krate: ast::Crate)
-> ast::Crate {
- if use_std(&crate) {
- inject_crates_ref(sess, crate)
+ if use_std(&krate) {
+ inject_crates_ref(sess, krate)
} else {
- crate
+ krate
}
}
-pub fn maybe_inject_prelude(sess: Session, crate: ast::Crate) -> ast::Crate {
- if use_std(&crate) {
- inject_prelude(sess, crate)
+pub fn maybe_inject_prelude(sess: Session, krate: ast::Crate) -> ast::Crate {
+ if use_std(&krate) {
+ inject_prelude(sess, krate)
} else {
- crate
+ krate
}
}
-fn use_std(crate: &ast::Crate) -> bool {
- !attr::contains_name(crate.attrs, "no_std")
+fn use_std(krate: &ast::Crate) -> bool {
+ !attr::contains_name(krate.attrs, "no_std")
}
-fn use_uv(crate: &ast::Crate) -> bool {
- !attr::contains_name(crate.attrs, "no_uv")
+fn use_uv(krate: &ast::Crate) -> bool {
+ !attr::contains_name(krate.attrs, "no_uv")
}
fn no_prelude(attrs: &[ast::Attribute]) -> bool {
sess: Session,
}
-pub fn with_version(crate: &str) -> Option<(InternedString, ast::StrStyle)> {
+pub fn with_version(krate: &str) -> Option<(InternedString, ast::StrStyle)> {
match option_env!("CFG_DISABLE_INJECT_STD_VERSION") {
Some("1") => None,
_ => {
Some((token::intern_and_get_ident(format!("{}\\#{}",
- crate,
+ krate,
VERSION)),
ast::CookedStr))
}
}
impl fold::Folder for StandardLibraryInjector {
- fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {
+ fn fold_crate(&mut self, krate: ast::Crate) -> ast::Crate {
let mut vis = ~[ast::ViewItem {
node: ast::ViewItemExternMod(self.sess.ident_of("std"),
with_version("std"),
span: DUMMY_SP
}];
- if use_uv(&crate) && !self.sess.building_library.get() {
+ if use_uv(&krate) && !self.sess.building_library.get() {
vis.push(ast::ViewItem {
node: ast::ViewItemExternMod(self.sess.ident_of("green"),
with_version("green"),
});
}
- vis.push_all(crate.module.view_items);
+ vis.push_all(krate.module.view_items);
let new_module = ast::Mod {
view_items: vis,
- ..crate.module.clone()
+ ..krate.module.clone()
};
ast::Crate {
module: new_module,
- ..crate
+ ..krate
}
}
}
-fn inject_crates_ref(sess: Session, crate: ast::Crate) -> ast::Crate {
+fn inject_crates_ref(sess: Session, krate: ast::Crate) -> ast::Crate {
let mut fold = StandardLibraryInjector {
sess: sess,
};
- fold.fold_crate(crate)
+ fold.fold_crate(krate)
}
struct PreludeInjector {
impl fold::Folder for PreludeInjector {
- fn fold_crate(&mut self, crate: ast::Crate) -> ast::Crate {
- if !no_prelude(crate.attrs) {
+ fn fold_crate(&mut self, krate: ast::Crate) -> ast::Crate {
+ if !no_prelude(krate.attrs) {
// only add `use std::prelude::*;` if there wasn't a
// `#[no_implicit_prelude];` at the crate level.
ast::Crate {
- module: self.fold_mod(&crate.module),
- ..crate
+ module: self.fold_mod(&krate.module),
+ ..krate
}
} else {
- crate
+ krate
}
}
}
}
-fn inject_prelude(sess: Session, crate: ast::Crate) -> ast::Crate {
+fn inject_prelude(sess: Session, krate: ast::Crate) -> ast::Crate {
let mut fold = PreludeInjector {
sess: sess,
};
- fold.fold_crate(crate)
+ fold.fold_crate(krate)
}
// Traverse the crate, collecting all the test functions, eliding any
// existing main functions, and synthesizing a main test harness
pub fn modify_for_testing(sess: session::Session,
- crate: ast::Crate) -> ast::Crate {
+ krate: ast::Crate) -> ast::Crate {
// We generate the test harness when building in the 'test'
// configuration, either with the '--test' or '--cfg test'
// command line options.
- let should_test = attr::contains_name(crate.config, "test");
+ let should_test = attr::contains_name(krate.config, "test");
if should_test {
- generate_test_harness(sess, crate)
+ generate_test_harness(sess, krate)
} else {
- strip_test_functions(crate)
+ strip_test_functions(krate)
}
}
}
}
-fn generate_test_harness(sess: session::Session, crate: ast::Crate)
+fn generate_test_harness(sess: session::Session, krate: ast::Crate)
-> ast::Crate {
let loader = &mut Loader::new(sess);
let mut cx: TestCtxt = TestCtxt {
ext_cx: ExtCtxt::new(sess.parse_sess, sess.opts.cfg.clone(), loader),
path: RefCell::new(~[]),
testfns: RefCell::new(~[]),
- is_extra: is_extra(&crate),
- config: crate.config.clone(),
+ is_extra: is_extra(&krate),
+ config: krate.config.clone(),
};
cx.ext_cx.bt_push(ExpnInfo {
let mut fold = TestHarnessGenerator {
cx: cx
};
- let res = fold.fold_crate(crate);
+ let res = fold.fold_crate(krate);
fold.cx.ext_cx.bt_pop();
return res;
}
-fn strip_test_functions(crate: ast::Crate) -> ast::Crate {
+fn strip_test_functions(krate: ast::Crate) -> ast::Crate {
// When not compiling with --test we should not compile the
// #[test] functions
- config::strip_items(crate, |attrs| {
+ config::strip_items(krate, |attrs| {
!attr::contains_name(attrs, "test") &&
!attr::contains_name(attrs, "bench")
})
)).unwrap()
}
-fn is_extra(crate: &ast::Crate) -> bool {
- match attr::find_crateid(crate.attrs) {
+fn is_extra(krate: &ast::Crate) -> bool {
+ match attr::find_crateid(krate.attrs) {
Some(ref s) if "extra" == s.name => true,
_ => false
}
// Traverses an AST, reading all the information about use'd crates and extern
// libraries necessary for later resolving, typechecking, linking, etc.
pub fn read_crates(sess: Session,
- crate: &ast::Crate,
+ krate: &ast::Crate,
os: loader::Os,
intr: @IdentInterner) {
let mut e = Env {
next_crate_num: 1,
intr: intr
};
- visit_crate(&e, crate);
+ visit_crate(&e, krate);
{
let mut v = ReadCrateVisitor {
e: &mut e
};
- visit::walk_crate(&mut v, crate, ());
+ visit::walk_crate(&mut v, krate, ());
}
let crate_cache = e.crate_cache.borrow();
dump_crates(*crate_cache.get());
}
impl CrateLoader for Loader {
- fn load_crate(&mut self, crate: &ast::ViewItem) -> MacroCrate {
- let info = extract_crate_info(crate).unwrap();
+ fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate {
+ let info = extract_crate_info(krate).unwrap();
let cnum = resolve_crate(&mut self.env,
info.ident.clone(),
info.name.clone(),
info.version.clone(),
~"",
- crate.span);
+ krate.span);
let library = self.env.sess.cstore.get_used_crate_source(cnum).unwrap();
MacroCrate {
lib: library.dylib,
}
pub fn get_symbol(cstore: @cstore::CStore, def: ast::DefId) -> ~str {
- let cdata = cstore.get_crate_data(def.crate).data();
+ let cdata = cstore.get_crate_data(def.krate).data();
return decoder::get_symbol(cdata, def.node);
}
pub fn get_type_param_count(cstore: @cstore::CStore, def: ast::DefId)
-> uint {
- let cdata = cstore.get_crate_data(def.crate).data();
+ let cdata = cstore.get_crate_data(def.krate).data();
return decoder::get_type_param_count(cdata, def.node);
}
callback: |decoder::DefLike,
ast::Ident,
ast::Visibility|) {
- let crate_data = cstore.get_crate_data(def_id.crate);
+ let crate_data = cstore.get_crate_data(def_id.krate);
let get_crate_data: decoder::GetCrateDataCb = |cnum| {
cstore.get_crate_data(cnum)
};
pub fn get_item_path(tcx: ty::ctxt, def: ast::DefId) -> ast_map::Path {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
let path = decoder::get_item_path(cdata, def.node);
// FIXME #1920: This path is not always correct if the crate is not linked
decode_inlined_item: decoder::decode_inlined_item)
-> found_ast {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::maybe_get_item_ast(cdata, tcx, def.node,
decode_inlined_item)
}
pub fn get_enum_variants(tcx: ty::ctxt, def: ast::DefId)
-> ~[@ty::VariantInfo] {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
return decoder::get_enum_variants(cstore.intr, cdata, def.node, tcx)
}
/// Returns information about the given implementation.
pub fn get_impl(tcx: ty::ctxt, impl_def_id: ast::DefId)
-> ty::Impl {
- let cdata = tcx.cstore.get_crate_data(impl_def_id.crate);
+ let cdata = tcx.cstore.get_crate_data(impl_def_id.krate);
decoder::get_impl(tcx.cstore.intr, cdata, impl_def_id.node, tcx)
}
pub fn get_method(tcx: ty::ctxt, def: ast::DefId) -> ty::Method {
- let cdata = tcx.cstore.get_crate_data(def.crate);
+ let cdata = tcx.cstore.get_crate_data(def.krate);
decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
}
def: ast::DefId)
-> (ast::Ident, ast::ExplicitSelf_)
{
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node)
}
pub fn get_trait_method_def_ids(cstore: @cstore::CStore,
def: ast::DefId) -> ~[ast::DefId] {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_trait_method_def_ids(cdata, def.node)
}
pub fn get_item_variances(cstore: @cstore::CStore,
def: ast::DefId) -> ty::ItemVariances {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_item_variances(cdata, def.node)
}
def: ast::DefId)
-> ~[@ty::Method] {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_provided_trait_methods(cstore.intr, cdata, def.node, tcx)
}
pub fn get_supertraits(tcx: ty::ctxt, def: ast::DefId) -> ~[@ty::TraitRef] {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_supertraits(cdata, def.node, tcx)
}
pub fn get_type_name_if_impl(cstore: @cstore::CStore, def: ast::DefId)
-> Option<ast::Ident> {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_type_name_if_impl(cdata, def.node)
}
pub fn get_static_methods_if_impl(cstore: @cstore::CStore,
def: ast::DefId)
-> Option<~[StaticMethodInfo]> {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_static_methods_if_impl(cstore.intr, cdata, def.node)
}
pub fn get_item_attrs(cstore: @cstore::CStore,
def_id: ast::DefId,
f: |~[@ast::MetaItem]|) {
- let cdata = cstore.get_crate_data(def_id.crate);
+ let cdata = cstore.get_crate_data(def_id.krate);
decoder::get_item_attrs(cdata, def_id.node, f)
}
pub fn get_struct_fields(cstore: @cstore::CStore,
def: ast::DefId)
-> ~[ty::field_ty] {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_struct_fields(cstore.intr, cdata, def.node)
}
def: ast::DefId)
-> ty::ty_param_bounds_and_ty {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_type(cdata, def.node, tcx)
}
pub fn get_trait_def(tcx: ty::ctxt, def: ast::DefId) -> ty::TraitDef {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_trait_def(cdata, def.node, tcx)
}
pub fn get_field_type(tcx: ty::ctxt, class_id: ast::DefId,
def: ast::DefId) -> ty::ty_param_bounds_and_ty {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(class_id.crate);
+ let cdata = cstore.get_crate_data(class_id.krate);
let all_items = reader::get_doc(reader::Doc(cdata.data()), tag_items);
let class_doc = expect(tcx.diag,
decoder::maybe_find_item(class_id.node, all_items),
pub fn get_impl_trait(tcx: ty::ctxt,
def: ast::DefId) -> Option<@ty::TraitRef> {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_trait(cdata, def.node, tcx)
}
pub fn get_impl_vtables(tcx: ty::ctxt,
def: ast::DefId) -> typeck::impl_res {
let cstore = tcx.cstore;
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_vtables(cdata, def.node, tcx)
}
def: ast::DefId,
mname: ast::Ident)
-> Option<ast::DefId> {
- let cdata = cstore.get_crate_data(def.crate);
+ let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
}
pub fn get_item_visibility(cstore: @cstore::CStore,
def_id: ast::DefId)
-> ast::Visibility {
- let cdata = cstore.get_crate_data(def_id.crate);
+ let cdata = cstore.get_crate_data(def_id.krate);
decoder::get_item_visibility(cdata, def_id.node)
}
pub fn each_implementation_for_type(cstore: @cstore::CStore,
def_id: ast::DefId,
callback: |ast::DefId|) {
- let cdata = cstore.get_crate_data(def_id.crate);
+ let cdata = cstore.get_crate_data(def_id.krate);
decoder::each_implementation_for_type(cdata, def_id.node, callback)
}
pub fn each_implementation_for_trait(cstore: @cstore::CStore,
def_id: ast::DefId,
callback: |ast::DefId|) {
- let cdata = cstore.get_crate_data(def_id.crate);
+ let cdata = cstore.get_crate_data(def_id.krate);
decoder::each_implementation_for_trait(cdata, def_id.node, callback)
}
def_id: ast::DefId,
tcx: ty::ctxt)
-> Option<ast::DefId> {
- let cdata = cstore.get_crate_data(def_id.crate);
+ let cdata = cstore.get_crate_data(def_id.krate);
decoder::get_trait_of_method(cdata, def_id.node, tcx)
}
fn item_reqd_and_translated_parent_item(cnum: ast::CrateNum,
d: ebml::Doc) -> ast::DefId {
let trait_did = item_parent_item(d).expect("item without parent");
- ast::DefId { crate: cnum, node: trait_did.node }
+ ast::DefId { krate: cnum, node: trait_did.node }
}
fn item_def_id(d: ebml::Doc, cdata: Cmd) -> ast::DefId {
let v = tag_items_data_item_variant;
reader::tagged_docs(item, v, |p| {
let ext = reader::with_doc_data(p, parse_def_id);
- ids.push(ast::DefId { crate: cdata.cnum, node: ext.node });
+ ids.push(ast::DefId { krate: cdata.cnum, node: ext.node });
true
});
return ids;
pub fn lookup_def(cnum: ast::CrateNum, data: &[u8], did_: ast::DefId) ->
ast::Def {
let item = lookup_item(did_.node, data);
- let did = ast::DefId { crate: cnum, node: did_.node };
+ let did = ast::DefId { krate: cnum, node: did_.node };
// We treat references to enums as references to types.
return def_like_to_def(item_to_def_like(item, did, cnum));
}
let item = lookup_item(id, cdata.data());
- let t = item_type(ast::DefId { crate: cdata.cnum, node: id }, item, tcx,
+ let t = item_type(ast::DefId { krate: cdata.cnum, node: id }, item, tcx,
cdata);
let tp_defs = item_ty_param_defs(item, tcx, cdata, tag_items_data_item_ty_param_bounds);
// This item may be in yet another crate if it was the child of a
// reexport.
- let other_crates_items = if child_def_id.crate == cdata.cnum {
+ let other_crates_items = if child_def_id.krate == cdata.cnum {
reader::get_doc(reader::Doc(cdata.data()), tag_items)
} else {
- let crate_data = get_crate_data(child_def_id.crate);
+ let crate_data = get_crate_data(child_def_id.krate);
reader::get_doc(reader::Doc(crate_data.data()), tag_items)
};
let name = name_doc.as_str_slice();
// This reexport may be in yet another crate.
- let other_crates_items = if child_def_id.crate == cdata.cnum {
+ let other_crates_items = if child_def_id.krate == cdata.cnum {
reader::get_doc(reader::Doc(cdata.data()), tag_items)
} else {
- let crate_data = get_crate_data(child_def_id.crate);
+ let crate_data = get_crate_data(child_def_id.krate);
reader::get_doc(reader::Doc(crate_data.data()), tag_items)
};
let mut disr_val = 0;
for did in variant_ids.iter() {
let item = find_item(did.node, items);
- let ctor_ty = item_type(ast::DefId { crate: cdata.cnum, node: id},
+ let ctor_ty = item_type(ast::DefId { krate: cdata.cnum, node: id},
item, tcx, cdata);
let name = item_name(intr, item);
let arg_tys = match ty::get(ctor_ty).sty {
let impl_item = lookup_item(impl_id, data);
ty::Impl {
did: ast::DefId {
- crate: cdata.cnum,
+ krate: cdata.cnum,
node: impl_id,
},
ident: item_name(intr, impl_item),
// then we must translate the crate number from that encoded in the external
// crate to the correct local crate number.
pub fn translate_def_id(cdata: Cmd, did: ast::DefId) -> ast::DefId {
- if did.crate == ast::LOCAL_CRATE {
- return ast::DefId { crate: cdata.cnum, node: did.node };
+ if did.krate == ast::LOCAL_CRATE {
+ return ast::DefId { krate: cdata.cnum, node: did.node };
}
let cnum_map = cdata.cnum_map.borrow();
- match cnum_map.get().find(&did.crate) {
+ match cnum_map.get().find(&did.krate) {
Some(&n) => {
ast::DefId {
- crate: n,
+ krate: n,
node: did.node,
}
}
}
pub fn def_to_str(did: DefId) -> ~str {
- format!("{}:{}", did.crate, did.node)
+ format!("{}:{}", did.krate, did.node)
}
fn encode_ty_type_param_defs(ebml_w: &mut writer::Encoder,
let mut disr_val = 0;
let mut i = 0;
let vi = ty::enum_variants(ecx.tcx,
- ast::DefId { crate: LOCAL_CRATE, node: id });
+ ast::DefId { krate: LOCAL_CRATE, node: id });
for variant in variants.iter() {
let def_id = local_def(variant.node.id);
{
debug!("(encoding info for module) reexport '{}' ({}/{}) for \
{}",
exp.name,
- exp.def_id.crate,
+ exp.def_id.krate,
exp.def_id.node,
id);
ebml_w.start_tag(tag_items_data_item_reexport);
// Now output the method info for each method.
let r = ty::trait_method_def_ids(tcx, def_id);
for (i, &method_def_id) in r.iter().enumerate() {
- assert_eq!(method_def_id.crate, ast::LOCAL_CRATE);
+ assert_eq!(method_def_id.krate, ast::LOCAL_CRATE);
let method_ty = ty::method(tcx, method_def_id);
fn encode_info_for_items(ecx: &EncodeContext,
ebml_w: &mut writer::Encoder,
- crate: &Crate)
+ krate: &Crate)
-> ~[entry<i64>] {
let index = @RefCell::new(~[]);
ebml_w.start_tag(tag_items_data);
}
encode_info_for_mod(ecx,
ebml_w,
- &crate.module,
+ &krate.module,
CRATE_NODE_ID,
[],
syntax::parse::token::special_idents::invalid,
ebml_w_for_visit_item: &mut *ebml_w,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
ebml_w.end_tag();
// metadata that Rust cares about for linking crates. If the user didn't
// provide it we will throw it in anyway with a default value.
fn synthesize_crate_attrs(ecx: &EncodeContext,
- crate: &Crate) -> ~[Attribute] {
+ krate: &Crate) -> ~[Attribute] {
fn synthesize_crateid_attr(ecx: &EncodeContext) -> Attribute {
assert!(!ecx.link_meta.crateid.name.is_empty());
}
let mut attrs = ~[];
- for attr in crate.attrs.iter() {
+ for attr in krate.attrs.iter() {
if !attr.name().equiv(&("crate_id")) {
attrs.push(*attr);
}
for (i, def_id) in ecx.tcx.lang_items.items() {
for id in def_id.iter() {
- if id.crate == LOCAL_CRATE {
+ if id.krate == LOCAL_CRATE {
ebml_w.start_tag(tag_lang_items_item);
ebml_w.start_tag(tag_lang_items_item_id);
}
fn encode_macro_defs(ecx: &EncodeContext,
- crate: &Crate,
+ krate: &Crate,
ebml_w: &mut writer::Encoder) {
ebml_w.start_tag(tag_exported_macros);
{
ecx: ecx,
ebml_w: ebml_w,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
ebml_w.end_tag();
}
// Load eagerly if this is an implementation of the Drop trait
// or if the trait is not defined in this crate.
if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() ||
- def_id.crate != LOCAL_CRATE {
+ def_id.krate != LOCAL_CRATE {
self.ebml_w.start_tag(tag_impls_impl);
encode_def_id(self.ebml_w, local_def(item.id));
self.ebml_w.end_tag();
///
/// * Implementations of traits not defined in this crate.
fn encode_impls(ecx: &EncodeContext,
- crate: &Crate,
+ krate: &Crate,
ebml_w: &mut writer::Encoder) {
ebml_w.start_tag(tag_impls);
ecx: ecx,
ebml_w: ebml_w,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
ebml_w.end_tag();
}
fn encode_misc_info(ecx: &EncodeContext,
- crate: &Crate,
+ krate: &Crate,
ebml_w: &mut writer::Encoder) {
ebml_w.start_tag(tag_misc_info);
ebml_w.start_tag(tag_misc_info_crate_items);
- for &item in crate.module.items.iter() {
+ for &item in krate.module.items.iter() {
ebml_w.start_tag(tag_mod_child);
ebml_w.wr_str(def_to_str(local_def(item.id)));
ebml_w.end_tag();
0x74, //'t' as u8,
0, 0, 0, 1 ];
-pub fn encode_metadata(parms: EncodeParams, crate: &Crate) -> ~[u8] {
+pub fn encode_metadata(parms: EncodeParams, krate: &Crate) -> ~[u8] {
let mut wr = MemWriter::new();
- encode_metadata_inner(&mut wr, parms, crate);
+ encode_metadata_inner(&mut wr, parms, krate);
wr.unwrap()
}
-fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, crate: &Crate) {
+fn encode_metadata_inner(wr: &mut MemWriter, parms: EncodeParams, krate: &Crate) {
let stats = Stats {
inline_bytes: Cell::new(0),
attr_bytes: Cell::new(0),
encode_hash(&mut ebml_w, ecx.link_meta.crate_hash);
let mut i = ebml_w.writer.tell().unwrap();
- let crate_attrs = synthesize_crate_attrs(&ecx, crate);
+ let crate_attrs = synthesize_crate_attrs(&ecx, krate);
encode_attributes(&mut ebml_w, crate_attrs);
ecx.stats.attr_bytes.set(ebml_w.writer.tell().unwrap() - i);
// Encode macro definitions
i = ebml_w.writer.tell().unwrap();
- encode_macro_defs(&ecx, crate, &mut ebml_w);
+ encode_macro_defs(&ecx, krate, &mut ebml_w);
ecx.stats.macro_defs_bytes.set(ebml_w.writer.tell().unwrap() - i);
// Encode the def IDs of impls, for coherence checking.
i = ebml_w.writer.tell().unwrap();
- encode_impls(&ecx, crate, &mut ebml_w);
+ encode_impls(&ecx, krate, &mut ebml_w);
ecx.stats.impl_bytes.set(ebml_w.writer.tell().unwrap() - i);
// Encode miscellaneous info.
i = ebml_w.writer.tell().unwrap();
- encode_misc_info(&ecx, crate, &mut ebml_w);
+ encode_misc_info(&ecx, krate, &mut ebml_w);
ecx.stats.misc_bytes.set(ebml_w.writer.tell().unwrap() - i);
// Encode and index the items.
ebml_w.start_tag(tag_items);
i = ebml_w.writer.tell().unwrap();
- let items_index = encode_info_for_items(&ecx, &mut ebml_w, crate);
+ let items_index = encode_info_for_items(&ecx, &mut ebml_w, krate);
ecx.stats.item_bytes.set(ebml_w.writer.tell().unwrap() - i);
i = ebml_w.writer.tell().unwrap();
pub struct PState<'a> {
data: &'a [u8],
- crate: ast::CrateNum,
+ krate: ast::CrateNum,
pos: uint,
tcx: ty::ctxt
}
pos: uint, tcx: ty::ctxt) -> PState<'a> {
PState {
data: data,
- crate: crate_num,
+ krate: crate_num,
pos: pos,
tcx: tcx
}
assert_eq!(next(st), ':');
let len = parse_hex(st);
assert_eq!(next(st), '#');
- let key = ty::creader_cache_key {cnum: st.crate,
+ let key = ty::creader_cache_key {cnum: st.krate,
pos: pos,
len: len };
None => fail!("internal error: parse_def_id: id expected, but found {:?}",
def_part)
};
- ast::DefId { crate: crate_num, node: def_num }
+ ast::DefId { krate: crate_num, node: def_num }
}
pub fn parse_type_param_def_data(data: &[u8], start: uint,
* refer to the current crate and to the new, inlined node-id.
*/
- assert_eq!(did.crate, ast::LOCAL_CRATE);
- ast::DefId { crate: ast::LOCAL_CRATE, node: self.tr_id(did.node) }
+ assert_eq!(did.krate, ast::LOCAL_CRATE);
+ ast::DefId { krate: ast::LOCAL_CRATE, node: self.tr_id(did.node) }
}
pub fn tr_span(&self, _span: Span) -> Span {
codemap::DUMMY_SP // FIXME (#1972): handle span properly
}
}
- let lid = ast::DefId { crate: ast::LOCAL_CRATE, node: id };
+ let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id };
{
let tcache = tcx.tcache.borrow();
let r = tcache.get().find(&lid);
}
c::tag_table_tcache => {
let tpbt = val_dsr.read_ty_param_bounds_and_ty(xcx);
- let lid = ast::DefId { crate: ast::LOCAL_CRATE, node: id };
+ let lid = ast::DefId { krate: ast::LOCAL_CRATE, node: id };
let mut tcache = dcx.tcx.tcache.borrow_mut();
tcache.get().insert(lid, tpbt);
}
moves_map: moves::MovesMap,
moved_variables_set: moves::MovedVariablesSet,
capture_map: moves::CaptureMap,
- crate: &ast::Crate)
+ krate: &ast::Crate)
-> root_map {
let mut bccx = BorrowckCtxt {
tcx: tcx,
};
let bccx = &mut bccx;
- visit::walk_crate(bccx, crate, ());
+ visit::walk_crate(bccx, krate, ());
if tcx.sess.borrowck_stats() {
println!("--- borrowck stats ---");
}
pub fn check_crate(sess: Session,
- crate: &Crate,
+ krate: &Crate,
ast_map: ast_map::Map,
def_map: resolve::DefMap,
method_map: typeck::method_map,
method_map: method_map,
tcx: tcx,
};
- visit::walk_crate(&mut v, crate, false);
+ visit::walk_crate(&mut v, krate, false);
sess.abort_if_errors();
}
tcx: ty::ctxt,
}
-pub fn check_crate(tcx: ty::ctxt, crate: &ast::Crate) {
- visit::walk_crate(&mut CheckLoopVisitor { tcx: tcx }, crate, Normal)
+pub fn check_crate(tcx: ty::ctxt, krate: &ast::Crate) {
+ visit::walk_crate(&mut CheckLoopVisitor { tcx: tcx }, krate, Normal)
}
impl Visitor<Context> for CheckLoopVisitor {
pub fn check_crate(tcx: ty::ctxt,
method_map: method_map,
moves_map: moves::MovesMap,
- crate: &Crate) {
+ krate: &Crate) {
let cx = @MatchCheckCtxt {tcx: tcx,
method_map: method_map,
moves_map: moves_map};
let mut v = CheckMatchVisitor { cx: cx };
- visit::walk_crate(&mut v, crate, ());
+ visit::walk_crate(&mut v, krate, ());
tcx.sess.abort_if_errors();
}
}
}
-pub fn process_crate(crate: &ast::Crate,
+pub fn process_crate(krate: &ast::Crate,
tcx: ty::ctxt) {
let mut v = ConstEvalVisitor {
tcx: tcx,
ccache: HashMap::new(),
};
- visit::walk_crate(&mut v, crate, ());
+ visit::walk_crate(&mut v, krate, ());
tcx.sess.abort_if_errors();
}
fn create_and_seed_worklist(tcx: ty::ctxt,
exported_items: &privacy::ExportedItems,
reachable_symbols: &HashSet<ast::NodeId>,
- crate: &ast::Crate) -> ~[ast::NodeId] {
+ krate: &ast::Crate) -> ~[ast::NodeId] {
let mut worklist = ~[];
// Preferably, we would only need to seed the worklist with reachable
let mut life_seeder = LifeSeeder {
worklist: worklist
};
- visit::walk_crate(&mut life_seeder, crate, ());
+ visit::walk_crate(&mut life_seeder, krate, ());
return life_seeder.worklist;
}
method_map: typeck::method_map,
exported_items: &privacy::ExportedItems,
reachable_symbols: &HashSet<ast::NodeId>,
- crate: &ast::Crate)
+ krate: &ast::Crate)
-> ~HashSet<ast::NodeId> {
let worklist = create_and_seed_worklist(tcx, exported_items,
- reachable_symbols, crate);
+ reachable_symbols, krate);
let mut symbol_visitor = MarkSymbolVisitor::new(tcx, method_map, worklist);
symbol_visitor.mark_live_symbols();
symbol_visitor.live_symbols
method_map: typeck::method_map,
exported_items: &privacy::ExportedItems,
reachable_symbols: &HashSet<ast::NodeId>,
- crate: &ast::Crate) {
+ krate: &ast::Crate) {
let live_symbols = find_live(tcx, method_map, exported_items,
- reachable_symbols, crate);
+ reachable_symbols, krate);
let mut visitor = DeadVisitor { tcx: tcx, live_symbols: live_symbols };
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
pub fn check_crate(tcx: ty::ctxt,
method_map: method_map,
- crate: &ast::Crate) {
+ krate: &ast::Crate) {
let mut visitor = EffectCheckVisitor {
tcx: tcx,
method_map: method_map,
unsafe_context: SafeContext,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
}
}
-pub fn find_entry_point(session: Session, crate: &Crate, ast_map: ast_map::Map) {
+pub fn find_entry_point(session: Session, krate: &Crate, ast_map: ast_map::Map) {
if session.building_library.get() {
// No need to find a main function
return;
}
// If the user wants no main function at all, then stop here.
- if attr::contains_name(crate.attrs, "no_main") {
+ if attr::contains_name(krate.attrs, "no_main") {
session.entry_type.set(Some(session::EntryNone));
return
}
non_main_fns: ~[],
};
- visit::walk_crate(&mut ctxt, crate, ());
+ visit::walk_crate(&mut ctxt, krate, ());
configure_main(&mut ctxt);
}
// efficient as it fully recomputes the free variables at every
// node of interest rather than building up the free variables in
// one pass. This could be improved upon if it turns out to matter.
-pub fn annotate_freevars(def_map: resolve::DefMap, crate: &ast::Crate) ->
+pub fn annotate_freevars(def_map: resolve::DefMap, krate: &ast::Crate) ->
freevar_map {
let mut visitor = AnnotateFreevarsVisitor {
def_map: def_map,
freevars: HashMap::new(),
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
let AnnotateFreevarsVisitor {
freevars,
pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map,
- crate: &Crate) {
+ krate: &Crate) {
let mut ctx = Context {
tcx: tcx,
method_map: method_map,
};
- visit::walk_crate(&mut ctx, crate, ());
+ visit::walk_crate(&mut ctx, krate, ());
tcx.sess.abort_if_errors();
}
self.items.items[item_index] = Some(item_def_id);
}
- pub fn collect_local_language_items(&mut self, crate: &ast::Crate) {
+ pub fn collect_local_language_items(&mut self, krate: &ast::Crate) {
let mut v = LanguageItemVisitor { this: self };
- visit::walk_crate(&mut v, crate, ());
+ visit::walk_crate(&mut v, krate, ());
}
pub fn collect_external_language_items(&mut self) {
let crate_store = self.session.cstore;
crate_store.iter_crate_data(|crate_number, _crate_metadata| {
each_lang_item(crate_store, crate_number, |node_id, item_index| {
- let def_id = ast::DefId { crate: crate_number, node: node_id };
+ let def_id = ast::DefId { krate: crate_number, node: node_id };
self.collect_item(item_index, def_id);
true
});
})
}
- pub fn collect(&mut self, crate: &ast::Crate) {
- self.collect_local_language_items(crate);
+ pub fn collect(&mut self, krate: &ast::Crate) {
+ self.collect_local_language_items(krate);
self.collect_external_language_items();
}
}
return None;
}
-pub fn collect_language_items(crate: &ast::Crate,
+pub fn collect_language_items(krate: &ast::Crate,
session: Session) -> @LanguageItems {
let mut collector = LanguageItemCollector::new(session);
- collector.collect(crate);
+ collector.collect(krate);
let LanguageItemCollector { items, .. } = collector;
session.abort_if_errors();
@items
fn check_missing_doc_method(cx: &Context, m: &ast::Method) {
let did = ast::DefId {
- crate: ast::LOCAL_CRATE,
+ krate: ast::LOCAL_CRATE,
node: m.id
};
pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map,
exported_items: &privacy::ExportedItems,
- crate: &ast::Crate) {
+ krate: &ast::Crate) {
let mut cx = Context {
dict: @get_lint_dict(),
cur: SmallIntMap::new(),
for &(lint, level) in tcx.sess.opts.lint_opts.iter() {
cx.set_level(lint, level, CommandLine);
}
- cx.with_lint_attrs(crate.attrs, |cx| {
+ cx.with_lint_attrs(krate.attrs, |cx| {
cx.visit_id(ast::CRATE_NODE_ID);
cx.visit_ids(|v| {
v.visited_outermost = true;
- visit::walk_crate(v, crate, ());
+ visit::walk_crate(v, krate, ());
});
- check_crate_attrs_usage(cx, crate.attrs);
+ check_crate_attrs_usage(cx, krate.attrs);
// since the root module isn't visited as an item (because it isn't an item), warn for it
// here.
- check_missing_doc_attrs(cx, None, crate.attrs, crate.span, "crate");
+ check_missing_doc_attrs(cx, None, krate.attrs, krate.span, "crate");
- visit::walk_crate(cx, crate, ());
+ visit::walk_crate(cx, krate, ());
});
// If we missed any lints added to the session, then there's a bug somewhere
pub fn check_crate(tcx: ty::ctxt,
method_map: typeck::method_map,
capture_map: moves::CaptureMap,
- crate: &Crate) {
+ krate: &Crate) {
let mut visitor = LivenessVisitor;
let initial_maps = @IrMaps(tcx, method_map, capture_map);
- visit::walk_crate(&mut visitor, crate, initial_maps);
+ visit::walk_crate(&mut visitor, krate, initial_maps);
tcx.sess.abort_if_errors();
}
pub fn compute_moves(tcx: ty::ctxt,
method_map: method_map,
- crate: &Crate) -> MoveMaps
+ krate: &Crate) -> MoveMaps
{
let mut visit_cx = VisitContext {
tcx: tcx,
}
};
let visit_cx = &mut visit_cx;
- visit::walk_crate(visit_cx, crate, ());
+ visit::walk_crate(visit_cx, krate, ());
return visit_cx.move_maps;
}
exp_map2: &resolve::ExportMap2,
external_exports: resolve::ExternalExports,
last_private_map: resolve::LastPrivateMap,
- crate: &ast::Crate) -> (ExportedItems, PublicItems) {
+ krate: &ast::Crate) -> (ExportedItems, PublicItems) {
// Figure out who everyone's parent is
let mut visitor = ParentVisitor {
parents: HashMap::new(),
curparent: ast::DUMMY_NODE_ID,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
// Use the parent map to check the privacy of everything
let mut visitor = PrivacyVisitor {
external_exports: external_exports,
last_private_map: last_private_map,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
// Sanity check to make sure that all privacy usage and controls are
// reasonable.
in_fn: false,
tcx: tcx,
};
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
tcx.sess.abort_if_errors();
};
loop {
let before = visitor.exported_items.len();
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
if before == visitor.exported_items.len() {
break
}
// eligible for inlining and false otherwise.
fn def_id_represents_local_inlined_item(tcx: ty::ctxt, def_id: ast::DefId)
-> bool {
- if def_id.crate != ast::LOCAL_CRATE {
+ if def_id.krate != ast::LOCAL_CRATE {
return false
}
} else {
// Check the impl. If the generics on the self type of the
// impl require inlining, this method does too.
- assert!(impl_did.crate == ast::LOCAL_CRATE);
+ assert!(impl_did.krate == ast::LOCAL_CRATE);
match tcx.items.find(impl_did.node) {
Some(ast_map::NodeItem(item, _)) => {
match item.node {
fn mark_destructors_reachable(&self) {
let destructor_for_type = self.tcx.destructor_for_type.borrow();
for (_, destructor_def_id) in destructor_for_type.get().iter() {
- if destructor_def_id.crate == ast::LOCAL_CRATE {
+ if destructor_def_id.krate == ast::LOCAL_CRATE {
let mut reachable_symbols = self.reachable_symbols
.borrow_mut();
reachable_symbols.get().insert(destructor_def_id.node);
}
}
-pub fn resolve_crate(sess: Session, crate: &ast::Crate) -> RegionMaps {
+pub fn resolve_crate(sess: Session, krate: &ast::Crate) -> RegionMaps {
let maps = RegionMaps {
scope_map: RefCell::new(HashMap::new()),
var_map: RefCell::new(HashMap::new()),
region_maps: &maps
};
let cx = Context { parent: None, var_parent: None };
- visit::walk_crate(&mut visitor, crate, cx);
+ visit::walk_crate(&mut visitor, krate, cx);
}
return maps;
}
let graph_root = @NameBindings();
graph_root.define_module(NoParentLink,
- Some(DefId { crate: 0, node: 0 }),
+ Some(DefId { krate: 0, node: 0 }),
NormalModuleKind,
false,
true,
impl Resolver {
/// The main name resolution procedure.
- fn resolve(&mut self, crate: &ast::Crate) {
- self.build_reduced_graph(crate);
+ fn resolve(&mut self, krate: &ast::Crate) {
+ self.build_reduced_graph(krate);
self.session.abort_if_errors();
self.resolve_imports();
self.record_exports();
self.session.abort_if_errors();
- self.resolve_crate(crate);
+ self.resolve_crate(krate);
self.session.abort_if_errors();
- self.check_for_unused_imports(crate);
+ self.check_for_unused_imports(krate);
}
//
//
/// Constructs the reduced graph for the entire crate.
- fn build_reduced_graph(&mut self, crate: &ast::Crate) {
+ fn build_reduced_graph(&mut self, krate: &ast::Crate) {
let initial_parent =
ModuleReducedGraphParent(self.graph_root.get_module());
let mut visitor = BuildReducedGraphVisitor { resolver: self, };
- visit::walk_crate(&mut visitor, crate, initial_parent);
+ visit::walk_crate(&mut visitor, krate, initial_parent);
}
/// Returns the current module tracked by the reduced graph parent.
self.add_child(ident, parent, ForbidDuplicateModules, sp);
let parent_link = self.get_parent_link(new_parent, ident);
- let def_id = DefId { crate: 0, node: item.id };
+ let def_id = DefId { krate: 0, node: item.id };
name_bindings.define_module(parent_link,
Some(def_id),
NormalModuleKind,
// n.b. we don't need to look at the path option here, because cstore already did
match self.session.cstore.find_extern_mod_stmt_cnum(node_id) {
Some(crate_id) => {
- let def_id = DefId { crate: crate_id, node: 0 };
+ let def_id = DefId { krate: crate_id, node: 0 };
self.external_exports.insert(def_id);
let parent_link = ModuleParentLink
(self.get_module_from_parent(parent), name);
root.def_id
.get()
.unwrap()
- .crate,
+ .krate,
|def_like, ident, visibility| {
self.build_reduced_graph_for_external_crate_def(root,
def_like,
fn record_exports_for_module_subtree(&mut self,
module_: @Module) {
- // If this isn't a local crate, then bail out. We don't need to record
+ // If this isn't a local krate, then bail out. We don't need to record
// exports for nonlocal crates.
match module_.def_id.get() {
- Some(def_id) if def_id.crate == LOCAL_CRATE => {
+ Some(def_id) if def_id.krate == LOCAL_CRATE => {
// OK. Continue.
debug!("(recording exports for module subtree) recording \
exports for local module `{}`",
return None;
}
- fn resolve_crate(&mut self, crate: &ast::Crate) {
+ fn resolve_crate(&mut self, krate: &ast::Crate) {
debug!("(resolving crate) starting");
- visit::walk_crate(self, crate, ());
+ visit::walk_crate(self, krate, ());
}
fn resolve_item(&mut self, item: &Item) {
trait_def_id: DefId,
name: Ident) {
debug!("(adding trait info) found trait {}:{} for method '{}'",
- trait_def_id.crate,
+ trait_def_id.krate,
trait_def_id.node,
self.session.str_of(name));
found_traits.push(trait_def_id);
// resolve data structures.
//
- fn check_for_unused_imports(&self, crate: &ast::Crate) {
+ fn check_for_unused_imports(&self, krate: &ast::Crate) {
let mut visitor = UnusedImportCheckVisitor{ resolver: self };
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
fn check_for_item_unused_imports(&self, vi: &ViewItem) {
/// Entry point to crate resolution.
pub fn resolve_crate(session: Session,
lang_items: @LanguageItems,
- crate: &Crate)
+ krate: &Crate)
-> CrateMap {
- let mut resolver = Resolver(session, lang_items, crate.span);
- resolver.resolve(crate);
+ let mut resolver = Resolver(session, lang_items, krate.span);
+ resolver.resolve(krate);
let Resolver { def_map, export_map2, trait_map, last_private,
external_exports, .. } = resolver;
CrateMap {
RootScope
}
-pub fn crate(sess: session::Session, crate: &ast::Crate)
+pub fn krate(sess: session::Session, krate: &ast::Crate)
-> @RefCell<NamedRegionMap> {
let mut ctxt = LifetimeContext {
sess: sess,
named_region_map: @RefCell::new(HashMap::new())
};
- visit::walk_crate(&mut ctxt, crate, &RootScope);
+ visit::walk_crate(&mut ctxt, krate, &RootScope);
sess.abort_if_errors();
ctxt.named_region_map
}
substs: &[ty::t])
-> ValueRef {
let _icx = push_ctxt("trans_res_dtor");
- let did = if did.crate != ast::LOCAL_CRATE {
+ let did = if did.krate != ast::LOCAL_CRATE {
inline::maybe_instantiate_inline(ccx, did)
} else {
did
};
if !substs.is_empty() {
- assert_eq!(did.crate, ast::LOCAL_CRATE);
+ assert_eq!(did.krate, ast::LOCAL_CRATE);
let tsubsts = ty::substs {regions: ty::ErasedRegions,
self_ty: None,
tps: /*bad*/ substs.to_owned() };
None);
val
- } else if did.crate == ast::LOCAL_CRATE {
+ } else if did.krate == ast::LOCAL_CRATE {
get_item_val(ccx, did.node)
} else {
let tcx = ccx.tcx;
Ok(id) => id,
Err(s) => { ccx.tcx.sess.fatal(s); }
};
- let start_fn = if start_def_id.crate == ast::LOCAL_CRATE {
+ let start_fn = if start_def_id.krate == ast::LOCAL_CRATE {
get_item_val(ccx, start_def_id.node)
} else {
let start_fn_type = csearch::get_type(ccx.tcx,
}
}
-pub fn write_metadata(cx: &CrateContext, crate: &ast::Crate) -> ~[u8] {
+pub fn write_metadata(cx: &CrateContext, krate: &ast::Crate) -> ~[u8] {
use flate;
if !cx.sess.building_library.get() {
astencode::encode_inlined_item(ecx, ebml_w, path, ii, cx.maps);
let encode_parms = crate_ctxt_to_encode_parms(cx, encode_inlined_item);
- let metadata = encoder::encode_metadata(encode_parms, crate);
+ let metadata = encoder::encode_metadata(encode_parms, krate);
let compressed = encoder::metadata_encoding_version +
flate::deflate_bytes(metadata);
let llmeta = C_bytes(compressed);
}
pub fn trans_crate(sess: session::Session,
- crate: ast::Crate,
+ krate: ast::Crate,
analysis: &CrateAnalysis,
output: &OutputFilenames) -> CrateTranslation {
// Before we touch LLVM, make sure that multithreading is enabled.
}
let mut symbol_hasher = Sha256::new();
- let link_meta = link::build_link_meta(crate.attrs, output,
+ let link_meta = link::build_link_meta(krate.attrs, output,
&mut symbol_hasher);
// Append ".rs" to crate name as LLVM module identifier.
analysis.reachable);
{
let _icx = push_ctxt("text");
- trans_mod(ccx, &crate.module);
+ trans_mod(ccx, &krate.module);
}
decl_gc_metadata(ccx, llmod_id);
}
// Translate the metadata.
- let metadata = write_metadata(ccx, &crate);
+ let metadata = write_metadata(ccx, &krate);
if ccx.sess.trans_stats() {
println!("--- trans stats ---");
println!("n_static_tydescs: {}", ccx.stats.n_static_tydescs.get());
// Check whether this fn has an inlined copy and, if so, redirect
// def_id to the local id of the inlined copy.
let def_id = {
- if def_id.crate != ast::LOCAL_CRATE {
+ if def_id.krate != ast::LOCAL_CRATE {
inline::maybe_instantiate_inline(ccx, def_id)
} else {
def_id
let must_monomorphise;
if type_params.len() > 0 || is_default {
must_monomorphise = true;
- } else if def_id.crate == ast::LOCAL_CRATE {
+ } else if def_id.krate == ast::LOCAL_CRATE {
{
let map_node = session::expect(
ccx.sess,
// Create a monomorphic verison of generic functions
if must_monomorphise {
// Should be either intra-crate or inlined.
- assert_eq!(def_id.crate, ast::LOCAL_CRATE);
+ assert_eq!(def_id.krate, ast::LOCAL_CRATE);
let (val, must_cast) =
monomorphize::monomorphic_fn(ccx, def_id, &substs,
// Find the actual function pointer.
let mut val = {
- if def_id.crate == ast::LOCAL_CRATE {
+ if def_id.krate == ast::LOCAL_CRATE {
// Internal reference.
get_item_val(ccx, def_id.node)
} else {
args: &[ValueRef],
dest: Option<expr::Dest>)
-> Result<'a> {
- let fty = if did.crate == ast::LOCAL_CRATE {
+ let fty = if did.krate == ast::LOCAL_CRATE {
ty::node_id_to_type(bcx.ccx().tcx, did.node)
} else {
csearch::get_type(bcx.ccx().tcx, did).ty
dest: expr::Dest)
-> &'a Block<'a> {
let fty;
- if did.crate == ast::LOCAL_CRATE {
+ if did.krate == ast::LOCAL_CRATE {
fty = ty::node_id_to_type(bcx.tcx(), did.node);
} else {
fty = csearch::get_type(bcx.tcx(), did).ty;
// Could some consistency checks here: size, align, field count, discr type
// Find the source code location of the variant's definition
- let variant_definition_span = if variant_info.id.crate == ast::LOCAL_CRATE {
+ let variant_definition_span = if variant_info.id.krate == ast::LOCAL_CRATE {
{
match cx.tcx.items.find(variant_info.id.node) {
Some(ast_map::NodeVariant(ref variant, _, _)) => variant.span,
warning_span: Span)
-> (DIScope, Span) {
let containing_scope = namespace_for_item(cx, def_id, warning_span).scope;
- let definition_span = if def_id.crate == ast::LOCAL_CRATE {
+ let definition_span = if def_id.krate == ast::LOCAL_CRATE {
{
let definition_span = match cx.tcx.items.find(def_id.node) {
Some(ast_map::NodeItem(item, _)) => item.span,
let namespace_path = {
let mut item_path = ty::item_path(cx.tcx, def_id);
- if (def_id.crate == ast::LOCAL_CRATE && item_path.len() < 1) ||
- (def_id.crate != ast::LOCAL_CRATE && item_path.len() < 2) {
+ if (def_id.krate == ast::LOCAL_CRATE && item_path.len() < 1) ||
+ (def_id.krate != ast::LOCAL_CRATE && item_path.len() < 2) {
cx.sess.bug(format!("debuginfo::namespace_for_item() - Item path too short: {}",
ast_map::path_to_str(item_path, token::get_ident_interner())));
}
// remove the name of the item
item_path.pop();
- if def_id.crate == ast::LOCAL_CRATE {
+ if def_id.krate == ast::LOCAL_CRATE {
// prepend crate name if not already present
let crate_namespace_ident = token::str_to_ident(cx.link_meta.crateid.name);
item_path.insert(0, ast_map::PathMod(crate_namespace_ident));
fn get_did(ccx: @CrateContext, did: ast::DefId)
-> ast::DefId {
- if did.crate != ast::LOCAL_CRATE {
+ if did.krate != ast::LOCAL_CRATE {
inline::maybe_instantiate_inline(ccx, did)
} else {
did
fn get_val<'a>(bcx: &'a Block<'a>, did: ast::DefId, const_ty: ty::t)
-> ValueRef {
// For external constants, we don't inline.
- if did.crate == ast::LOCAL_CRATE {
+ if did.krate == ast::LOCAL_CRATE {
// The LLVM global has the type of its initializer,
// which may not be equal to the enum's type for
// non-C-like enums.
let external_srcs = ccx.external_srcs.borrow();
srccrate = match external_srcs.get().find(&bcx.fcx.id) {
Some(&src) => {
- ccx.sess.cstore.get_crate_data(src.crate).name.clone()
+ ccx.sess.cstore.get_crate_data(src.krate).name.clone()
}
None => ccx.link_meta.crateid.name.to_str(),
};
let bound_index = ty::lookup_trait_def(bcx.tcx(), trait_id).
generics.type_param_defs().len();
- let mname = if method_id.crate == ast::LOCAL_CRATE {
+ let mname = if method_id.krate == ast::LOCAL_CRATE {
{
match bcx.tcx().items.get(method_id.node) {
ast_map::NodeTraitMethod(trait_method, _, _) => {
let tstr = ppaux::parameterized(cx.tcx, ty::item_path_str(cx.tcx, did),
&ty::NonerasedRegions(opt_vec::Empty),
tps, did, false);
- if did.crate == 0 {
+ if did.krate == 0 {
format!("{}.{}", name, tstr)
} else {
- format!("{}.{}[\\#{}]", name, tstr, did.crate)
+ format!("{}.{}[\\#{}]", name, tstr, did.krate)
}
}
// If this assertion failures, it is likely because of a
// failure in the cross-crate inlining code to translate a
// def-id.
- assert_eq!(p.def_id.crate, ast::LOCAL_CRATE);
+ assert_eq!(p.def_id.krate, ast::LOCAL_CRATE);
let ty_param_defs = cx.ty_param_defs.borrow();
let tp_def = ty_param_defs.get().get(&p.def_id.node);
None => { }
}
- if def_id.crate == ast::LOCAL_CRATE {
- fail!("no def'n found for {:?} in tcx.{}", def_id, descr);
+ if def_id.krate == ast::LOCAL_CRATE {
+ fail!("No def'n found for {:?} in tcx.{}", def_id, descr);
}
let v = load_external();
map.insert(def_id, v.clone());
}
}
- let ret = if id.crate == ast::LOCAL_CRATE {
+ let ret = if id.krate == ast::LOCAL_CRATE {
debug!("(impl_trait_ref) searching for trait impl {:?}", id);
{
match cx.items.find(id.node) {
}
pub fn item_path(cx: ctxt, id: ast::DefId) -> ast_map::Path {
- if id.crate != ast::LOCAL_CRATE {
+ if id.krate != ast::LOCAL_CRATE {
return csearch::get_item_path(cx, id)
}
}
}
- let result = if ast::LOCAL_CRATE != id.crate {
+ let result = if ast::LOCAL_CRATE != id.krate {
@csearch::get_enum_variants(cx, id)
} else {
/*
return trait_def;
}
None => {
- assert!(did.crate != ast::LOCAL_CRATE);
+ assert!(did.krate != ast::LOCAL_CRATE);
let trait_def = @csearch::get_trait_def(cx, did);
trait_defs.get().insert(did, trait_def);
return trait_def;
id: DefId,
substs: &substs)
-> ty::t {
- let t = if id.crate == ast::LOCAL_CRATE {
+ let t = if id.krate == ast::LOCAL_CRATE {
node_id_to_type(tcx, id.node)
} else {
{
// Look up the list of field names and IDs for a given struct
// Fails if the id is not bound to a struct.
pub fn lookup_struct_fields(cx: ctxt, did: ast::DefId) -> ~[field_ty] {
- if did.crate == ast::LOCAL_CRATE {
+ if did.krate == ast::LOCAL_CRATE {
{
match cx.items.find(did.node) {
Some(ast_map::NodeItem(i,_)) => {
/// if necessary.
pub fn populate_implementations_for_type_if_necessary(tcx: ctxt,
type_id: ast::DefId) {
- if type_id.crate == LOCAL_CRATE {
+ if type_id.krate == LOCAL_CRATE {
return
}
{
pub fn populate_implementations_for_trait_if_necessary(
tcx: ctxt,
trait_id: ast::DefId) {
- if trait_id.crate == LOCAL_CRATE {
+ if trait_id.krate == LOCAL_CRATE {
return
}
{
/// the trait that the method belongs to. Otherwise, return `None`.
pub fn trait_of_method(tcx: ctxt, def_id: ast::DefId)
-> Option<ast::DefId> {
- if def_id.crate != LOCAL_CRATE {
+ if def_id.krate != LOCAL_CRATE {
return csearch::get_trait_of_method(tcx.cstore, def_id, tcx);
}
let method;
let h = if ast_util::is_local(did) {
local_hash.clone()
} else {
- tcx.sess.cstore.get_crate_hash(did.crate)
+ tcx.sess.cstore.get_crate_hash(did.krate)
};
hash.input(h.as_bytes());
iter(hash, &did.node);
}
fn report_static_candidate(&self, idx: uint, did: DefId) {
- let span = if did.crate == ast::LOCAL_CRATE {
+ let span = if did.krate == ast::LOCAL_CRATE {
{
match self.tcx().items.find(did.node) {
Some(ast_map::NodeMethod(m, _, _)) => m.span,
}
}
-pub fn check_item_types(ccx: @CrateCtxt, crate: &ast::Crate) {
+pub fn check_item_types(ccx: @CrateCtxt, krate: &ast::Crate) {
let mut visit = CheckItemTypesVisitor { ccx: ccx };
- visit::walk_crate(&mut visit, crate, ());
+ visit::walk_crate(&mut visit, krate, ());
}
fn check_bare_fn(ccx: @CrateCtxt,
Err(msg) => {
tcx.sess.span_err(expr.span, msg);
ast::DefId {
- crate: ast::CRATE_NODE_ID,
+ krate: ast::CRATE_NODE_ID,
node: ast::DUMMY_NODE_ID,
}
}
return variants;
}
- let hint = ty::lookup_repr_hint(ccx.tcx, ast::DefId { crate: ast::LOCAL_CRATE, node: id });
+ let hint = ty::lookup_repr_hint(ccx.tcx, ast::DefId { krate: ast::LOCAL_CRATE, node: id });
if hint != attr::ReprAny && vs.len() <= 1 {
ccx.tcx.sess.span_err(sp, format!("unsupported representation for {}variant enum",
if vs.len() == 1 { "uni" } else { "zero-" }))
// Identify the variable being closed over and its node-id.
let def = freevar.def;
let def_id = ast_util::def_id_of_def(def);
- assert!(def_id.crate == ast::LOCAL_CRATE);
+ assert!(def_id.krate == ast::LOCAL_CRATE);
let upvar_id = ty::UpvarId { var_id: def_id.node,
closure_expr_id: expr.id };
ty_enum(def_id, _) |
ty_trait(def_id, _, _, _, _) |
ty_struct(def_id, _) => {
- if def_id.crate == ast::LOCAL_CRATE {
+ if def_id.krate == ast::LOCAL_CRATE {
found_nominal = true;
}
}
let trait_def_id =
self.cc.trait_ref_to_trait_def_id(trait_ref);
- if trait_def_id.crate != LOCAL_CRATE {
+ if trait_def_id.krate != LOCAL_CRATE {
let session = self.cc.crate_context.tcx.sess;
session.span_err(item.span,
"cannot provide an extension implementation \
}
}
- fn check(&self, crate: &Crate) {
+ fn check(&self, krate: &Crate) {
// Check implementations and traits. This populates the tables
// containing the inherent methods and extension methods. It also
// builds up the trait inheritance table.
let mut visitor = CoherenceCheckVisitor { cc: self };
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
// Check that there are no overlapping trait instances
self.check_implementation_coherence();
// Check whether traits with base types are in privileged scopes.
- self.check_privileged_scopes(crate);
+ self.check_privileged_scopes(krate);
// Bring in external crates. It's fine for this to happen after the
// coherence checks, because we ensure by construction that no errors
format!("conflicting implementations for trait `{}`",
ty::item_path_str(self.crate_context.tcx,
trait_def_id)));
- if implementation_b.did.crate == LOCAL_CRATE {
+ if implementation_b.did.krate == LOCAL_CRATE {
session.span_note(self.span_of_impl(implementation_b),
"note conflicting implementation here");
} else {
let crate_store = self.crate_context.tcx.sess.cstore;
- let cdata = crate_store.get_crate_data(implementation_b.did.crate);
+ let cdata = crate_store.get_crate_data(implementation_b.did.krate);
session.note(
"conflicting implementation in crate `" + cdata.name + "`");
}
fn iter_impls_of_trait(&self, trait_def_id: DefId, f: |@Impl|) {
self.iter_impls_of_trait_local(trait_def_id, |x| f(x));
- if trait_def_id.crate == LOCAL_CRATE {
+ if trait_def_id.krate == LOCAL_CRATE {
return;
}
}
// Privileged scope checking
- fn check_privileged_scopes(&self, crate: &Crate) {
- let mut visitor = PrivilegedScopeVisitor { cc: self };
- visit::walk_crate(&mut visitor, crate, ());
+ fn check_privileged_scopes(&self, krate: &Crate) {
+ let mut visitor = PrivilegedScopeVisitor{ cc: self };
+ visit::walk_crate(&mut visitor, krate, ());
}
fn trait_ref_to_trait_def_id(&self, trait_ref: &TraitRef) -> DefId {
let def_map = self.crate_context.tcx.def_map.borrow();
match def_map.get().get_copy(&path_id) {
DefTy(def_id) | DefStruct(def_id) => {
- if def_id.crate != LOCAL_CRATE {
+ if def_id.krate != LOCAL_CRATE {
return false;
}
}
fn span_of_impl(&self, implementation: @Impl) -> Span {
- assert_eq!(implementation.did.crate, LOCAL_CRATE);
+ assert_eq!(implementation.did.krate, LOCAL_CRATE);
match self.crate_context.tcx.items.find(implementation.did.node) {
Some(NodeItem(item, _)) => {
return item.span;
let crate_store = self.crate_context.tcx.sess.cstore;
crate_store.iter_crate_data(|crate_number, _crate_metadata| {
each_impl(crate_store, crate_number, |def_id| {
- assert_eq!(crate_number, def_id.crate);
+ assert_eq!(crate_number, def_id.krate);
self.add_external_impl(&mut impls_seen, def_id)
})
})
}
_ => {
// Destructors only work on nominal types.
- if impl_info.did.crate == ast::LOCAL_CRATE {
+ if impl_info.did.krate == ast::LOCAL_CRATE {
{
match tcx.items.find(impl_info.did.node) {
Some(ast_map::NodeItem(item, _)) => {
)
}
-pub fn check_coherence(crate_context: @CrateCtxt, crate: &Crate) {
- CoherenceChecker::new(crate_context).check(crate);
+pub fn check_coherence(crate_context: @CrateCtxt, krate: &Crate) {
+ CoherenceChecker::new(crate_context).check(krate);
}
}
}
-pub fn collect_item_types(ccx: @CrateCtxt, crate: &ast::Crate) {
+pub fn collect_item_types(ccx: @CrateCtxt, krate: &ast::Crate) {
fn collect_intrinsic_type(ccx: &CrateCtxt,
lang_item: ast::DefId) {
let ty::ty_param_bounds_and_ty { ty: ty, .. } =
}
let mut visitor = CollectItemTypesVisitor{ ccx: ccx };
- visit::walk_crate(&mut visitor, crate, ());
+ visit::walk_crate(&mut visitor, krate, ());
}
pub trait ToTy {
fn tcx(&self) -> ty::ctxt { self.tcx }
fn get_item_ty(&self, id: ast::DefId) -> ty::ty_param_bounds_and_ty {
- if id.crate != ast::LOCAL_CRATE {
+ if id.krate != ast::LOCAL_CRATE {
return csearch::get_type(self.tcx, id)
}
let tcx = ccx.tcx;
- let dummy_defid = ast::DefId {crate: 0, node: 0};
+ let dummy_defid = ast::DefId {krate: 0, node: 0};
// Represents [A',B',C']
let num_trait_bounds = trait_ty_generics.type_param_defs().len();
}
fn get_trait_def(ccx: &CrateCtxt, trait_id: ast::DefId) -> @ty::TraitDef {
- if trait_id.crate != ast::LOCAL_CRATE {
+ if trait_id.krate != ast::LOCAL_CRATE {
return ty::lookup_trait_def(ccx.tcx, trait_id)
}
use syntax::{ast, attr, parse};
struct Env {
- crate: @ast::Crate,
+ krate: @ast::Crate,
tcx: ty::ctxt,
infcx: infer::infer_ctxt,
err_messages: @DVec<~str>
let lang_items = LanguageItems::new();
let parse_sess = parse::new_parse_sess(None);
- let crate = parse_crate_from_source_str(
+ let krate = parse_crate_from_source_str(
test_name.to_str(), @source_string.to_str(),
cfg, parse_sess);
let infcx = infer::new_infer_ctxt(tcx);
- return Env {crate: crate,
+ return Env {krate: krate,
tcx: tcx,
infcx: infcx,
err_messages: messages};
}
pub fn lookup_item(&self, names: &[~str]) -> ast::node_id {
- return match search_mod(self, &self.crate.node.module, 0, names) {
+ return match search_mod(self, &self.krate.node.module, 0, names) {
Some(id) => id,
None => {
fail!("no item found: `%s`", names.connect("::"));
pub fn check_crate(tcx: ty::ctxt,
trait_map: resolve::TraitMap,
- crate: &ast::Crate)
+ krate: &ast::Crate)
-> (method_map, vtable_map) {
let time_passes = tcx.sess.time_passes();
let ccx = @CrateCtxt {
};
time(time_passes, "type collecting", (), |_|
- collect::collect_item_types(ccx, crate));
+ collect::collect_item_types(ccx, krate));
// this ensures that later parts of type checking can assume that items
// have valid types and not error
tcx.sess.abort_if_errors();
time(time_passes, "variance inference", (), |_|
- variance::infer_variance(tcx, crate));
+ variance::infer_variance(tcx, krate));
time(time_passes, "coherence checking", (), |_|
- coherence::check_coherence(ccx, crate));
+ coherence::check_coherence(ccx, krate));
time(time_passes, "type checking", (), |_|
- check::check_item_types(ccx, crate));
+ check::check_item_types(ccx, krate));
check_for_entry_fn(ccx);
tcx.sess.abort_if_errors();
pub fn bound_type_regions(defs: &[ty::RegionParameterDef])
-> OptVec<ty::Region> {
- assert!(defs.iter().all(|def| def.def_id.crate == ast::LOCAL_CRATE));
+ assert!(defs.iter().all(|def| def.def_id.krate == ast::LOCAL_CRATE));
defs.iter().enumerate().map(
|(i, def)| ty::ReEarlyBound(def.def_id.node, i, def.ident)).collect()
}
use util::ppaux::Repr;
pub fn infer_variance(tcx: ty::ctxt,
- crate: &ast::Crate) {
+ krate: &ast::Crate) {
let mut arena = arena::Arena::new();
- let terms_cx = determine_parameters_to_be_inferred(tcx, &mut arena, crate);
- let constraints_cx = add_constraints_from_crate(terms_cx, crate);
+ let terms_cx = determine_parameters_to_be_inferred(tcx, &mut arena, krate);
+ let constraints_cx = add_constraints_from_crate(terms_cx, krate);
solve_constraints(constraints_cx);
}
fn determine_parameters_to_be_inferred<'a>(tcx: ty::ctxt,
arena: &'a mut Arena,
- crate: &ast::Crate)
+ krate: &ast::Crate)
-> TermsContext<'a> {
let mut terms_cx = TermsContext {
tcx: tcx,
region_params: opt_vec::Empty }
};
- visit::walk_crate(&mut terms_cx, crate, ());
+ visit::walk_crate(&mut terms_cx, krate, ());
terms_cx
}
}
fn add_constraints_from_crate<'a>(terms_cx: TermsContext<'a>,
- crate: &ast::Crate)
+ krate: &ast::Crate)
-> ConstraintContext<'a> {
let mut invariant_lang_items = [None, ..3];
let mut covariant_lang_items = [None, ..3];
bivariant: bivariant,
constraints: ~[],
};
- visit::walk_crate(&mut constraint_cx, crate, ());
+ visit::walk_crate(&mut constraint_cx, krate, ());
constraint_cx
}
ast::ItemStruct(..) => {
let struct_fields = ty::lookup_struct_fields(tcx, did);
for field_info in struct_fields.iter() {
- assert_eq!(field_info.id.crate, ast::LOCAL_CRATE);
+ assert_eq!(field_info.id.krate, ast::LOCAL_CRATE);
let field_ty = ty::node_id_to_type(tcx, field_info.id.node);
self.add_constraints_from_ty(field_ty, self.covariant);
}
* the type/region parameter with the given id.
*/
- assert_eq!(param_def_id.crate, item_def_id.crate);
+ assert_eq!(param_def_id.krate, item_def_id.krate);
if self.invariant_lang_items[kind as uint] == Some(item_def_id) {
self.invariant
self.covariant
} else if self.contravariant_lang_items[kind as uint] == Some(item_def_id) {
self.contravariant
- } else if param_def_id.crate == ast::LOCAL_CRATE {
+ } else if param_def_id.krate == ast::LOCAL_CRATE {
// Parameter on an item defined within current crate:
// variance not yet inferred, so return a symbolic
// variance.
}
ty::ty_param(ty::param_ty { def_id: ref def_id, .. }) => {
- assert_eq!(def_id.crate, ast::LOCAL_CRATE);
+ assert_eq!(def_id.krate, ast::LOCAL_CRATE);
match self.terms_cx.inferred_map.find(&def_id.node) {
Some(&index) => {
self.add_constraint(index, variance);
}
ty::ty_self(ref def_id) => {
- assert_eq!(def_id.crate, ast::LOCAL_CRATE);
+ assert_eq!(def_id.krate, ast::LOCAL_CRATE);
let index = self.inferred_index(def_id.node);
self.add_constraint(index, variance);
}
// Unfortunately, there seems to be no way to attempt to print
// a path for a def-id, so I'll just make a best effort for now
// and otherwise fallback to just printing the crate/node pair
- if self.crate == ast::LOCAL_CRATE {
+ if self.krate == ast::LOCAL_CRATE {
{
match tcx.items.find(self.node) {
Some(ast_map::NodeItem(..)) |
typarams: Option<~[TyParamBound]>,
fqn: ~[~str],
kind: TypeKind,
- crate: ast::CrateNum,
+ krate: ast::CrateNum,
},
// I have no idea how to usefully use this.
TyParamBinder(ast::NodeId),
}
}).to_owned_vec();
ExternalPath{ path: path, typarams: tpbs, fqn: fqn, kind: kind,
- crate: def_id.crate }
+ krate: def_id.krate }
}
}
use clean::Clean;
pub struct DocContext {
- crate: ast::Crate,
+ krate: ast::Crate,
tycx: Option<middle::ty::ctxt>,
sess: driver::session::Session
}
cfg.push(@dummy_spanned(ast::MetaWord(cfg_)));
}
- let crate = phase_1_parse_input(sess, cfg, &input);
+ let krate = phase_1_parse_input(sess, cfg, &input);
let loader = &mut Loader::new(sess);
- let (crate, ast_map) = phase_2_configure_and_expand(sess, loader, crate);
+ let (krate, ast_map) = phase_2_configure_and_expand(sess, loader, krate);
let driver::driver::CrateAnalysis {
exported_items, public_items, ty_cx, ..
- } = phase_3_run_analysis_passes(sess, &crate, ast_map);
+ } = phase_3_run_analysis_passes(sess, &krate, ast_map);
- debug!("crate: {:?}", crate);
- return (DocContext { crate: crate, tycx: Some(ty_cx), sess: sess },
+ debug!("crate: {:?}", krate);
+ return (DocContext { krate: krate, tycx: Some(ty_cx), sess: sess },
CrateAnalysis {
exported_items: exported_items,
public_items: public_items,
let ctxt = @ctxt;
local_data::set(super::ctxtkey, ctxt);
- let crate = {
+ let krate = {
let mut v = RustdocVisitor::new(ctxt, Some(&analysis));
- v.visit(&ctxt.crate);
+ v.visit(&ctxt.krate);
v.clean()
};
- (crate, analysis)
+ (krate, analysis)
}
/// will invoke `path` with proper linking-style arguments.
fn external_path(w: &mut io::Writer, p: &clean::Path, print_all: bool,
fqn: &[~str], kind: clean::TypeKind,
- crate: ast::CrateNum) -> fmt::Result {
+ krate: ast::CrateNum) -> fmt::Result {
path(w, p, print_all,
|cache, loc| {
- match *cache.extern_locations.get(&crate) {
+ match *cache.extern_locations.get(&krate) {
render::Remote(ref s) => Some(s.clone()),
render::Local => Some("../".repeat(loc.len())),
render::Unknown => None,
typarams(f.buf, tp)
}
clean::ExternalPath{path: ref path, typarams: ref tp,
- fqn: ref fqn, kind, crate} => {
+ fqn: ref fqn, kind, krate} => {
if_ok!(external_path(f.buf, path, false, fqn.as_slice(), kind,
- crate))
+ krate))
typarams(f.buf, tp)
}
clean::Self(..) => f.buf.write("Self".as_bytes()),
pub struct Layout {
logo: ~str,
favicon: ~str,
- crate: ~str,
+ krate: ~str,
}
pub struct Page<'a> {
<link href='http://fonts.googleapis.com/css?family=Oswald:700|Inconsolata:400'
rel='stylesheet' type='text/css'>
- <link rel=\"stylesheet\" type=\"text/css\" href=\"{root_path}{crate}/main.css\">
+ <link rel=\"stylesheet\" type=\"text/css\" href=\"{root_path}{krate}/main.css\">
{favicon, select, none{} other{<link rel=\"shortcut icon\" href=\"#\" />}}
</head>
<section class=\"sidebar\">
{logo, select, none{} other{
- <a href='{root_path}{
crate}/index.html'><img src='#' alt=''/></a>
+ <a href='{root_path}{
krate}/index.html'><img src='#' alt=''/></a>
}}
{sidebar}
<script>
var rootPath = \"{root_path}\";
</script>
- <script src=\"{root_path}{crate}/jquery.js\"></script>
- <script src=\"{root_path}{crate}/search-index.js\"></script>
- <script src=\"{root_path}{crate}/main.js\"></script>
+ <script src=\"{root_path}{krate}/jquery.js\"></script>
+ <script src=\"{root_path}{krate}/search-index.js\"></script>
+ <script src=\"{root_path}{krate}/main.js\"></script>
<div id=\"help\" class=\"hidden\">
<div class=\"shortcuts\">
title = page.title,
favicon = nonestr(layout.favicon),
sidebar = *sidebar,
- crate = layout.crate,
+ krate = layout.krate,
)
}
local_data_key!(pub current_location_key: ~[~str])
/// Generates the documentation for `crate` into the directory `dst`
-pub fn run(mut crate: clean::Crate, dst: Path) -> io::IoResult<()> {
+pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
let mut cx = Context {
dst: dst,
current: ~[],
layout: layout::Layout {
logo: ~"",
favicon: ~"",
- crate: crate.name.clone(),
+ krate: krate.name.clone(),
},
include_sources: true,
};
if_ok!(mkdir(&cx.dst));
- match crate.module.as_ref().map(|m| m.doc_list().unwrap_or(&[])) {
+ match krate.module.as_ref().map(|m| m.doc_list().unwrap_or(&[])) {
Some(attrs) => {
for attr in attrs.iter() {
match *attr {
extern_locations: HashMap::new(),
privmod: false,
};
- cache.stack.push(crate.name.clone());
- crate = cache.fold_crate(crate);
+ cache.stack.push(krate.name.clone());
+ krate = cache.fold_crate(krate);
// Add all the static files
- let mut dst = cx.dst.join(crate.name.as_slice());
+ let mut dst = cx.dst.join(krate.name.as_slice());
if_ok!(mkdir(&dst));
if_ok!(write(dst.join("jquery.js"),
include_str!("static/jquery-2.1.0.min.js")));
info!("emitting source files");
let dst = cx.dst.join("src");
if_ok!(mkdir(&dst));
- let dst = dst.join(crate.name.as_slice());
+ let dst = dst.join(krate.name.as_slice());
if_ok!(mkdir(&dst));
let mut folder = SourceCollector {
dst: dst,
seen: HashSet::new(),
cx: &mut cx,
};
- crate = folder.fold_crate(crate);
+ krate = folder.fold_crate(krate);
}
- for (&n, e) in crate.externs.iter() {
+ for (&n, e) in krate.externs.iter() {
cache.extern_locations.insert(n, extern_location(e, &cx.dst));
}
// And finally render the whole crate's documentation
- cx.crate(crate, cache)
+ cx.krate(krate, cache)
}
/// Writes the entire contents of a string to a destination, not attempting to
///
/// This currently isn't parallelized, but it'd be pretty easy to add
/// parallelization to this function.
- fn crate(self, mut crate: clean::Crate, cache: Cache) -> io::IoResult<()> {
- let mut item = match crate.module.take() {
+ fn krate(self, mut krate: clean::Crate, cache: Cache) -> io::IoResult<()> {
+ let mut item = match krate.module.take() {
Some(i) => i,
None => return Ok(())
};
- item.name = Some(crate.name);
+ item.name = Some(krate.name);
// using a rwarc makes this parallelizable in the future
local_data::set(cache_key, Arc::new(cache));
};
if_ok!(write!(fmt.buf,
"<a class='source'
- href='{root}src/{crate}/{path}.html\\#{href}'>\
+ href='{root}src/{krate}/{path}.html\\#{href}'>\
[src]</a>",
root = self.cx.root_path,
- crate = self.cx.layout.crate,
+ krate = self.cx.layout.krate,
path = path.connect("/"),
href = href));
}
return 0;
}
- let (crate, res) = match acquire_input(input, &matches) {
+ let (krate, res) = match acquire_input(input, &matches) {
Ok(pair) => pair,
Err(s) => {
println!("input error: {}", s);
let output = matches.opt_str("o").map(|s| Path::new(s));
match matches.opt_str("w") {
Some(~"html") | None => {
- match html::render::run(crate, output.unwrap_or(Path::new("doc"))) {
+ match html::render::run(krate, output.unwrap_or(Path::new("doc"))) {
Ok(()) => {}
Err(e) => fail!("failed to generate documentation: {}", e),
}
}
Some(~"json") => {
- match json_output(crate, res, output.unwrap_or(Path::new("doc.json"))) {
+ match json_output(krate, res, output.unwrap_or(Path::new("doc.json"))) {
Ok(()) => {}
Err(e) => fail!("failed to write json: {}", e),
}
let cfgs = matches.opt_strs("cfg");
let cr = Path::new(cratefile);
info!("starting to run rustc");
- let (crate, analysis) = std::task::try(proc() {
+ let (krate, analysis) = std::task::try(proc() {
let cr = cr;
core::run_core(libs.move_iter().collect(), cfgs, &cr)
}).unwrap();
// Process all of the crate attributes, extracting plugin metadata along
// with the passes which we are supposed to run.
- match crate.module.get_ref().doc_list() {
+ match krate.module.get_ref().doc_list() {
Some(nested) => {
for inner in nested.iter() {
match *inner {
// Run everything!
info!("Executing passes/plugins");
- return pm.run_plugins(crate);
+ return pm.run_plugins(krate);
}
/// This input format purely deserializes the json output file. No passes are
Some(..) => return Err(~"malformed json"),
None => return Err(~"expected a schema version"),
}
- let crate = match obj.pop(&~"crate") {
+ let krate = match obj.pop(&~"crate") {
Some(json) => {
let mut d = json::Decoder::new(json);
Decodable::decode(&mut d)
// FIXME: this should read from the "plugins" field, but currently
// Json doesn't implement decodable...
let plugin_output = ~[];
- Ok((crate, plugin_output))
+ Ok((krate, plugin_output))
}
Ok(..) => Err(~"malformed json input: expected an object at the top"),
}
/// Outputs the crate/plugin json as a giant json blob at the specified
/// destination.
-fn json_output(crate: clean::Crate, res: ~[plugins::PluginJson],
+fn json_output(krate: clean::Crate, res: ~[plugins::PluginJson],
dst: Path) -> io::IoResult<()> {
// {
// "schema": version,
let mut w = MemWriter::new();
{
let mut encoder = json::Encoder::new(&mut w as &mut io::Writer);
- crate.encode(&mut encoder);
+ krate.encode(&mut encoder);
}
str::from_utf8_owned(w.unwrap()).unwrap()
};
use fold::DocFolder;
/// Strip items marked `#[doc(hidden)]`
-pub fn strip_hidden(crate: clean::Crate) -> plugins::PluginResult {
+pub fn strip_hidden(krate: clean::Crate) -> plugins::PluginResult {
struct Stripper;
impl fold::DocFolder for Stripper {
fn fold_item(&mut self, i: Item) -> Option<Item> {
}
}
let mut stripper = Stripper;
- let crate = stripper.fold_crate(crate);
- (crate, None)
+ let krate = stripper.fold_crate(krate);
+ (krate, None)
}
/// Strip private items from the point of view of a crate or externally from a
/// crate, specified by the `xcrate` flag.
-pub fn strip_private(crate: clean::Crate) -> plugins::PluginResult {
+pub fn strip_private(krate: clean::Crate) -> plugins::PluginResult {
// This stripper collects all *retained* nodes.
let mut retained = HashSet::new();
let exported_items = local_data::get(super::analysiskey, |analysis| {
analysis.unwrap().exported_items.clone()
});
- let mut crate = crate;
+ let mut krate = krate;
// strip all private items
{
retained: &mut retained,
exported_items: &exported_items,
};
- crate = stripper.fold_crate(crate);
+ krate = stripper.fold_crate(krate);
}
// strip all private implementations of traits
{
let mut stripper = ImplStripper(&retained);
- crate = stripper.fold_crate(crate);
+ krate = stripper.fold_crate(krate);
}
- (crate, None)
+ (krate, None)
}
struct Stripper<'a> {
}
-pub fn unindent_comments(crate: clean::Crate) -> plugins::PluginResult {
+pub fn unindent_comments(krate: clean::Crate) -> plugins::PluginResult {
struct CommentCleaner;
impl fold::DocFolder for CommentCleaner {
fn fold_item(&mut self, i: Item) -> Option<Item> {
}
}
let mut cleaner = CommentCleaner;
- let crate = cleaner.fold_crate(crate);
- (crate, None)
+ let krate = cleaner.fold_crate(krate);
+ (krate, None)
}
-pub fn collapse_docs(crate: clean::Crate) -> plugins::PluginResult {
+pub fn collapse_docs(krate: clean::Crate) -> plugins::PluginResult {
struct Collapser;
impl fold::DocFolder for Collapser {
fn fold_item(&mut self, i: Item) -> Option<Item> {
}
}
let mut collapser = Collapser;
- let crate = collapser.fold_crate(crate);
- (crate, None)
+ let krate = collapser.fold_crate(krate);
+ (krate, None)
}
pub fn unindent(s: &str) -> ~str {
self.callbacks.push(plugin);
}
/// Run all the loaded plugins over the crate, returning their results
- pub fn run_plugins(&self, crate: clean::Crate) -> (clean::Crate, ~[PluginJson]) {
+ pub fn run_plugins(&self, krate: clean::Crate) -> (clean::Crate, ~[PluginJson]) {
let mut out_json = ~[];
- let mut crate = crate;
+ let mut krate = krate;
for &callback in self.callbacks.iter() {
- let (c, res) = callback(crate);
- crate = c;
+ let (c, res) = callback(krate);
+ krate = c;
out_json.push(res);
}
- (crate, out_json)
+ (krate, out_json)
}
}
span_diagnostic_handler);
let cfg = driver::build_configuration(sess);
- let crate = driver::phase_1_parse_input(sess, cfg, &input);
+ let krate = driver::phase_1_parse_input(sess, cfg, &input);
let loader = &mut Loader::new(sess);
- let (crate, _) = driver::phase_2_configure_and_expand(sess, loader, crate);
+ let (krate, _) = driver::phase_2_configure_and_expand(sess, loader, krate);
let ctx = @core::DocContext {
- crate: crate,
+ krate: krate,
tycx: None,
sess: sess,
};
local_data::set(super::ctxtkey, ctx);
let mut v = RustdocVisitor::new(ctx, None);
- v.visit(&ctx.crate);
- let crate = v.clean();
- let (crate, _) = passes::unindent_comments(crate);
- let (crate, _) = passes::collapse_docs(crate);
+ v.visit(&ctx.krate);
+ let krate = v.clean();
+ let (krate, _) = passes::unindent_comments(krate);
+ let (krate, _) = passes::collapse_docs(krate);
let mut collector = Collector {
tests: ~[],
names: ~[],
cnt: 0,
libs: libs,
- cratename: crate.name.to_owned(),
+ cratename: krate.name.to_owned(),
};
- collector.fold_crate(crate);
+ collector.fold_crate(krate);
let args = matches.opt_strs("test-args");
let mut args = args.iter().flat_map(|s| s.words()).map(|s| s.to_owned());
}
}
- pub fn visit(&mut self, crate: &ast::Crate) {
- self.attrs = crate.attrs.clone();
+ pub fn visit(&mut self, krate: &ast::Crate) {
+ self.attrs = krate.attrs.clone();
- self.module = self.visit_mod_contents(crate.span, crate.attrs.clone(),
+ self.module = self.visit_mod_contents(krate.span, krate.attrs.clone(),
ast::Public, ast::CRATE_NODE_ID,
- &crate.module, None);
+ &krate.module, None);
}
pub fn visit_struct_def(&mut self, item: &ast::Item, sd: @ast::StructDef,
#[deriving(Clone, TotalEq, TotalOrd, Eq, Encodable, Decodable, IterBytes, ToStr)]
pub struct DefId {
- crate: CrateNum,
+ krate: CrateNum,
node: NodeId,
}
diag: diag,
fold_ops: fold_ops
};
- let crate = cx.fold_crate(c);
+ let krate = cx.fold_crate(c);
if log_enabled!(logging::DEBUG) {
let map = cx.map.map.borrow();
entries, vector_length, (entries as f64 / vector_length as f64) * 100.);
}
- (crate, cx.map)
+ (krate, cx.map)
}
// Used for items loaded from external crate that are being inlined into this
}
pub fn local_def(id: NodeId) -> DefId {
- ast::DefId { crate: LOCAL_CRATE, node: id }
+ ast::DefId { krate: LOCAL_CRATE, node: id }
}
-pub fn is_local(did: ast::DefId) -> bool { did.crate == LOCAL_CRATE }
+pub fn is_local(did: ast::DefId) -> bool { did.krate == LOCAL_CRATE }
pub fn stmt_id(s: &Stmt) -> NodeId {
match s.node {
}
pub trait CrateLoader {
- fn load_crate(&mut self, crate: &ast::ViewItem) -> MacroCrate;
+ fn load_crate(&mut self, krate: &ast::ViewItem) -> MacroCrate;
fn get_exported_macros(&mut self, crate_num: ast::CrateNum) -> ~[~str];
fn get_registrar_symbol(&mut self, crate_num: ast::CrateNum) -> Option<~str>;
}
noop_fold_view_item(vi, fld)
}
-fn load_extern_macros(crate: &ast::ViewItem, fld: &mut MacroExpander) {
- let MacroCrate { lib, cnum } = fld.cx.loader.load_crate(crate);
+fn load_extern_macros(krate: &ast::ViewItem, fld: &mut MacroExpander) {
+ let MacroCrate { lib, cnum } = fld.cx.loader.load_crate(krate);
- let crate_name = match crate.node {
+ let crate_name = match krate.node {
ast::ViewItemExternMod(ref name, _, _) => {
let string = token::get_ident(name.name);
string.get().to_str()
// this is fatal: there are almost certainly macros we need
// inside this crate, so continue would spew "macro undefined"
// errors
- Err(err) => fld.cx.span_fatal(crate.span, err)
+ Err(err) => fld.cx.span_fatal(krate.span, err)
};
unsafe {
let registrar: MacroCrateRegistrationFun = match lib.symbol(registrar) {
Ok(registrar) => registrar,
// again fatal if we can't register macros
- Err(err) => fld.cx.span_fatal(crate.span, err)
+ Err(err) => fld.cx.span_fatal(krate.span, err)
};
registrar(|name, extension| {
let extension = match extension {
- NormalTT(ext, _) => NormalTT(ext, Some(crate.span)),
- IdentTT(ext, _) => IdentTT(ext, Some(crate.span)),
+ NormalTT(ext, _) => NormalTT(ext, Some(krate.span)),
+ IdentTT(ext, _) => IdentTT(ext, Some(krate.span)),
ItemDecorator(ext) => ItemDecorator(ext),
};
fld.extsbox.insert(name, extension);
}
}
- //fn fake_print_crate(crate: &ast::Crate) {
+ //fn fake_print_crate(krate: &ast::Crate) {
// let mut out = ~std::io::stderr() as ~std::io::Writer;
// let mut s = pprust::rust_printer(out, get_ident_interner());
- // pprust::print_crate_(&mut s, crate);
+ // pprust::print_crate_(&mut s, krate);
//}
fn expand_crate_str(crate_str: ~str) -> ast::Crate {
}
pub fn find_macro_registrar(diagnostic: @diagnostic::SpanHandler,
-
crate: &ast::Crate) -> Option<ast::DefId> {
+
krate: &ast::Crate) -> Option<ast::DefId> {
let mut ctx = MacroRegistrarContext { registrars: ~[] };
- visit::walk_crate(&mut ctx, crate, ());
+ visit::walk_crate(&mut ctx, krate, ());
match ctx.registrars.len() {
0 => None,
1 => {
let (node_id, _) = ctx.registrars.pop().unwrap();
Some(ast::DefId {
- crate: ast::LOCAL_CRATE,
+ krate: ast::LOCAL_CRATE,
node: node_id
})
},
// this version doesn't care about getting comments or docstrings in.
fn fake_print_crate(s: &mut pprust::State,
- crate: &ast::Crate) -> io::IoResult<()> {
- pprust::print_mod(s, &crate.module, crate.attrs)
+ krate: &ast::Crate) -> io::IoResult<()> {
+ pprust::print_mod(s, &krate.module, krate.attrs)
}
// change every identifier to "zz"
pub fn print_crate(cm: @CodeMap,
intr: @IdentInterner,
span_diagnostic: @diagnostic::SpanHandler,
- crate: &ast::Crate,
+ krate: &ast::Crate,
filename: ~str,
input: &mut io::Reader,
out: ~io::Writer,
boxes: RefCell::new(~[]),
ann: ann
};
- print_crate_(&mut s, crate)
+ print_crate_(&mut s, krate)
}
-pub fn print_crate_(s: &mut State, crate: &ast::Crate) -> io::IoResult<()> {
- if_ok!(print_mod(s, &crate.module, crate.attrs));
+pub fn print_crate_(s: &mut State, krate: &ast::Crate) -> io::IoResult<()> {
+ if_ok!(print_mod(s, &krate.module, krate.attrs));
if_ok!(print_remaining_comments(s));
if_ok!(eof(&mut s.s));
Ok(())
}
-pub fn walk_crate<E: Clone, V: Visitor<E>>(visitor: &mut V, crate: &Crate, env: E) {
- visitor.visit_mod(&crate.module, crate.span, CRATE_NODE_ID, env)
+pub fn walk_crate<E: Clone, V: Visitor<E>>(visitor: &mut V, krate: &Crate, env: E) {
+ visitor.visit_mod(&krate.module, krate.span, CRATE_NODE_ID, env)
}
pub fn walk_mod<E: Clone, V: Visitor<E>>(visitor: &mut V, module: &Mod, env: E) {
projects / rust.git / commitdiff