mirror of
https://github.com/rust-lang/rust.git
synced 2025-04-16 05:56:56 +00:00
Auto merge of #90337 - matthiaskrgr:rollup-azkr158, r=matthiaskrgr
Rollup of 3 pull requests Successful merges: - #90154 (rustdoc: Remove `GetDefId`) - #90232 (rustdoc: Use TTF based font instead of OTF for CJK glyphs to improve readability) - #90278 (rustdoc: use better highlighting for *const, *mut, and &mut) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
This commit is contained in:
bors
commit
47aeac648e
@ -234,7 +234,7 @@ unsafe impl SliceIndex<str> for ops::Range<usize> {
|
||||
/// Implements substring slicing with syntax `&self[.. end]` or `&mut
|
||||
/// self[.. end]`.
|
||||
///
|
||||
/// Returns a slice of the given string from the byte range [`0`, `end`).
|
||||
/// Returns a slice of the given string from the byte range \[0, `end`).
|
||||
/// Equivalent to `&self[0 .. end]` or `&mut self[0 .. end]`.
|
||||
///
|
||||
/// This operation is *O*(1).
|
||||
@ -304,9 +304,8 @@ unsafe impl SliceIndex<str> for ops::RangeTo<usize> {
|
||||
/// Implements substring slicing with syntax `&self[begin ..]` or `&mut
|
||||
/// self[begin ..]`.
|
||||
///
|
||||
/// Returns a slice of the given string from the byte range [`begin`,
|
||||
/// `len`). Equivalent to `&self[begin .. len]` or `&mut self[begin ..
|
||||
/// len]`.
|
||||
/// Returns a slice of the given string from the byte range \[`begin`, `len`).
|
||||
/// Equivalent to `&self[begin .. len]` or `&mut self[begin .. len]`.
|
||||
///
|
||||
/// This operation is *O*(1).
|
||||
///
|
||||
@ -433,7 +432,7 @@ unsafe impl SliceIndex<str> for ops::RangeInclusive<usize> {
|
||||
/// Implements substring slicing with syntax `&self[..= end]` or `&mut
|
||||
/// self[..= end]`.
|
||||
///
|
||||
/// Returns a slice of the given string from the byte range [0, `end`].
|
||||
/// Returns a slice of the given string from the byte range \[0, `end`\].
|
||||
/// Equivalent to `&self [0 .. end + 1]`, except if `end` has the maximum
|
||||
/// value for `usize`.
|
||||
///
|
||||
|
||||
@ -686,7 +686,7 @@ impl Wtf8 {
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a slice of the given string for the byte range [`begin`..`end`).
|
||||
/// Returns a slice of the given string for the byte range \[`begin`..`end`).
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
|
||||
@ -14,9 +14,7 @@ use rustc_middle::ty::{self, TyCtxt};
|
||||
use rustc_span::hygiene::MacroKind;
|
||||
use rustc_span::symbol::{kw, sym, Symbol};
|
||||
|
||||
use crate::clean::{
|
||||
self, utils, Attributes, AttributesExt, GetDefId, ItemId, NestedAttributesExt, Type,
|
||||
};
|
||||
use crate::clean::{self, utils, Attributes, AttributesExt, ItemId, NestedAttributesExt, Type};
|
||||
use crate::core::DocContext;
|
||||
use crate::formats::item_type::ItemType;
|
||||
|
||||
@ -325,7 +323,7 @@ fn merge_attrs(
|
||||
}
|
||||
}
|
||||
|
||||
/// Builds a specific implementation of a type. The `did` could be a type method or trait method.
|
||||
/// Inline an `impl`, inherent or of a trait. The `did` must be for an `impl`.
|
||||
crate fn build_impl(
|
||||
cx: &mut DocContext<'_>,
|
||||
parent_module: impl Into<Option<DefId>>,
|
||||
@ -376,7 +374,7 @@ crate fn build_impl(
|
||||
// Only inline impl if the implementing type is
|
||||
// reachable in rustdoc generated documentation
|
||||
if !did.is_local() {
|
||||
if let Some(did) = for_.def_id() {
|
||||
if let Some(did) = for_.def_id(&cx.cache) {
|
||||
if !cx.cache.access_levels.is_public(did) {
|
||||
return;
|
||||
}
|
||||
@ -464,7 +462,7 @@ crate fn build_impl(
|
||||
}
|
||||
|
||||
while let Some(ty) = stack.pop() {
|
||||
if let Some(did) = ty.def_id() {
|
||||
if let Some(did) = ty.def_id(&cx.cache) {
|
||||
if tcx.get_attrs(did).lists(sym::doc).has_word(sym::hidden) {
|
||||
return;
|
||||
}
|
||||
@ -481,7 +479,11 @@ crate fn build_impl(
|
||||
let (merged_attrs, cfg) = merge_attrs(cx, parent_module.into(), load_attrs(cx, did), attrs);
|
||||
trace!("merged_attrs={:?}", merged_attrs);
|
||||
|
||||
trace!("build_impl: impl {:?} for {:?}", trait_.as_ref().map(|t| t.def_id()), for_.def_id());
|
||||
trace!(
|
||||
"build_impl: impl {:?} for {:?}",
|
||||
trait_.as_ref().map(|t| t.def_id()),
|
||||
for_.def_id(&cx.cache)
|
||||
);
|
||||
ret.push(clean::Item::from_def_id_and_attrs_and_parts(
|
||||
did,
|
||||
None,
|
||||
|
||||
@ -383,7 +383,7 @@ impl<'tcx> Clean<Type> for ty::ProjectionTy<'tcx> {
|
||||
let self_type = self.self_ty().clean(cx);
|
||||
Type::QPath {
|
||||
name: cx.tcx.associated_item(self.item_def_id).ident.name,
|
||||
self_def_id: self_type.def_id(),
|
||||
self_def_id: self_type.def_id(&cx.cache),
|
||||
self_type: box self_type,
|
||||
trait_,
|
||||
}
|
||||
@ -1883,7 +1883,7 @@ fn clean_impl(impl_: &hir::Impl<'_>, hir_id: hir::HirId, cx: &mut DocContext<'_>
|
||||
}
|
||||
|
||||
let for_ = impl_.self_ty.clean(cx);
|
||||
let type_alias = for_.def_id().and_then(|did| match tcx.def_kind(did) {
|
||||
let type_alias = for_.def_id(&cx.cache).and_then(|did| match tcx.def_kind(did) {
|
||||
DefKind::TyAlias => Some(tcx.type_of(did).clean(cx)),
|
||||
_ => None,
|
||||
});
|
||||
|
||||
@ -1370,17 +1370,10 @@ crate enum FnRetTy {
|
||||
DefaultReturn,
|
||||
}
|
||||
|
||||
impl GetDefId for FnRetTy {
|
||||
fn def_id(&self) -> Option<DefId> {
|
||||
match *self {
|
||||
Return(ref ty) => ty.def_id(),
|
||||
DefaultReturn => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn def_id_full(&self, cache: &Cache) -> Option<DefId> {
|
||||
match *self {
|
||||
Return(ref ty) => ty.def_id_full(cache),
|
||||
impl FnRetTy {
|
||||
crate fn as_return(&self) -> Option<&Type> {
|
||||
match self {
|
||||
Return(ret) => Some(ret),
|
||||
DefaultReturn => None,
|
||||
}
|
||||
}
|
||||
@ -1458,34 +1451,6 @@ crate enum Type {
|
||||
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
|
||||
rustc_data_structures::static_assert_size!(Type, 72);
|
||||
|
||||
crate trait GetDefId {
|
||||
/// Use this method to get the [`DefId`] of a [`clean`] AST node.
|
||||
/// This will return [`None`] when called on a primitive [`clean::Type`].
|
||||
/// Use [`Self::def_id_full`] if you want to include primitives.
|
||||
///
|
||||
/// [`clean`]: crate::clean
|
||||
/// [`clean::Type`]: crate::clean::Type
|
||||
// FIXME: get rid of this function and always use `def_id_full`
|
||||
fn def_id(&self) -> Option<DefId>;
|
||||
|
||||
/// Use this method to get the [DefId] of a [clean] AST node, including [PrimitiveType]s.
|
||||
///
|
||||
/// See [`Self::def_id`] for more.
|
||||
///
|
||||
/// [clean]: crate::clean
|
||||
fn def_id_full(&self, cache: &Cache) -> Option<DefId>;
|
||||
}
|
||||
|
||||
impl<T: GetDefId> GetDefId for Option<T> {
|
||||
fn def_id(&self) -> Option<DefId> {
|
||||
self.as_ref().and_then(|d| d.def_id())
|
||||
}
|
||||
|
||||
fn def_id_full(&self, cache: &Cache) -> Option<DefId> {
|
||||
self.as_ref().and_then(|d| d.def_id_full(cache))
|
||||
}
|
||||
}
|
||||
|
||||
impl Type {
|
||||
crate fn primitive_type(&self) -> Option<PrimitiveType> {
|
||||
match *self {
|
||||
@ -1564,18 +1529,28 @@ impl Type {
|
||||
QPath { ref self_type, .. } => return self_type.inner_def_id(cache),
|
||||
Generic(_) | Infer | ImplTrait(_) => return None,
|
||||
};
|
||||
cache.and_then(|c| Primitive(t).def_id_full(c))
|
||||
}
|
||||
}
|
||||
|
||||
impl GetDefId for Type {
|
||||
fn def_id(&self) -> Option<DefId> {
|
||||
self.inner_def_id(None)
|
||||
cache.and_then(|c| Primitive(t).def_id(c))
|
||||
}
|
||||
|
||||
fn def_id_full(&self, cache: &Cache) -> Option<DefId> {
|
||||
/// Use this method to get the [DefId] of a [clean] AST node, including [PrimitiveType]s.
|
||||
///
|
||||
/// See [`Self::def_id_no_primitives`] for more.
|
||||
///
|
||||
/// [clean]: crate::clean
|
||||
crate fn def_id(&self, cache: &Cache) -> Option<DefId> {
|
||||
self.inner_def_id(Some(cache))
|
||||
}
|
||||
|
||||
/// Use this method to get the [`DefId`] of a [`clean`] AST node.
|
||||
/// This will return [`None`] when called on a primitive [`clean::Type`].
|
||||
/// Use [`Self::def_id`] if you want to include primitives.
|
||||
///
|
||||
/// [`clean`]: crate::clean
|
||||
/// [`clean::Type`]: crate::clean::Type
|
||||
// FIXME: get rid of this function and always use `def_id`
|
||||
crate fn def_id_no_primitives(&self) -> Option<DefId> {
|
||||
self.inner_def_id(None)
|
||||
}
|
||||
}
|
||||
|
||||
/// A primitive (aka, builtin) type.
|
||||
@ -2092,16 +2067,6 @@ crate struct Typedef {
|
||||
crate item_type: Option<Type>,
|
||||
}
|
||||
|
||||
impl GetDefId for Typedef {
|
||||
fn def_id(&self) -> Option<DefId> {
|
||||
self.type_.def_id()
|
||||
}
|
||||
|
||||
fn def_id_full(&self, cache: &Cache) -> Option<DefId> {
|
||||
self.type_.def_id_full(cache)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
crate struct OpaqueTy {
|
||||
crate bounds: Vec<GenericBound>,
|
||||
|
||||
@ -6,7 +6,7 @@ use rustc_middle::middle::privacy::AccessLevels;
|
||||
use rustc_middle::ty::TyCtxt;
|
||||
use rustc_span::symbol::sym;
|
||||
|
||||
use crate::clean::{self, GetDefId, ItemId, PrimitiveType};
|
||||
use crate::clean::{self, ItemId, PrimitiveType};
|
||||
use crate::config::RenderOptions;
|
||||
use crate::fold::DocFolder;
|
||||
use crate::formats::item_type::ItemType;
|
||||
@ -206,7 +206,9 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
|
||||
|| i.trait_
|
||||
.as_ref()
|
||||
.map_or(false, |t| self.cache.masked_crates.contains(&t.def_id().krate))
|
||||
|| i.for_.def_id().map_or(false, |d| self.cache.masked_crates.contains(&d.krate))
|
||||
|| i.for_
|
||||
.def_id(self.cache)
|
||||
.map_or(false, |d| self.cache.masked_crates.contains(&d.krate))
|
||||
{
|
||||
return None;
|
||||
}
|
||||
@ -454,7 +456,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
|
||||
|
||||
if let Some(generics) = i.trait_.as_ref().and_then(|t| t.generics()) {
|
||||
for bound in generics {
|
||||
if let Some(did) = bound.def_id() {
|
||||
if let Some(did) = bound.def_id(self.cache) {
|
||||
dids.insert(did);
|
||||
}
|
||||
}
|
||||
|
||||
@ -469,22 +469,37 @@ impl<'a> Classifier<'a> {
|
||||
// Assume that '&' or '*' is the reference or dereference operator
|
||||
// or a reference or pointer type. Unless, of course, it looks like
|
||||
// a logical and or a multiplication operator: `&&` or `* `.
|
||||
TokenKind::Star => match self.peek() {
|
||||
Some(TokenKind::Whitespace) => Class::Op,
|
||||
TokenKind::Star => match self.tokens.peek() {
|
||||
Some((TokenKind::Whitespace, _)) => Class::Op,
|
||||
Some((TokenKind::Ident, "mut")) => {
|
||||
self.next();
|
||||
sink(Highlight::Token { text: "*mut", class: Some(Class::RefKeyWord) });
|
||||
return;
|
||||
}
|
||||
Some((TokenKind::Ident, "const")) => {
|
||||
self.next();
|
||||
sink(Highlight::Token { text: "*const", class: Some(Class::RefKeyWord) });
|
||||
return;
|
||||
}
|
||||
_ => Class::RefKeyWord,
|
||||
},
|
||||
TokenKind::And => match lookahead {
|
||||
Some(TokenKind::And) => {
|
||||
TokenKind::And => match self.tokens.peek() {
|
||||
Some((TokenKind::And, _)) => {
|
||||
self.next();
|
||||
sink(Highlight::Token { text: "&&", class: Some(Class::Op) });
|
||||
return;
|
||||
}
|
||||
Some(TokenKind::Eq) => {
|
||||
Some((TokenKind::Eq, _)) => {
|
||||
self.next();
|
||||
sink(Highlight::Token { text: "&=", class: Some(Class::Op) });
|
||||
return;
|
||||
}
|
||||
Some(TokenKind::Whitespace) => Class::Op,
|
||||
Some((TokenKind::Whitespace, _)) => Class::Op,
|
||||
Some((TokenKind::Ident, "mut")) => {
|
||||
self.next();
|
||||
sink(Highlight::Token { text: "&mut", class: Some(Class::RefKeyWord) });
|
||||
return;
|
||||
}
|
||||
_ => Class::RefKeyWord,
|
||||
},
|
||||
|
||||
|
||||
@ -15,11 +15,11 @@
|
||||
<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">"linux"</span>)]</span>
|
||||
<span class="kw">fn</span> <span class="ident">main</span>() -> () {
|
||||
<span class="kw">let</span> <span class="ident">foo</span> <span class="op">=</span> <span class="bool-val">true</span> <span class="op">&&</span> <span class="bool-val">false</span> <span class="op">|</span><span class="op">|</span> <span class="bool-val">true</span>;
|
||||
<span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">*</span><span class="kw">const</span> () <span class="op">=</span> <span class="number">0</span>;
|
||||
<span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">*const</span> () <span class="op">=</span> <span class="number">0</span>;
|
||||
<span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">&</span><span class="ident">foo</span>;
|
||||
<span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="op">&&</span><span class="ident">foo</span>;
|
||||
<span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">*</span><span class="ident">foo</span>;
|
||||
<span class="macro">mac!</span>(<span class="ident">foo</span>, <span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">bar</span>);
|
||||
<span class="macro">mac!</span>(<span class="ident">foo</span>, <span class="kw-2">&mut</span> <span class="ident">bar</span>);
|
||||
<span class="macro">assert!</span>(<span class="self">self</span>.<span class="ident">length</span> <span class="op"><</span> <span class="ident">N</span> <span class="op">&&</span> <span class="ident">index</span> <span class="op"><</span><span class="op">=</span> <span class="self">self</span>.<span class="ident">length</span>);
|
||||
<span class="ident">::std::env::var</span>(<span class="string">"gateau"</span>).<span class="ident">is_ok</span>();
|
||||
<span class="attribute">#[<span class="ident">rustfmt::skip</span>]</span>
|
||||
|
||||
@ -7,9 +7,7 @@ use rustc_span::symbol::Symbol;
|
||||
use serde::ser::{Serialize, SerializeStruct, Serializer};
|
||||
|
||||
use crate::clean;
|
||||
use crate::clean::types::{
|
||||
FnDecl, FnRetTy, GenericBound, Generics, GetDefId, Type, WherePredicate,
|
||||
};
|
||||
use crate::clean::types::{FnDecl, FnRetTy, GenericBound, Generics, Type, WherePredicate};
|
||||
use crate::formats::cache::Cache;
|
||||
use crate::formats::item_type::ItemType;
|
||||
use crate::html::markdown::short_markdown_summary;
|
||||
@ -278,7 +276,7 @@ crate fn get_real_types<'tcx>(
|
||||
res: &mut FxHashSet<(Type, ItemType)>,
|
||||
) -> usize {
|
||||
fn insert(res: &mut FxHashSet<(Type, ItemType)>, tcx: TyCtxt<'_>, ty: Type) -> usize {
|
||||
if let Some(kind) = ty.def_id().map(|did| tcx.def_kind(did).into()) {
|
||||
if let Some(kind) = ty.def_id_no_primitives().map(|did| tcx.def_kind(did).into()) {
|
||||
res.insert((ty, kind));
|
||||
1
|
||||
} else if ty.is_primitive() {
|
||||
@ -298,7 +296,9 @@ crate fn get_real_types<'tcx>(
|
||||
|
||||
if let Type::Generic(arg_s) = *arg {
|
||||
if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g {
|
||||
WherePredicate::BoundPredicate { ty, .. } => ty.def_id() == arg.def_id(),
|
||||
WherePredicate::BoundPredicate { ty, .. } => {
|
||||
ty.def_id_no_primitives() == arg.def_id_no_primitives()
|
||||
}
|
||||
_ => false,
|
||||
}) {
|
||||
let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]);
|
||||
@ -365,7 +365,8 @@ crate fn get_all_types<'tcx>(
|
||||
if !args.is_empty() {
|
||||
all_types.extend(args);
|
||||
} else {
|
||||
if let Some(kind) = arg.type_.def_id().map(|did| tcx.def_kind(did).into()) {
|
||||
if let Some(kind) = arg.type_.def_id_no_primitives().map(|did| tcx.def_kind(did).into())
|
||||
{
|
||||
all_types.insert((arg.type_.clone(), kind));
|
||||
}
|
||||
}
|
||||
@ -376,7 +377,9 @@ crate fn get_all_types<'tcx>(
|
||||
let mut ret = FxHashSet::default();
|
||||
get_real_types(generics, return_type, tcx, 0, &mut ret);
|
||||
if ret.is_empty() {
|
||||
if let Some(kind) = return_type.def_id().map(|did| tcx.def_kind(did).into()) {
|
||||
if let Some(kind) =
|
||||
return_type.def_id_no_primitives().map(|did| tcx.def_kind(did).into())
|
||||
{
|
||||
ret.insert((return_type.clone(), kind));
|
||||
}
|
||||
}
|
||||
|
||||
@ -62,7 +62,7 @@ use rustc_span::{
|
||||
use serde::ser::SerializeSeq;
|
||||
use serde::{Serialize, Serializer};
|
||||
|
||||
use crate::clean::{self, GetDefId, ItemId, RenderedLink, SelfTy};
|
||||
use crate::clean::{self, ItemId, RenderedLink, SelfTy};
|
||||
use crate::docfs::PathError;
|
||||
use crate::error::Error;
|
||||
use crate::formats::cache::Cache;
|
||||
@ -1184,8 +1184,8 @@ fn render_deref_methods(
|
||||
debug!("Render deref methods for {:#?}, target {:#?}", impl_.inner_impl().for_, target);
|
||||
let what =
|
||||
AssocItemRender::DerefFor { trait_: deref_type, type_: real_target, deref_mut_: deref_mut };
|
||||
if let Some(did) = target.def_id_full(cache) {
|
||||
if let Some(type_did) = impl_.inner_impl().for_.def_id_full(cache) {
|
||||
if let Some(did) = target.def_id(cache) {
|
||||
if let Some(type_did) = impl_.inner_impl().for_.def_id(cache) {
|
||||
// `impl Deref<Target = S> for S`
|
||||
if did == type_did {
|
||||
// Avoid infinite cycles
|
||||
@ -1231,7 +1231,7 @@ fn should_render_item(item: &clean::Item, deref_mut_: bool, tcx: TyCtxt<'_>) ->
|
||||
fn notable_traits_decl(decl: &clean::FnDecl, cx: &Context<'_>) -> String {
|
||||
let mut out = Buffer::html();
|
||||
|
||||
if let Some(did) = decl.output.def_id_full(cx.cache()) {
|
||||
if let Some(did) = decl.output.as_return().and_then(|t| t.def_id(cx.cache())) {
|
||||
if let Some(impls) = cx.cache().impls.get(&did) {
|
||||
for i in impls {
|
||||
let impl_ = i.inner_impl();
|
||||
@ -2074,8 +2074,8 @@ fn sidebar_deref_methods(cx: &Context<'_>, out: &mut Buffer, impl_: &Impl, v: &[
|
||||
})
|
||||
{
|
||||
debug!("found target, real_target: {:?} {:?}", target, real_target);
|
||||
if let Some(did) = target.def_id_full(c) {
|
||||
if let Some(type_did) = impl_.inner_impl().for_.def_id_full(c) {
|
||||
if let Some(did) = target.def_id(c) {
|
||||
if let Some(type_did) = impl_.inner_impl().for_.def_id(c) {
|
||||
// `impl Deref<Target = S> for S`
|
||||
if did == type_did {
|
||||
// Avoid infinite cycles
|
||||
@ -2085,7 +2085,7 @@ fn sidebar_deref_methods(cx: &Context<'_>, out: &mut Buffer, impl_: &Impl, v: &[
|
||||
}
|
||||
let deref_mut = v.iter().any(|i| i.trait_did() == cx.tcx().lang_items().deref_mut_trait());
|
||||
let inner_impl = target
|
||||
.def_id_full(c)
|
||||
.def_id(c)
|
||||
.or_else(|| {
|
||||
target.primitive_type().and_then(|prim| c.primitive_locations.get(&prim).cloned())
|
||||
})
|
||||
@ -2246,10 +2246,7 @@ fn sidebar_trait(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, t: &clean
|
||||
let mut res = implementors
|
||||
.iter()
|
||||
.filter(|i| {
|
||||
i.inner_impl()
|
||||
.for_
|
||||
.def_id_full(cache)
|
||||
.map_or(false, |d| !cache.paths.contains_key(&d))
|
||||
i.inner_impl().for_.def_id(cache).map_or(false, |d| !cache.paths.contains_key(&d))
|
||||
})
|
||||
.filter_map(|i| extract_for_impl_name(&i.impl_item, cx))
|
||||
.collect::<Vec<_>>();
|
||||
|
||||
@ -21,7 +21,7 @@ use super::{
|
||||
render_impl, render_stability_since_raw, write_srclink, AssocItemLink, Context,
|
||||
ImplRenderingParameters,
|
||||
};
|
||||
use crate::clean::{self, GetDefId};
|
||||
use crate::clean;
|
||||
use crate::formats::item_type::ItemType;
|
||||
use crate::formats::{AssocItemRender, Impl, RenderMode};
|
||||
use crate::html::escape::Escape;
|
||||
@ -742,7 +742,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
|
||||
}
|
||||
|
||||
let (local, foreign) = implementors.iter().partition::<Vec<_>, _>(|i| {
|
||||
i.inner_impl().for_.def_id_full(cache).map_or(true, |d| cache.paths.contains_key(&d))
|
||||
i.inner_impl().for_.def_id(cache).map_or(true, |d| cache.paths.contains_key(&d))
|
||||
});
|
||||
|
||||
let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
|
||||
|
||||
@ -39,9 +39,9 @@ static FILES_UNVERSIONED: Lazy<FxHashMap<&str, &[u8]>> = Lazy::new(|| {
|
||||
"SourceCodePro-Semibold.ttf.woff" => static_files::source_code_pro::SEMIBOLD,
|
||||
"SourceCodePro-It.ttf.woff" => static_files::source_code_pro::ITALIC,
|
||||
"SourceCodePro-LICENSE.txt" => static_files::source_code_pro::LICENSE,
|
||||
"noto-sans-kr-regular.woff2" => static_files::noto_sans_kr::REGULAR2,
|
||||
"noto-sans-kr-regular.woff" => static_files::noto_sans_kr::REGULAR,
|
||||
"noto-sans-kr-LICENSE.txt" => static_files::noto_sans_kr::LICENSE,
|
||||
"NanumBarunGothic.ttf.woff2" => static_files::nanum_barun_gothic::REGULAR2,
|
||||
"NanumBarunGothic.ttf.woff" => static_files::nanum_barun_gothic::REGULAR,
|
||||
"NanumBarunGothic-LICENSE.txt" => static_files::nanum_barun_gothic::LICENSE,
|
||||
"LICENSE-MIT.txt" => static_files::LICENSE_MIT,
|
||||
"LICENSE-APACHE.txt" => static_files::LICENSE_APACHE,
|
||||
"COPYRIGHT.txt" => static_files::COPYRIGHT,
|
||||
|
||||
@ -77,11 +77,11 @@
|
||||
|
||||
/* Avoid using legacy CJK serif fonts in Windows like Batang. */
|
||||
@font-face {
|
||||
font-family: 'Noto Sans KR';
|
||||
src: url("noto-sans-kr-regular.woff2") format("woff2"),
|
||||
url("noto-sans-kr-regular.woff") format("woff");
|
||||
font-family: 'NanumBarunGothic';
|
||||
src: url("NanumBarunGothic.ttf.woff2") format("woff2"),
|
||||
url("NanumBarunGothic.ttf.woff") format("woff");
|
||||
font-display: swap;
|
||||
unicode-range: U+AC00-D7AF, U+3130-318F, U+1100-11FF, U+A960-A97F, U+D7B0-D7FF;
|
||||
unicode-range: U+AC00-D7AF, U+1100-11FF, U+3130-318F, U+A960-A97F, U+D7B0-D7FF;
|
||||
}
|
||||
|
||||
* {
|
||||
@ -108,7 +108,7 @@ html {
|
||||
/* General structure and fonts */
|
||||
|
||||
body {
|
||||
font: 16px/1.4 "Source Serif 4", "Noto Sans KR", serif;
|
||||
font: 16px/1.4 "Source Serif 4", NanumBarunGothic, serif;
|
||||
margin: 0;
|
||||
position: relative;
|
||||
padding: 10px 15px 20px 15px;
|
||||
@ -196,7 +196,7 @@ div.impl-items > div:not(.docblock):not(.item-info),
|
||||
.content ul.crate a.crate, a.srclink,
|
||||
/* This selector is for the items listed in the "all items" page. */
|
||||
#main > ul.docblock > li > a {
|
||||
font-family: "Fira Sans", Arial, sans-serif;
|
||||
font-family: "Fira Sans", Arial, NanumBarunGothic, sans-serif;
|
||||
}
|
||||
|
||||
.content ul.crate a.crate {
|
||||
|
||||
@ -1,8 +1,14 @@
|
||||
Copyright 2014, 2015 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
|
||||
Copyright (c) 2010, NAVER Corporation (https://www.navercorp.com/),
|
||||
|
||||
with Reserved Font Name Nanum, Naver Nanum, NanumGothic, Naver NanumGothic,
|
||||
NanumMyeongjo, Naver NanumMyeongjo, NanumBrush, Naver NanumBrush, NanumPen,
|
||||
Naver NanumPen, Naver NanumGothicEco, NanumGothicEco, Naver NanumMyeongjoEco,
|
||||
NanumMyeongjoEco, Naver NanumGothicLight, NanumGothicLight, NanumBarunGothic,
|
||||
Naver NanumBarunGothic, NanumSquareRound, NanumBarunPen, MaruBuri
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License, Version 1.1.
|
||||
|
||||
This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
http://scripts.sil.org/OFL
|
||||
|
||||
|
||||
-----------------------------------------------------------
|
||||
BIN
src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff
Normal file
BIN
src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff
Normal file
Binary file not shown.
BIN
src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff2
Normal file
BIN
src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff2
Normal file
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -160,15 +160,35 @@ crate mod source_code_pro {
|
||||
crate static LICENSE: &[u8] = include_bytes!("static/fonts/SourceCodePro-LICENSE.txt");
|
||||
}
|
||||
|
||||
crate mod noto_sans_kr {
|
||||
/// The file `noto-sans-kr.woff`, the Regular variant of the Noto Sans KR font.
|
||||
crate static REGULAR: &[u8] = include_bytes!("static/fonts/noto-sans-kr-regular.woff");
|
||||
/// Files related to the Nanum Barun Gothic font.
|
||||
///
|
||||
/// These files are used to avoid some legacy CJK serif fonts in Windows.
|
||||
///
|
||||
/// Note that the Noto Sans KR font, which was used previously but was not very readable on Windows,
|
||||
/// has been replaced by the Nanum Barun Gothic font. This is due to Windows' implementation of font
|
||||
/// rendering that distorts OpenType fonts too much.
|
||||
///
|
||||
/// The font files were generated with these commands:
|
||||
///
|
||||
/// ```sh
|
||||
/// pyftsubset NanumBarunGothic.ttf \
|
||||
/// --unicodes=U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF \
|
||||
/// --output-file=NanumBarunGothic.ttf.woff --flavor=woff
|
||||
/// ```
|
||||
/// ```sh
|
||||
/// pyftsubset NanumBarunGothic.ttf \
|
||||
/// --unicodes=U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF \
|
||||
/// --output-file=NanumBarunGothic.ttf.woff2 --flavor=woff2
|
||||
/// ```
|
||||
crate mod nanum_barun_gothic {
|
||||
/// The file `NanumBarunGothic.ttf.woff`, the Regular variant of the Nanum Barun Gothic font.
|
||||
crate static REGULAR: &[u8] = include_bytes!("static/fonts/NanumBarunGothic.ttf.woff");
|
||||
|
||||
/// The file `noto-sans-kr.woff2`, the Regular variant of the Noto Sans KR font.
|
||||
crate static REGULAR2: &[u8] = include_bytes!("static/fonts/noto-sans-kr-regular.woff2");
|
||||
/// The file `NanumBarunGothic.ttf.woff2`, the Regular variant of the Nanum Barun Gothic font.
|
||||
crate static REGULAR2: &[u8] = include_bytes!("static/fonts/NanumBarunGothic.ttf.woff2");
|
||||
|
||||
/// The file `noto-sans-kr-LICENSE.txt`, the license text of the Noto Sans KR font.
|
||||
crate static LICENSE: &[u8] = include_bytes!("static/fonts/noto-sans-kr-LICENSE.txt");
|
||||
/// The file `NanumBarunGothic-LICENSE.txt`, the license text of the Nanum Barun Gothic font.
|
||||
crate static LICENSE: &[u8] = include_bytes!("static/fonts/NanumBarunGothic-LICENSE.txt");
|
||||
}
|
||||
|
||||
/// Files related to the sidebar in rustdoc sources.
|
||||
|
||||
@ -70,7 +70,7 @@ crate fn collect_trait_impls(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
|
||||
|
||||
if let Some(prim) = target.primitive_type() {
|
||||
cleaner.prims.insert(prim);
|
||||
} else if let Some(did) = target.def_id() {
|
||||
} else if let Some(did) = target.def_id(&cx.cache) {
|
||||
cleaner.items.insert(did.into());
|
||||
}
|
||||
}
|
||||
@ -187,7 +187,7 @@ impl BadImplStripper {
|
||||
true
|
||||
} else if let Some(prim) = ty.primitive_type() {
|
||||
self.prims.contains(&prim)
|
||||
} else if let Some(did) = ty.def_id() {
|
||||
} else if let Some(did) = ty.def_id_no_primitives() {
|
||||
self.keep_impl_with_def_id(did.into())
|
||||
} else {
|
||||
false
|
||||
|
||||
@ -2,7 +2,7 @@ use rustc_hir::def_id::DefId;
|
||||
use rustc_middle::middle::privacy::AccessLevels;
|
||||
use std::mem;
|
||||
|
||||
use crate::clean::{self, GetDefId, Item, ItemIdSet};
|
||||
use crate::clean::{self, Item, ItemIdSet};
|
||||
use crate::fold::{strip_item, DocFolder};
|
||||
|
||||
crate struct Stripper<'a> {
|
||||
@ -127,7 +127,7 @@ impl<'a> DocFolder for ImplStripper<'a> {
|
||||
if imp.trait_.is_none() && imp.items.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if let Some(did) = imp.for_.def_id() {
|
||||
if let Some(did) = imp.for_.def_id_no_primitives() {
|
||||
if did.is_local() && !imp.for_.is_assoc_ty() && !self.retained.contains(&did.into())
|
||||
{
|
||||
debug!("ImplStripper: impl item for stripped type; removing");
|
||||
@ -142,7 +142,7 @@ impl<'a> DocFolder for ImplStripper<'a> {
|
||||
}
|
||||
if let Some(generics) = imp.trait_.as_ref().and_then(|t| t.generics()) {
|
||||
for typaram in generics {
|
||||
if let Some(did) = typaram.def_id() {
|
||||
if let Some(did) = typaram.def_id_no_primitives() {
|
||||
if did.is_local() && !self.retained.contains(&did.into()) {
|
||||
debug!(
|
||||
"ImplStripper: stripped item in trait's generics; removing impl"
|
||||
|
||||
@ -1,23 +1,23 @@
|
||||
// This test checks that the correct font is used on module items (in index.html pages).
|
||||
goto: file://|DOC_PATH|/test_docs/index.html
|
||||
assert-css: (".item-table .module-item a", {"font-family": '"Fira Sans", Arial, sans-serif'}, ALL)
|
||||
assert-css: (".item-table .docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'}, ALL)
|
||||
assert-css: (".item-table .module-item a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'}, ALL)
|
||||
assert-css: (".item-table .docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'}, ALL)
|
||||
|
||||
// modules
|
||||
assert-css: ("#modules + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#modules + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#modules + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#modules + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
// structs
|
||||
assert-css: ("#structs + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#structs + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#structs + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#structs + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
// enums
|
||||
assert-css: ("#enums + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#enums + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#enums + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#enums + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
// traits
|
||||
assert-css: ("#traits + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#traits + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#traits + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#traits + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
// functions
|
||||
assert-css: ("#functions + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#functions + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#functions + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#functions + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
// keywords
|
||||
assert-css: ("#keywords + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, sans-serif'})
|
||||
assert-css: ("#keywords + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", "Noto Sans KR", serif'})
|
||||
assert-css: ("#keywords + .item-table .item-left a", {"font-family": '"Fira Sans", Arial, NanumBarunGothic, sans-serif'})
|
||||
assert-css: ("#keywords + .item-table .item-right.docblock-short", {"font-family": '"Source Serif 4", NanumBarunGothic, serif'})
|
||||
|
||||
@ -85,6 +85,8 @@ const INTRA_DOC_LINK_EXCEPTIONS: &[(&str, &[&str])] = &[
|
||||
("core/slice/trait.SliceIndex.html", &["begin</code>, <code>end"]),
|
||||
("alloc/slice/trait.SliceIndex.html", &["begin</code>, <code>end"]),
|
||||
("std/slice/trait.SliceIndex.html", &["begin</code>, <code>end"]),
|
||||
("core/primitive.str.html", &["begin</code>, <code>end"]),
|
||||
("std/primitive.str.html", &["begin</code>, <code>end"]),
|
||||
|
||||
];
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user