use serde::ser::SerializeSeq;
use serde::{Serialize, Serializer};
-use crate::clean::{self, FakeDefId, GetDefId, RenderedLink, SelfTy};
+use crate::clean::{self, GetDefId, ItemId, RenderedLink, SelfTy};
use crate::docfs::PathError;
use crate::error::Error;
use crate::formats::cache::Cache;
/// A type used for the search index.
#[derive(Debug)]
crate struct RenderType {
- ty: Option<DefId>,
- idx: Option<usize>,
name: Option<String>,
- generics: Option<Vec<Generic>>,
-}
-
-impl Serialize for RenderType {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: Serializer,
- {
- if let Some(name) = &self.name {
- let mut seq = serializer.serialize_seq(None)?;
- if let Some(id) = self.idx {
- seq.serialize_element(&id)?;
- } else {
- seq.serialize_element(&name)?;
- }
- if let Some(generics) = &self.generics {
- seq.serialize_element(&generics)?;
- }
- seq.end()
- } else {
- serializer.serialize_none()
- }
- }
-}
-
-/// A type used for the search index.
-#[derive(Debug)]
-crate struct Generic {
- name: String,
- defid: Option<DefId>,
- idx: Option<usize>,
-}
-
-impl Serialize for Generic {
- fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
- where
- S: Serializer,
- {
- if let Some(id) = self.idx {
- serializer.serialize_some(&id)
- } else {
- serializer.serialize_some(&self.name)
- }
- }
+ generics: Option<Vec<String>>,
}
/// Full type of functions/methods in the search index.
where
S: Serializer,
{
- (&self.ty.name, self.kind).serialize(serializer)
+ let mut seq = serializer.serialize_seq(None)?;
+ seq.serialize_element(&self.ty.name)?;
+ seq.serialize_element(&self.kind)?;
+ if let Some(generics) = &self.ty.generics {
+ seq.serialize_element(generics)?;
+ }
+ seq.end()
}
}
AssocItemLink::Anchor(Some(ref id)) => format!("#{}", id),
AssocItemLink::Anchor(None) => anchor,
AssocItemLink::GotoSource(did, _) => {
- href(did.expect_real(), cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
+ href(did.expect_def_id(), cx).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor)
}
}
}
ItemType::TyMethod
};
- href(did.expect_real(), cx)
+ href(did.expect_def_id(), cx)
.map(|p| format!("{}#{}.{}", p.0, ty, name))
.unwrap_or_else(|| format!("#{}.{}", ty, name))
}
#[derive(Copy, Clone)]
enum AssocItemLink<'a> {
Anchor(Option<&'a str>),
- GotoSource(FakeDefId, &'a FxHashSet<Symbol>),
+ GotoSource(ItemId, &'a FxHashSet<Symbol>),
}
impl<'a> AssocItemLink<'a> {
write!(
buffer,
"<div class=\"block version\">\
+ <div class=\"narrow-helper\"></div>\
<p>Version {}</p>\
</div>",
Escape(version),
}
fn sidebar_assoc_items(cx: &Context<'_>, out: &mut Buffer, it: &clean::Item) {
- let did = it.def_id.expect_real();
+ let did = it.def_id.expect_def_id();
if let Some(v) = cx.cache.impls.get(&did) {
let mut used_links = FxHashSet::default();
let cache = cx.cache();
"</div>",
);
- if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_real()) {
+ if let Some(implementors) = cx.cache.implementors.get(&it.def_id.expect_def_id()) {
let cache = cx.cache();
let mut res = implementors
.iter()