diff --git a/src/rustdoc/astsrv.rs b/src/rustdoc/astsrv.rs index e39393bfa13..cb081c00d36 100644 --- a/src/rustdoc/astsrv.rs +++ b/src/rustdoc/astsrv.rs @@ -20,8 +20,6 @@ import syntax::ast_map; import rustc::back::link; import rustc::metadata::filesearch; import rustc::front; -import rustc::middle::resolve; -import rustc::middle::resolve3; export ctxt; export ctxt_handler; @@ -32,9 +30,7 @@ export exec; type ctxt = { ast: @ast::crate, - ast_map: ast_map::map, - exp_map: resolve::exp_map, - impl_map: resolve::impl_map + ast_map: ast_map::map }; type srv_owner = fn(srv: srv) -> T; @@ -72,12 +68,11 @@ fn run(owner: srv_owner, source: ~str, +parse: parser) -> T { } fn act(po: comm::port, source: ~str, parse: parser) { - let (sess, ignore_errors) = build_session(); + let sess = build_session(); let ctxt = build_ctxt( sess, - parse(sess, source), - ignore_errors + parse(sess, source) ); let mut keep_going = true; @@ -107,41 +102,34 @@ fn exec( } fn build_ctxt(sess: session, - ast: @ast::crate, - ignore_errors: @mut bool) -> ctxt { + ast: @ast::crate) -> ctxt { import rustc::front::config; let ast = config::strip_unconfigured_items(ast); let ast = front::test::modify_for_testing(sess, ast); let ast_map = ast_map::map_crate(sess.diagnostic(), *ast); - *ignore_errors = true; - let {exp_map, impl_map, _} = resolve3::resolve_crate(sess, ast_map, ast); - *ignore_errors = false; { ast: ast, ast_map: ast_map, - exp_map: exp_map, - impl_map: impl_map } } -fn build_session() -> (session, @mut bool) { +fn build_session() -> session { let sopts: @options = basic_options(); let codemap = codemap::new_codemap(); let error_handlers = build_error_handlers(codemap); - let {emitter, span_handler, ignore_errors} = error_handlers; + let {emitter, span_handler} = error_handlers; let session = driver::build_session_(sopts, codemap, emitter, span_handler); - (session, ignore_errors) + session } type error_handlers = { emitter: diagnostic::emitter, - span_handler: diagnostic::span_handler, - ignore_errors: @mut bool + span_handler: diagnostic::span_handler }; // Build a custom error handler that will allow us to ignore non-fatal @@ -152,16 +140,13 @@ fn build_error_handlers( type diagnostic_handler = { inner: diagnostic::handler, - ignore_errors: @mut bool }; impl of diagnostic::handler for diagnostic_handler { fn fatal(msg: ~str) -> ! { self.inner.fatal(msg) } fn err(msg: ~str) { self.inner.err(msg) } fn bump_err_count() { - if !(*self.ignore_errors) { - self.inner.bump_err_count(); - } + self.inner.bump_err_count(); } fn has_errors() -> bool { self.inner.has_errors() } fn abort_if_errors() { self.inner.abort_if_errors() } @@ -175,25 +160,20 @@ fn build_error_handlers( } } - let ignore_errors = @mut false; let emitter = fn@(cmsp: option<(codemap::codemap, codemap::span)>, msg: ~str, lvl: diagnostic::level) { - if !(*ignore_errors) { - diagnostic::emit(cmsp, msg, lvl); - } + diagnostic::emit(cmsp, msg, lvl); }; let inner_handler = diagnostic::mk_handler(some(emitter)); let handler = { inner: inner_handler, - ignore_errors: ignore_errors }; let span_handler = diagnostic::mk_span_handler( handler as diagnostic::handler, codemap); { emitter: emitter, - span_handler: span_handler, - ignore_errors: ignore_errors + span_handler: span_handler } } @@ -217,48 +197,6 @@ fn srv_should_build_ast_map() { } } -#[test] -fn srv_should_build_reexport_map() { - let source = ~"import a::b; export b; mod a { mod b { } }"; - do from_str(source) |srv| { - do exec(srv) |ctxt| { - assert ctxt.exp_map.size() != 0u - }; - } -} - -#[test] -fn srv_should_resolve_external_crates() { - let source = ~"use std;\ - fn f() -> std::sha1::sha1 {\ - std::sha1::mk_sha1() }"; - // Just testing that resolve doesn't crash - from_str(source, |_srv| { } ) -} - -#[test] -fn srv_should_resolve_core_crate() { - let source = ~"fn a() -> option { fail }"; - // Just testing that resolve doesn't crash - from_str(source, |_srv| { } ) -} - -#[test] -fn srv_should_resolve_non_existant_imports() { - // XXX: XFAIL'd - - // We want to ignore things we can't resolve. Shouldn't - // need to be able to find external crates to create docs. - //let source = ~"import wooboo; fn a() { }"; - //from_str(source, |_srv| { } ) -} - -#[test] -fn srv_should_resolve_non_existant_uses() { - let source = ~"use forble; fn a() { }"; - from_str(source, |_srv| { } ) -} - #[test] fn should_ignore_external_import_paths_that_dont_exist() { let source = ~"use forble; import forble::bippy;"; diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs deleted file mode 100644 index 03d8a3de127..00000000000 --- a/src/rustdoc/prune_unexported_pass.rs +++ /dev/null @@ -1,247 +0,0 @@ -//! Prunes branches of the tree that are not exported - -import doc::item_utils; -import syntax::ast; -import syntax::ast_util; -import syntax::ast_map; -import std::map::hashmap; - -export mk_pass; - -fn mk_pass() -> pass { - { - name: ~"prune_unexported", - f: run - } -} - -fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc { - let fold = fold::fold({ - fold_mod: fold_mod - with *fold::default_any_fold(srv) - }); - fold.fold_doc(fold, doc) -} - -fn fold_mod(fold: fold::fold, doc: doc::moddoc) -> doc::moddoc { - let doc = fold::default_any_fold_mod(fold, doc); - doc::moddoc_({ - items: exported_items(fold.ctxt, doc) - with *doc - }) -} - -fn exported_items(srv: astsrv::srv, doc: doc::moddoc) -> ~[doc::itemtag] { - exported_things( - srv, doc, - exported_items_from_crate, - exported_items_from_mod - ) -} - -fn exported_things( - srv: astsrv::srv, - doc: doc::moddoc, - from_crate: fn(astsrv::srv, doc::moddoc) -> ~[T], - from_mod: fn(astsrv::srv, doc::moddoc) -> ~[T] -) -> ~[T] { - if doc.id() == ast::crate_node_id { - from_crate(srv, doc) - } else { - from_mod(srv, doc) - } -} - -fn exported_items_from_crate( - srv: astsrv::srv, - doc: doc::moddoc -) -> ~[doc::itemtag] { - exported_items_from(srv, doc, is_exported_from_crate) -} - -fn exported_items_from_mod( - srv: astsrv::srv, - doc: doc::moddoc -) -> ~[doc::itemtag] { - exported_items_from(srv, doc, |a,b| { - is_exported_from_mod(a, doc.id(), b) - }) -} - -fn exported_items_from( - srv: astsrv::srv, - doc: doc::moddoc, - is_exported: fn(astsrv::srv, ~str) -> bool -) -> ~[doc::itemtag] { - do vec::filter_map(doc.items) |itemtag| { - let itemtag = alt itemtag { - doc::enumtag(enumdoc) { - // Also need to check variant exportedness - doc::enumtag({ - variants: exported_variants_from(srv, enumdoc, is_exported) - with enumdoc - }) - } - _ { itemtag } - }; - - if itemtag.item().reexport || is_exported(srv, itemtag.name()) { - some(itemtag) - } else { - none - } - } -} - -fn exported_variants_from( - srv: astsrv::srv, - doc: doc::enumdoc, - is_exported: fn(astsrv::srv, ~str) -> bool -) -> ~[doc::variantdoc] { - do vec::filter_map(doc.variants) |doc| { - if is_exported(srv, doc.name) { - some(doc) - } else { - none - } - } -} - -fn is_exported_from_mod( - srv: astsrv::srv, - mod_id: doc::ast_id, - item_name: ~str -) -> bool { - do astsrv::exec(srv) |ctxt| { - alt ctxt.ast_map.get(mod_id) { - ast_map::node_item(item, _) { - alt item.node { - ast::item_mod(m) { - ast_util::is_exported(@item_name, m) - } - _ { - fail ~"is_exported_from_mod: not a mod"; - } - } - } - _ { fail ~"is_exported_from_mod: not an item"; } - } - } -} - -fn is_exported_from_crate( - srv: astsrv::srv, - item_name: ~str -) -> bool { - do astsrv::exec(srv) |ctxt| { - ast_util::is_exported(@item_name, ctxt.ast.node.module) - } -} - -#[test] -fn should_prune_unexported_fns() { - let doc = test::mk_doc(~"mod b { export a; fn a() { } fn b() { } }"); - assert vec::len(doc.cratemod().mods()[0].fns()) == 1u; -} - -#[test] -fn should_prune_unexported_fns_from_top_mod() { - let doc = test::mk_doc(~"export a; fn a() { } fn b() { }"); - assert vec::len(doc.cratemod().fns()) == 1u; -} - -#[test] -fn should_prune_unexported_modules() { - let doc = test::mk_doc(~"mod a { export a; mod a { } mod b { } }"); - assert vec::len(doc.cratemod().mods()[0].mods()) == 1u; -} - -#[test] -fn should_prune_unexported_modules_from_top_mod() { - let doc = test::mk_doc(~"export a; mod a { } mod b { }"); - assert vec::len(doc.cratemod().mods()) == 1u; -} - -#[test] -fn should_prune_unexported_consts() { - let doc = test::mk_doc( - ~"mod a { export a; \ - const a: bool = true; \ - const b: bool = true; }"); - assert vec::len(doc.cratemod().mods()[0].consts()) == 1u; -} - -#[test] -fn should_prune_unexported_consts_from_top_mod() { - let doc = test::mk_doc( - ~"export a; const a: bool = true; const b: bool = true;"); - assert vec::len(doc.cratemod().consts()) == 1u; -} - -#[test] -fn should_prune_unexported_enums_from_top_mod() { - let doc = test::mk_doc(~"export a; mod a { } enum b { c }"); - assert vec::len(doc.cratemod().enums()) == 0u; -} - -#[test] -fn should_prune_unexported_enums() { - let doc = test::mk_doc(~"mod a { export a; mod a { } enum b { c } }"); - assert vec::len(doc.cratemod().mods()[0].enums()) == 0u; -} - -#[test] -fn should_prune_unexported_variants_from_top_mod() { - let doc = test::mk_doc(~"export b::{}; enum b { c }"); - assert vec::len(doc.cratemod().enums()[0].variants) == 0u; -} - -#[test] -fn should_prune_unexported_variants() { - let doc = test::mk_doc(~"mod a { export b::{}; enum b { c } }"); - assert vec::len(doc.cratemod().mods()[0].enums()[0].variants) == 0u; -} - -#[test] -fn should_prune_unexported_traits_from_top_mod() { - let doc = test::mk_doc(~"export a; mod a { } iface b { fn c(); }"); - assert vec::is_empty(doc.cratemod().traits()); -} - -#[test] -fn should_prune_unexported_impls_from_top_mod() { - let doc = test::mk_doc( - ~"export a; mod a { } impl b for int { fn c() { } }"); - assert vec::is_empty(doc.cratemod().impls()) -} - -#[test] -fn should_prune_unexported_types() { - let doc = test::mk_doc(~"export a; mod a { } type b = int;"); - assert vec::is_empty(doc.cratemod().types()); -} - -#[test] -fn should_not_prune_reexports() { - fn mk_doc(source: ~str) -> doc::doc { - do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ~""); - let doc = reexport_pass::mk_pass().f(srv, doc); - run(srv, doc) - } - } - let doc = mk_doc(~"import a::b; \ - export b; \ - mod a { fn b() { } }"); - assert vec::is_not_empty(doc.cratemod().fns()); -} - -#[cfg(test)] -mod test { - fn mk_doc(source: ~str) -> doc::doc { - do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ~""); - run(srv, doc) - } - } -} diff --git a/src/rustdoc/reexport_pass.rs b/src/rustdoc/reexport_pass.rs deleted file mode 100644 index 29f76d16225..00000000000 --- a/src/rustdoc/reexport_pass.rs +++ /dev/null @@ -1,528 +0,0 @@ -//! Finds docs for reexported items and duplicates them - -import doc::item_utils; -import std::map; -import std::map::hashmap; -import std::list; -import syntax::ast; -import syntax::ast_util; -import syntax::ast_map; -import syntax::visit; -import syntax::codemap; -import rustc::middle::resolve; - -export mk_pass; - -fn mk_pass() -> pass { - { - name: ~"reexport", - f: run - } -} - -type def_set = map::set; -type def_map = map::hashmap; -type path_map = map::hashmap<~str, ~[(~str, doc::itemtag)]>; - -fn run(srv: astsrv::srv, doc: doc::doc) -> doc::doc { - - // First gather the set of defs that are used as reexports - let def_set = build_reexport_def_set(srv); - - // Now find the docs that go with those defs - let def_map = build_reexport_def_map(srv, doc, def_set); - - // Now create a map that tells us where to insert the duplicated - // docs into the existing doc tree - let path_map = build_reexport_path_map(srv, def_map); - - // Finally update the doc tree - merge_reexports(doc, path_map) -} - -// Hash maps are not sendable so converting them back and forth -// to association lists. Yuck. -fn to_assoc_list( - map: map::hashmap -) -> ~[(K, V)] { - - let mut vec = ~[]; - for map.each |k, v| { - vec += ~[(k, v)]; - } - ret vec; -} - -fn from_assoc_list( - list: ~[(K, V)], - new_hash: fn() -> map::hashmap -) -> map::hashmap { - - let map = new_hash(); - do vec::iter(list) |elt| { - let (k, v) = elt; - map.insert(k, v); - } - ret map; -} - -fn from_def_assoc_list( - list: ~[(ast::def_id, V)] -) -> map::hashmap { - from_assoc_list(list, ast_util::new_def_hash) -} - -fn from_str_assoc_list( - list: ~[(~str, V)] -) -> map::hashmap<~str, V> { - from_assoc_list(list, map::str_hash) -} - -fn build_reexport_def_set(srv: astsrv::srv) -> def_set { - let assoc_list = do astsrv::exec(srv) |ctxt| { - let def_set = ast_util::new_def_hash(); - for ctxt.exp_map.each |_id, defs| { - for defs.each |def| { - if def.reexp { - def_set.insert(def.id, ()); - } - } - } - for find_reexport_impls(ctxt).each |def| { - def_set.insert(def, ()); - } - to_assoc_list(def_set) - }; - - from_def_assoc_list(assoc_list) -} - -fn find_reexport_impls(ctxt: astsrv::ctxt) -> ~[ast::def_id] { - let defs = @mut ~[]; - do for_each_reexported_impl(ctxt) |_mod_id, i| { - *defs += ~[i.did] - } - ret *defs; -} - -fn build_reexport_def_map( - srv: astsrv::srv, - doc: doc::doc, - def_set: def_set -) -> def_map { - - type ctxt = { - srv: astsrv::srv, - def_set: def_set, - def_map: def_map - }; - - let ctxt = { - srv: srv, - def_set: def_set, - def_map: ast_util::new_def_hash() - }; - - // FIXME: Do a parallel fold (#2597) - let fold = fold::fold({ - fold_mod: fold_mod, - fold_nmod: fold_nmod - with *fold::default_seq_fold(ctxt) - }); - - fold.fold_doc(fold, doc); - - ret ctxt.def_map; - - fn fold_mod(fold: fold::fold, doc: doc::moddoc) -> doc::moddoc { - let doc = fold::default_seq_fold_mod(fold, doc); - - for doc.items.each |item| { - let def_id = ast_util::local_def(item.id()); - if fold.ctxt.def_set.contains_key(def_id) { - fold.ctxt.def_map.insert(def_id, item); - } - } - - ret doc; - } - - fn fold_nmod(fold: fold::fold, doc: doc::nmoddoc) -> doc::nmoddoc { - let doc = fold::default_seq_fold_nmod(fold, doc); - - for doc.fns.each |fndoc| { - let def_id = ast_util::local_def(fndoc.id()); - if fold.ctxt.def_set.contains_key(def_id) { - fold.ctxt.def_map.insert(def_id, doc::fntag(fndoc)); - } - } - - ret doc; - } -} - -fn build_reexport_path_map(srv: astsrv::srv, -def_map: def_map) -> path_map { - - // This is real unfortunate. Lots of copying going on here - let def_assoc_list = to_assoc_list(def_map); - #debug("def_map: %?", def_assoc_list); - - let assoc_list = do astsrv::exec(srv) |ctxt| { - - let def_map = from_def_assoc_list(def_assoc_list); - let path_map = map::str_hash::<~[(~str,doc::itemtag)]>(); - - for ctxt.exp_map.each |exp_id, defs| { - let path = alt check ctxt.ast_map.get(exp_id) { - ast_map::node_export(_, path) { path } - }; - // should be a constraint on the node_export constructor - // that guarantees path is non-empty - let name = alt check vec::last(*path) { - ast_map::path_name(nm) { nm } - }; - let modpath = ast_map::path_to_str(vec::init(*path)); - - let mut reexportdocs = ~[]; - for defs.each |def| { - if !def.reexp { again; } - alt def_map.find(def.id) { - some(itemtag) { - reexportdocs += ~[(*name, itemtag)]; - } - _ {} - } - } - - if reexportdocs.len() > 0u { - do option::iter(path_map.find(modpath)) |docs| { - reexportdocs = docs + vec::filter(reexportdocs, |x| { - !vec::contains(docs, x) - }); - } - path_map.insert(modpath, reexportdocs); - #debug("path_map entry: %? - %?", - modpath, (name, reexportdocs)); - } - } - - for find_reexport_impl_docs(ctxt, def_map).each |elt| { - let (path, doc) = elt; - let docs = alt path_map.find(path) { - some(docs) { docs + ~[(doc)] } - none { ~[doc] } - }; - path_map.insert(path, docs); - } - - to_assoc_list(path_map) - }; - - from_str_assoc_list(assoc_list) -} - -fn find_reexport_impl_docs( - ctxt: astsrv::ctxt, - def_map: def_map -) -> ~[(~str, (~str, doc::itemtag))] { - let docs = @mut ~[]; - - do for_each_reexported_impl(ctxt) |mod_id, i| { - let path = alt ctxt.ast_map.find(mod_id) { - some(ast_map::node_item(item, path)) { - let path = ast_map::path_to_str(*path); - if str::is_empty(path) { - *item.ident - } else { - path + ~"::" + *item.ident - } - } - _ { - assert mod_id == ast::crate_node_id; - ~"" - } - }; - let ident = *i.ident; - let doc = alt check def_map.find(i.did) { - some(doc) { doc } - }; - *docs += ~[(path, (ident, doc))]; - } - - ret *docs; -} - -fn for_each_reexported_impl( - ctxt: astsrv::ctxt, - f: fn@(ast::node_id, resolve::_impl) -) { - let visitor = @{ - visit_mod: |a,b,c| visit_mod(ctxt, f, a, b, c) - with *visit::default_simple_visitor() - }; - let visitor = visit::mk_simple_visitor(visitor); - visit::visit_crate(*ctxt.ast, (), visitor); - - fn visit_mod( - ctxt: astsrv::ctxt, - f: fn@(ast::node_id, resolve::_impl), - m: ast::_mod, - _sp: codemap::span, - mod_id: ast::node_id - ) { - let all_impls = all_impls(m); - alt *ctxt.impl_map.get(mod_id) { - list::cons(impls, _) { - for vec::each(*impls) |i| { - // This impl is not an item in the current mod - if !all_impls.contains_key(i.did) { - // Ignore external impls because I don't - // know what to do with them yet - if i.did.crate == ast::local_crate { - f(mod_id, *i); - } - } - } - } - list::nil { - // Do nothing -- mod has no impls - } - } - } -} - -fn all_impls(m: ast::_mod) -> map::set { - let all_impls = ast_util::new_def_hash(); - for m.items.each |item| { - alt item.node { - ast::item_impl(_, _, _, _) { - all_impls.insert(ast_util::local_def(item.id), ()); - } - _ { } - } - } - ret all_impls; -} - -fn merge_reexports( - doc: doc::doc, - path_map: path_map -) -> doc::doc { - - let fold = fold::fold({ - fold_mod: fold_mod - with *fold::default_seq_fold(path_map) - }); - - ret fold.fold_doc(fold, doc); - - fn fold_mod(fold: fold::fold, doc: doc::moddoc) -> doc::moddoc { - let doc = fold::default_seq_fold_mod(fold, doc); - - let is_topmod = doc.id() == ast::crate_node_id; - - // In the case of the top mod, it really doesn't have a name; - // the name we have here is actually the crate name - let path = if is_topmod { - doc.path() - } else { - doc.path() + ~[doc.name()] - }; - - let new_items = get_new_items(path, fold.ctxt); - #debug("merging into %?: %?", path, new_items); - - doc::moddoc_({ - items: (doc.items + new_items) - with *doc - }) - } - - fn get_new_items(path: ~[~str], path_map: path_map) -> ~[doc::itemtag] { - #debug("looking for reexports in path %?", path); - alt path_map.find(str::connect(path, ~"::")) { - some(name_docs) { - do vec::foldl(~[], name_docs) |v, name_doc| { - let (name, doc) = name_doc; - v + ~[reexport_doc(doc, name)] - } - } - none { ~[] } - } - } - - fn reexport_doc(doc: doc::itemtag, name: ~str) -> doc::itemtag { - alt doc { - doc::modtag(doc @ doc::moddoc_({item, _})) { - doc::modtag(doc::moddoc_({ - item: reexport(item, name) - with *doc - })) - } - doc::nmodtag(_) { fail } - doc::consttag(doc @ {item, _}) { - doc::consttag({ - item: reexport(item, name) - with doc - }) - } - doc::fntag(doc @ {item, _}) { - doc::fntag({ - item: reexport(item, name) - with doc - }) - } - doc::enumtag(doc @ {item, _}) { - doc::enumtag({ - item: reexport(item, name) - with doc - }) - } - doc::traittag(doc @ {item, _}) { - doc::traittag({ - item: reexport(item, name) - with doc - }) - } - doc::impltag(doc @ {item, _}) { - doc::impltag({ - item: reexport(item, name) - with doc - }) - } - doc::tytag(doc @ {item, _}) { - doc::tytag({ - item: reexport(item, name) - with doc - }) - } - } - } - - fn reexport(doc: doc::itemdoc, name: ~str) -> doc::itemdoc { - { - name: name, - reexport: true - with doc - } - } -} - -#[test] -fn should_duplicate_reexported_items() { - let source = ~"mod a { export b; fn b() { } } \ - mod c { import a::b; export b; }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].fns()[0].name() == ~"b"; -} - -#[test] -fn should_mark_reepxorts_as_such() { - let source = ~"mod a { export b; fn b() { } } \ - mod c { import a::b; export b; }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].fns()[0].item.reexport == true; -} - -#[test] -fn should_duplicate_reexported_impls() { - let source = ~"mod a { impl b for int { fn c() { } } } \ - mod d { import a::b; export b; }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].impls()[0].name() == ~"b"; -} - -#[test] -fn should_duplicate_reexported_impls_deep() { - let source = ~"mod a { impl b for int { fn c() { } } } \ - mod d { mod e { import a::b; export b; } }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].mods()[0].impls()[0].name() == ~"b"; -} - -#[test] -fn should_duplicate_reexported_impls_crate() { - let source = ~"import a::b; export b; \ - mod a { impl b for int { fn c() { } } }"; - let doc = test::mk_doc(source); - assert doc.cratemod().impls()[0].name() == ~"b"; -} - -#[test] -fn should_duplicate_reexported_foreign_fns() { - let source = ~"extern mod a { fn b(); } \ - mod c { import a::b; export b; }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[0].fns()[0].name() == ~"b"; -} - -#[test] -fn should_duplicate_multiple_reexported_items() { - let source = ~"mod a { \ - export b; export c; \ - fn b() { } fn c() { } \ - } \ - mod d { \ - import a::b; import a::c; \ - export b; export c; \ - }"; - do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ~""); - let doc = path_pass::mk_pass().f(srv, doc); - let doc = run(srv, doc); - // Reexports may not be in any specific order - let doc = sort_item_name_pass::mk_pass().f(srv, doc); - assert doc.cratemod().mods()[1].fns()[0].name() == ~"b"; - assert doc.cratemod().mods()[1].fns()[1].name() == ~"c"; - } -} - -#[test] -fn should_rename_items_reexported_with_different_names() { - let source = ~"mod a { export b; fn b() { } } \ - mod c { import x = a::b; export x; }"; - let doc = test::mk_doc(source); - assert doc.cratemod().mods()[1].fns()[0].name() == ~"x"; -} - -#[test] -fn should_reexport_in_topmod() { - fn mk_doc(source: ~str) -> doc::doc { - do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ~"core"); - let doc = path_pass::mk_pass().f(srv, doc); - run(srv, doc) - } - } - let source = ~"import option::{some, none}; \ - import option = option::t; \ - export option, some, none; \ - mod option { \ - enum t { some, none } \ - }"; - let doc = mk_doc(source); - assert doc.cratemod().enums()[0].name() == ~"option"; -} - -#[test] -fn should_not_reexport_multiple_times() { - let source = ~"import option = option::t; \ - export option; \ - export option; \ - mod option { \ - enum t { none, some } \ - }"; - let doc = test::mk_doc(source); - assert vec::len(doc.cratemod().enums()) == 1u; -} - -#[cfg(test)] -mod test { - fn mk_doc(source: ~str) -> doc::doc { - do astsrv::from_str(source) |srv| { - let doc = extract::from_srv(srv, ~""); - let doc = path_pass::mk_pass().f(srv, doc); - run(srv, doc) - } - } -} diff --git a/src/rustdoc/rustdoc.rc b/src/rustdoc/rustdoc.rc index 8a16e90cd67..36067b2db6f 100644 --- a/src/rustdoc/rustdoc.rc +++ b/src/rustdoc/rustdoc.rc @@ -33,7 +33,6 @@ mod fold; mod path_pass; mod attr_pass; mod tystr_pass; -mod prune_unexported_pass; mod prune_hidden_pass; mod desc_to_brief_pass; mod text_pass; @@ -44,7 +43,6 @@ mod demo; mod sort_pass; mod sort_item_name_pass; mod sort_item_type_pass; -mod reexport_pass; mod page_pass; mod sectionalize_pass; mod escape_pass; diff --git a/src/rustdoc/rustdoc.rs b/src/rustdoc/rustdoc.rs index 21db670f781..7a23dbd9d9d 100755 --- a/src/rustdoc/rustdoc.rs +++ b/src/rustdoc/rustdoc.rs @@ -139,8 +139,6 @@ fn run(config: config::config) { extract::from_srv(srv, default_name) }); run_passes(srv, doc, ~[ - reexport_pass::mk_pass(), - prune_unexported_pass::mk_pass(), tystr_pass::mk_pass(), path_pass::mk_pass(), attr_pass::mk_pass(),