rustdoc: Hyperlink cross-crate reexports

This should improve the libcore experience quite a bit when looking at the
libstd documentation.

src/librustdoc/clean.rs

@@ -670,15 +670,7 @@ pub enum Type {
     ResolvedPath {
         pub path: Path,
         pub typarams: Option<Vec<TyParamBound>>,
-        pub id: ast::NodeId,
-    },
-    /// Same as above, but only external variants
-    ExternalPath {
-        pub path: Path,
-        pub typarams: Option<Vec<TyParamBound>>,
-        pub fqn: Vec<~str>,
-        pub kind: TypeKind,
-        pub krate: ast::CrateNum,
+        pub did: ast::DefId,
     },
     // I have no idea how to usefully use this.
     TyParamBinder(ast::NodeId),
@@ -715,19 +707,18 @@ pub enum Type {
 
 #[deriving(Clone, Encodable, Decodable)]
 pub enum TypeKind {
-    TypeStruct,
     TypeEnum,
-    TypeTrait,
     TypeFunction,
+    TypeModule,
+    TypeStatic,
+    TypeStruct,
+    TypeTrait,
+    TypeVariant,
 }
 
 impl Clean<Type> for ast::Ty {
     fn clean(&self) -> Type {
         use syntax::ast::*;
-        debug!("cleaning type `{:?}`", self);
-        let ctxt = super::ctxtkey.get().unwrap();
-        let codemap = ctxt.sess().codemap();
-        debug!("span corresponds to `{}`", codemap.span_to_str(self.span));
         match self.node {
             TyNil => Unit,
             TyPtr(ref m) => RawPointer(m.mutbl.clean(), box m.ty.clean()),
@@ -1153,7 +1144,7 @@ pub enum ViewPath {
     // use source::*;
     GlobImport(ImportSource),
     // use source::{a, b, c};
-    ImportList(ImportSource, Vec<ViewListIdent> ),
+    ImportList(ImportSource, Vec<ViewListIdent>),
 }
 
 #[deriving(Clone, Encodable, Decodable)]
@@ -1298,48 +1289,47 @@ fn resolve_type(path: Path, tpbs: Option<Vec<TyParamBound> >,
         core::NotTyped(_) => return Bool
     };
     debug!("searching for {:?} in defmap", id);
-    let d = match tycx.def_map.borrow().find(&id) {
+    let def = match tycx.def_map.borrow().find(&id) {
         Some(&k) => k,
-        None => {
-            debug!("could not find {:?} in defmap (`{}`)", id, tycx.map.node_to_str(id));
-            fail!("Unexpected failure: unresolved id not in defmap (this is a bug!)")
-        }
+        None => fail!("unresolved id not in defmap")
     };
 
-    let (def_id, kind) = match d {
-        ast::DefFn(i, _) => (i, TypeFunction),
+    match def {
         ast::DefSelfTy(i) => return Self(i),
-        ast::DefTy(i) => (i, TypeEnum),
-        ast::DefTrait(i) => {
-            debug!("saw DefTrait in def_to_id");
-            (i, TypeTrait)
-        },
         ast::DefPrimTy(p) => match p {
             ast::TyStr => return String,
             ast::TyBool => return Bool,
             _ => return Primitive(p)
         },
         ast::DefTyParam(i, _) => return Generic(i.node),
+        ast::DefTyParamBinder(i) => return TyParamBinder(i),
+        _ => {}
+    };
+    let did = register_def(&**cx, def);
+    ResolvedPath { path: path, typarams: tpbs, did: did }
+}
+
+fn register_def(cx: &core::DocContext, def: ast::Def) -> ast::DefId {
+    let (did, kind) = match def {
+        ast::DefFn(i, _) => (i, TypeFunction),
+        ast::DefTy(i) => (i, TypeEnum),
+        ast::DefTrait(i) => (i, TypeTrait),
         ast::DefStruct(i) => (i, TypeStruct),
-        ast::DefTyParamBinder(i) => {
-            debug!("found a typaram_binder, what is it? {}", i);
-            return TyParamBinder(i);
-        },
-        x => fail!("resolved type maps to a weird def {:?}", x),
+        ast::DefMod(i) => (i, TypeModule),
+        ast::DefStatic(i, _) => (i, TypeStatic),
+        ast::DefVariant(i, _, _) => (i, TypeEnum),
+        _ => return ast_util::def_id_of_def(def),
     };
-    if ast_util::is_local(def_id) {
-        ResolvedPath{ path: path, typarams: tpbs, id: def_id.node }
-    } else {
-        let fqn = csearch::get_item_path(tycx, def_id);
-        let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
-        ExternalPath {
-            path: path,
-            typarams: tpbs,
-            fqn: fqn,
-            kind: kind,
-            krate: def_id.krate,
-        }
-    }
+    if ast_util::is_local(did) { return did }
+    let tcx = match cx.maybe_typed {
+        core::Typed(ref t) => t,
+        core::NotTyped(_) => return did
+    };
+    let fqn = csearch::get_item_path(tcx, did);
+    let fqn = fqn.move_iter().map(|i| i.to_str()).collect();
+    debug!("recording {} => {}", did, fqn);
+    cx.external_paths.borrow_mut().get_mut_ref().insert(did, (fqn, kind));
+    return did;
 }
 
 fn resolve_use_source(path: Path, id: ast::NodeId) -> ImportSource {
@@ -1353,7 +1343,7 @@ fn resolve_def(id: ast::NodeId) -> Option<ast::DefId> {
     let cx = super::ctxtkey.get().unwrap();
     match cx.maybe_typed {
         core::Typed(ref tcx) => {
-            tcx.def_map.borrow().find(&id).map(|&d| ast_util::def_id_of_def(d))
+            tcx.def_map.borrow().find(&id).map(|&def| register_def(&**cx, def))
         }
         core::NotTyped(_) => None
     }

src/librustdoc/core.rs

@@ -20,7 +20,7 @@
 
 use std::cell::RefCell;
 use std::os;
-use collections::HashSet;
+use collections::{HashSet, HashMap};
 
 use visit_ast::RustdocVisitor;
 use clean;
@@ -31,10 +31,14 @@ pub enum MaybeTyped {
     NotTyped(driver::session::Session)
 }
 
+pub type ExternalPaths = RefCell<Option<HashMap<ast::DefId,
+                                                (Vec<~str>, clean::TypeKind)>>>;
+
 pub struct DocContext {
     pub krate: ast::Crate,
     pub maybe_typed: MaybeTyped,
     pub src: Path,
+    pub external_paths: ExternalPaths,
 }
 
 impl DocContext {
@@ -49,6 +53,7 @@ pub fn sess<'a>(&'a self) -> &'a driver::session::Session {
 pub struct CrateAnalysis {
     pub exported_items: privacy::ExportedItems,
     pub public_items: privacy::PublicItems,
+    pub external_paths: ExternalPaths,
 }
 
 /// Parses, resolves, and typechecks the given crate
@@ -98,9 +103,11 @@ fn get_ast_and_resolve(cpath: &Path, libs: HashSet<Path>, cfgs: Vec<~str>)
         krate: krate,
         maybe_typed: Typed(ty_cx),
         src: cpath.clone(),
+        external_paths: RefCell::new(Some(HashMap::new())),
     }, CrateAnalysis {
         exported_items: exported_items,
         public_items: public_items,
+        external_paths: RefCell::new(None),
     })
 }
 
@@ -116,5 +123,7 @@ pub fn run_core(libs: HashSet<Path>, cfgs: Vec<~str>, path: &Path)
         v.clean()
     };
 
+    let external_paths = ctxt.external_paths.borrow_mut().take();
+    *analysis.external_paths.borrow_mut() = external_paths;
     (krate, analysis)
 }

src/librustdoc/html/format.rs

@@ -146,41 +146,28 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 
 /// Used when rendering a `ResolvedPath` structure. This invokes the `path`
 /// rendering function with the necessary arguments for linking to a local path.
-fn resolved_path(w: &mut io::Writer, id: ast::NodeId, p: &clean::Path,
+fn resolved_path(w: &mut io::Writer, did: ast::DefId, p: &clean::Path,
                  print_all: bool) -> fmt::Result {
     path(w, p, print_all,
-        |_cache, loc| { Some("../".repeat(loc.len())) },
+        |cache, loc| {
+            if ast_util::is_local(did) {
+                Some("../".repeat(loc.len()))
+            } else {
+                match *cache.extern_locations.get(&did.krate) {
+                    render::Remote(ref s) => Some(s.clone()),
+                    render::Local => Some("../".repeat(loc.len())),
+                    render::Unknown => None,
+                }
+            }
+        },
         |cache| {
-            match cache.paths.find(&id) {
+            match cache.paths.find(&did) {
                 None => None,
                 Some(&(ref fqp, shortty)) => Some((fqp.clone(), shortty))
             }
         })
 }
 
-/// Used when rendering an `ExternalPath` structure. Like `resolved_path` this
-/// 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,
-                 krate: ast::CrateNum) -> fmt::Result {
-    path(w, p, print_all,
-        |cache, loc| {
-            match *cache.extern_locations.get(&krate) {
-                render::Remote(ref s) => Some(s.clone()),
-                render::Local => Some("../".repeat(loc.len())),
-                render::Unknown => None,
-            }
-        },
-        |_cache| {
-            Some((Vec::from_slice(fqn), match kind {
-                clean::TypeStruct => item_type::Struct,
-                clean::TypeEnum => item_type::Enum,
-                clean::TypeFunction => item_type::Function,
-                clean::TypeTrait => item_type::Trait,
-            }))
-        })
-}
-
 fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
         root: |&render::Cache, &[~str]| -> Option<~str>,
         info: |&render::Cache| -> Option<(Vec<~str> , ItemType)>)
@@ -298,15 +285,9 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                 let m = cache_key.get().unwrap();
                 f.buf.write(m.typarams.get(&id).as_bytes())
             }
-            clean::ResolvedPath{id, typarams: ref tp, path: ref path} => {
-                try!(resolved_path(f.buf, id, path, false));
-                tybounds(f.buf, tp)
-            }
-            clean::ExternalPath{path: ref path, typarams: ref tp,
-                                fqn: ref fqn, kind, krate} => {
-                try!(external_path(f.buf, path, false, fqn.as_slice(), kind,
-                                     krate))
-                tybounds(f.buf, tp)
+            clean::ResolvedPath{ did, ref typarams, ref path} => {
+                try!(resolved_path(f.buf, did, path, false));
+                tybounds(f.buf, typarams)
             }
             clean::Self(..) => f.buf.write("Self".as_bytes()),
             clean::Primitive(prim) => {
@@ -543,10 +524,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 impl fmt::Show for clean::ImportSource {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.did {
-            // FIXME: shouldn't be restricted to just local imports
-            Some(did) if ast_util::is_local(did) => {
-                resolved_path(f.buf, did.node, &self.path, true)
-            }
+            Some(did) => resolved_path(f.buf, did, &self.path, true),
             _ => {
                 for (i, seg) in self.path.segments.iter().enumerate() {
                     if i > 0 {
@@ -563,8 +541,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
 impl fmt::Show for clean::ViewListIdent {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.source {
-            // FIXME: shouldn't be limited to just local imports
-            Some(did) if ast_util::is_local(did) => {
+            Some(did) => {
                 let path = clean::Path {
                     global: false,
                     segments: vec!(clean::PathSegment {
@@ -573,7 +550,7 @@ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
                         types: Vec::new(),
                     })
                 };
-                resolved_path(f.buf, did.node, &path, false)
+                resolved_path(f.buf, did, &path, false)
             }
             _ => write!(f.buf, "{}", self.name),
         }

src/librustdoc/html/render.rs

@@ -43,6 +43,7 @@
 use sync::Arc;
 use serialize::json::ToJson;
 use syntax::ast;
+use syntax::ast_util;
 use syntax::attr;
 use syntax::parse::token::InternedString;
 use rustc::util::nodemap::NodeSet;
@@ -50,13 +51,13 @@
 use clean;
 use doctree;
 use fold::DocFolder;
-use html::item_type;
-use html::item_type::{ItemType, shortty};
 use html::format::{VisSpace, Method, FnStyleSpace};
+use html::highlight;
+use html::item_type::{ItemType, shortty};
+use html::item_type;
 use html::layout;
-use html::markdown;
 use html::markdown::Markdown;
-use html::highlight;
+use html::markdown;
 
 /// Major driving force in all rustdoc rendering. This contains information
 /// about where in the tree-like hierarchy rendering is occurring and controls
@@ -138,7 +139,7 @@ pub struct Cache {
     /// URLs when a type is being linked to. External paths are not located in
     /// this map because the `External` type itself has all the information
     /// necessary.
-    pub paths: HashMap<ast::NodeId, (Vec<~str> , ItemType)>,
+    pub paths: HashMap<ast::DefId, (Vec<~str>, ItemType)>,
 
     /// This map contains information about all known traits of this crate.
     /// Implementations of a crate should inherit the documentation of the
@@ -242,12 +243,26 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
     }
 
     // Crawl the crate to build various caches used for the output
-    let public_items = ::analysiskey.get().map(|a| a.public_items.clone());
-    let public_items = public_items.unwrap_or(NodeSet::new());
+    let analysis = ::analysiskey.get();
+    let public_items = analysis.as_ref().map(|a| a.public_items.clone());
+    let paths = analysis.as_ref().map(|a| {
+        let paths = a.external_paths.borrow_mut().take_unwrap();
+        paths.move_iter().map(|(k, (v, t))| {
+            (k, (v, match t {
+                clean::TypeStruct => item_type::Struct,
+                clean::TypeEnum => item_type::Enum,
+                clean::TypeFunction => item_type::Function,
+                clean::TypeTrait => item_type::Trait,
+                clean::TypeModule => item_type::Module,
+                clean::TypeStatic => item_type::Static,
+                clean::TypeVariant => item_type::Variant,
+            }))
+        }).collect()
+    }).unwrap_or(HashMap::new());
     let mut cache = Cache {
         impls: HashMap::new(),
         typarams: HashMap::new(),
-        paths: HashMap::new(),
+        paths: paths,
         traits: HashMap::new(),
         implementors: HashMap::new(),
         stack: Vec::new(),
@@ -255,7 +270,7 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
         search_index: Vec::new(),
         extern_locations: HashMap::new(),
         privmod: false,
-        public_items: public_items,
+        public_items: public_items.unwrap_or(NodeSet::new()),
         orphan_methods: Vec::new(),
     };
     cache.stack.push(krate.name.clone());
@@ -269,15 +284,16 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
 
         // Attach all orphan methods to the type's definition if the type
         // has since been learned.
-        for &(ref pid, ref item) in meths.iter() {
-            match paths.find(pid) {
+        for &(pid, ref item) in meths.iter() {
+            let did = ast_util::local_def(pid);
+            match paths.find(&did) {
                 Some(&(ref fqp, _)) => {
                     index.push(IndexItem {
                         ty: shortty(item),
                         name: item.name.clone().unwrap(),
                         path: fqp.slice_to(fqp.len() - 1).connect("::"),
                         desc: shorter(item.doc_value()).to_owned(),
-                        parent: Some(*pid),
+                        parent: Some(pid),
                     });
                 },
                 None => {}
@@ -336,7 +352,8 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
         try!(write!(&mut w, r#"],"paths":["#));
 
         for (i, &nodeid) in pathid_to_nodeid.iter().enumerate() {
-            let &(ref fqp, short) = cache.paths.find(&nodeid).unwrap();
+            let def = ast_util::local_def(nodeid);
+            let &(ref fqp, short) = cache.paths.find(&def).unwrap();
             if i > 0 {
                 try!(write!(&mut w, ","));
             }
@@ -414,6 +431,8 @@ pub fn run(mut krate: clean::Crate, dst: Path) -> io::IoResult<()> {
 
     for &(n, ref e) in krate.externs.iter() {
         cache.extern_locations.insert(n, extern_location(e, &cx.dst));
+        let did = ast::DefId { krate: n, node: ast::CRATE_NODE_ID };
+        cache.paths.insert(did, (Vec::new(), item_type::Module));
     }
 
     // And finally render the whole crate's documentation
@@ -605,7 +624,12 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
         match item.inner {
             clean::ImplItem(ref i) => {
                 match i.trait_ {
-                    Some(clean::ResolvedPath{ id, .. }) => {
+                    // FIXME: this is_local() check seems to be losing
+                    // information
+                    Some(clean::ResolvedPath{ did, .. })
+                        if ast_util::is_local(did) =>
+                    {
+                        let id = did.node;
                         let v = self.implementors.find_or_insert_with(id, |_|{
                             Vec::new()
                         });
@@ -642,7 +666,8 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
                             (None, None)
                         } else {
                             let last = self.parent_stack.last().unwrap();
-                            let path = match self.paths.find(last) {
+                            let did = ast_util::local_def(*last);
+                            let path = match self.paths.find(&did) {
                                 Some(&(_, item_type::Trait)) =>
                                     Some(self.stack.slice_to(self.stack.len() - 1)),
                                 // The current stack not necessarily has correlation for
@@ -698,10 +723,11 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
                 // a reexported item doesn't show up in the `public_items` map,
                 // so we can skip inserting into the paths map if there was
                 // already an entry present and we're not a public item.
-                if !self.paths.contains_key(&item.id) ||
+                let did = ast_util::local_def(item.id);
+                if !self.paths.contains_key(&did) ||
                    self.public_items.contains(&item.id) {
-                    self.paths.insert(item.id,
-                                      (self.stack.clone(), shortty(&item)));
+                    self.paths.insert(did, (self.stack.clone(),
+                                            shortty(&item)));
                 }
             }
             // link variants to their parent enum because pages aren't emitted
@@ -709,7 +735,8 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
             clean::VariantItem(..) => {
                 let mut stack = self.stack.clone();
                 stack.pop();
-                self.paths.insert(item.id, (stack, item_type::Enum));
+                self.paths.insert(ast_util::local_def(item.id),
+                                  (stack, item_type::Enum));
             }
             _ => {}
         }
@@ -721,8 +748,13 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
             }
             clean::ImplItem(ref i) => {
                 match i.for_ {
-                    clean::ResolvedPath{ id, .. } => {
-                        self.parent_stack.push(id); true
+                    clean::ResolvedPath{ did, .. } => {
+                        if ast_util::is_local(did) {
+                            self.parent_stack.push(did.node);
+                            true
+                        } else {
+                            false
+                        }
                     }
                     _ => false
                 }
@@ -737,8 +769,10 @@ fn fold_item(&mut self, item: clean::Item) -> Option<clean::Item> {
                 match item {
                     clean::Item{ attrs, inner: clean::ImplItem(i), .. } => {
                         match i.for_ {
-                            clean::ResolvedPath { id, .. } => {
-                                let v = self.impls.find_or_insert_with(id, |_| {
+                            clean::ResolvedPath { did, .. }
+                                if ast_util::is_local(did) =>
+                            {
+                                let v = self.impls.find_or_insert_with(did.node, |_| {
                                     Vec::new()
                                 });
                                 // extract relevant documentation for this impl
@@ -1595,7 +1629,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
         Some(ref ty) => {
             try!(write!(w, "{} for ", *ty));
             match *ty {
-                clean::ResolvedPath { id, .. } => Some(id),
+                clean::ResolvedPath { did, .. } => Some(did),
                 _ => None,
             }
         }
@@ -1634,9 +1668,10 @@ fn docmeth(w: &mut Writer, item: &clean::Item,
     // default methods which weren't overridden in the implementation block.
     match trait_id {
         None => {}
-        Some(id) => {
+        // FIXME: this should work for non-local traits
+        Some(did) if ast_util::is_local(did) => {
             try!({
-                match cache_key.get().unwrap().traits.find(&id) {
+                match cache_key.get().unwrap().traits.find(&did.node) {
                     Some(t) => {
                         for method in t.methods.iter() {
                             let n = method.item().name.clone();
@@ -1653,6 +1688,7 @@ fn docmeth(w: &mut Writer, item: &clean::Item,
                 Ok(())
             })
         }
+        Some(..) => {}
     }
     try!(write!(w, "</div>"));
     Ok(())

src/librustdoc/passes.rs

@@ -65,9 +65,10 @@ struct ImplStripper<'a> {
         impl<'a> fold::DocFolder for ImplStripper<'a> {
             fn fold_item(&mut self, i: Item) -> Option<Item> {
                 match i.inner {
-                    clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: for_id, .. },
-                                                 .. }) => {
-                        if self.stripped.contains(&for_id) {
+                    clean::ImplItem(clean::Impl{
+                        for_: clean::ResolvedPath{ did, .. }, ..
+                    }) => {
+                        if self.stripped.contains(&did.node) {
                             return None;
                         }
                     }
@@ -146,8 +147,10 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
             clean::ModuleItem(..) => {}
 
             // trait impls for private items should be stripped
-            clean::ImplItem(clean::Impl{ for_: clean::ResolvedPath{ id: ref for_id, .. }, .. }) => {
-                if !self.exported_items.contains(for_id) {
+            clean::ImplItem(clean::Impl{
+                for_: clean::ResolvedPath{ did, .. }, ..
+            }) => {
+                if !self.exported_items.contains(&did.node) {
                     return None;
                 }
             }
@@ -201,9 +204,9 @@ fn fold_item(&mut self, i: Item) -> Option<Item> {
         match i.inner {
             clean::ImplItem(ref imp) => {
                 match imp.trait_ {
-                    Some(clean::ResolvedPath{ id, .. }) => {
+                    Some(clean::ResolvedPath{ did, .. }) => {
                         let ImplStripper(s) = *self;
-                        if !s.contains(&id) {
+                        if !s.contains(&did.node) {
                             return None;
                         }
                     }

src/librustdoc/test.rs

@@ -16,7 +16,7 @@
 use std::str;
 use std::strbuf::StrBuf;
 
-use collections::HashSet;
+use collections::{HashSet, HashMap};
 use testing;
 use rustc::back::link;
 use rustc::driver::driver;
@@ -73,6 +73,7 @@ pub fn run(input: &str,
         krate: krate,
         maybe_typed: core::NotTyped(sess),
         src: input_path,
+        external_paths: RefCell::new(Some(HashMap::new())),
     };
     super::ctxtkey.replace(Some(ctx));