user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Improve path segment joining.

Browse source 
There are many places that join path segments with `::` to produce a
string. A lot of these use `join("::")`. Many in rustdoc use
`join_with_double_colon`, and a few use `.joined("..")`. One in Clippy
uses `itertools::join`. A couple of them look for `kw::PathRoot` in the
first segment, which can be important.

This commit introduces `rustc_ast::join_path_{syms,ident}` to do the
joining for everyone. `rustc_ast` is as good a location for these as
any, being the earliest-running of the several crates with a `Path`
type. Two functions are needed because `Ident` printing is more complex
than simple `Symbol` printing.

The commit also removes `join_with_double_colon`, and
`estimate_item_path_byte_length` with it.

There are still a handful of places that join strings with "::" that are
unchanged. They are not that important: some of them are in tests, and
some of them first split a path around "::" and then rejoin with "::".

This fixes one test case where `{{root}}` shows up in an error message.
This commit is contained in:
Nicholas Nethercote 2025-05-27 15:51:47 +10:00
parent 5795086bdf
commit fb7aa9e4fd
20 changed files with 130 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

55
compiler/rustc_ast/src/ast.rs
View file

@ -18,7 +18,7 @@
//! - [`Attribute`]: Metadata associated with item.
//! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
use std::borrow::Cow;
use std::borrow::{Borrow, Cow};
use std::{cmp, fmt};
pub use GenericArgs::*;
@ -155,6 +155,59 @@ impl Path {
}
}
/// Joins multiple symbols with "::" into a path, e.g. "a::b::c". If the first
/// segment is `kw::PathRoot` it will be printed as empty, e.g. "::b::c".
///
/// The generics on the `path` argument mean it can accept many forms, such as:
/// - `&[Symbol]`
/// - `Vec<Symbol>`
/// - `Vec<&Symbol>`
/// - `impl Iterator<Item = Symbol>`
/// - `impl Iterator<Item = &Symbol>`
///
/// Panics if `path` is empty or a segment after the first is `kw::PathRoot`.
pub fn join_path_syms(path: impl IntoIterator<Item = impl Borrow<Symbol>>) -> String {
// This is a guess at the needed capacity that works well in practice. It is slightly faster
// than (a) starting with an empty string, or (b) computing the exact capacity required.
// `8` works well because it's about the right size and jemalloc's size classes are all
// multiples of 8.
let mut iter = path.into_iter();
let len_hint = iter.size_hint().1.unwrap_or(1);
let mut s = String::with_capacity(len_hint * 8);
let first_sym = *iter.next().unwrap().borrow();
if first_sym != kw::PathRoot {
s.push_str(first_sym.as_str());
}
for sym in iter {
let sym = *sym.borrow();
debug_assert_ne!(sym, kw::PathRoot);
s.push_str("::");
s.push_str(sym.as_str());
}
s
}
/// Like `join_path_syms`, but for `Ident`s. This function is necessary because
/// `Ident::to_string` does more than just print the symbol in the `name` field.
pub fn join_path_idents(path: impl IntoIterator<Item = impl Borrow<Ident>>) -> String {
let mut iter = path.into_iter();
let len_hint = iter.size_hint().1.unwrap_or(1);
let mut s = String::with_capacity(len_hint * 8);
let first_ident = *iter.next().unwrap().borrow();
if first_ident.name != kw::PathRoot {
s.push_str(&first_ident.to_string());
}
for ident in iter {
let ident = *ident.borrow();
debug_assert_ne!(ident.name, kw::PathRoot);
s.push_str("::");
s.push_str(&ident.to_string());
}
s
}
/// A segment of a path: an identifier, an optional lifetime, and a set of types.
///
/// E.g., `std`, `String` or `Box<T>`.

4
compiler/rustc_builtin_macros/src/source_util.rs
View file

@ -4,8 +4,8 @@ use std::sync::Arc;
use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_ast::token;
use rustc_ast::tokenstream::TokenStream;
use rustc_ast::{join_path_idents, token};
use rustc_ast_pretty::pprust;
use rustc_expand::base::{
DummyResult, ExpandResult, ExtCtxt, MacEager, MacResult, MacroExpanderResult, resolve_path,
@ -100,7 +100,7 @@ pub(crate) fn expand_mod(
let sp = cx.with_def_site_ctxt(sp);
check_zero_tts(cx, sp, tts, "module_path!");
let mod_path = &cx.current_expansion.module.mod_path;
let string = mod_path.iter().map(|x| x.to_string()).collect::<Vec<String>>().join("::");
let string = join_path_idents(mod_path);
ExpandResult::Ready(MacEager::expr(cx.expr_str(sp, Symbol::intern(&string))))
}

9
compiler/rustc_builtin_macros/src/test.rs
View file

@ -5,7 +5,7 @@ use std::assert_matches::assert_matches;
use std::iter;
use rustc_ast::ptr::P;
use rustc_ast::{self as ast, GenericParamKind, attr};
use rustc_ast::{self as ast, GenericParamKind, attr, join_path_idents};
use rustc_ast_pretty::pprust;
use rustc_errors::{Applicability, Diag, Level};
use rustc_expand::base::*;
@ -446,12 +446,7 @@ fn get_location_info(cx: &ExtCtxt<'_>, fn_: &ast::Fn) -> (Symbol, usize, usize,
}
fn item_path(mod_path: &[Ident], item_ident: &Ident) -> String {
mod_path
.iter()
.chain(iter::once(item_ident))
.map(|x| x.to_string())
.collect::<Vec<String>>()
.join("::")
join_path_idents(mod_path.iter().chain(iter::once(item_ident)))
}
enum ShouldPanic {

4
compiler/rustc_hir/src/hir.rs
View file

@ -7,7 +7,7 @@ use rustc_ast::token::CommentKind;
use rustc_ast::util::parser::ExprPrecedence;
use rustc_ast::{
self as ast, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece, IntTy, Label, LitIntType,
LitKind, TraitObjectSyntax, UintTy, UnsafeBinderCastKind,
LitKind, TraitObjectSyntax, UintTy, UnsafeBinderCastKind, join_path_idents,
};
pub use rustc_ast::{
AssignOp, AssignOpKind, AttrId, AttrStyle, BinOp, BinOpKind, BindingMode, BorrowKind,
@ -1168,7 +1168,7 @@ impl AttrPath {
impl fmt::Display for AttrPath {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.segments.iter().map(|i| i.to_string()).collect::<Vec<_>>().join("::"))
write!(f, "{}", join_path_idents(&self.segments))
}
}

11
compiler/rustc_hir_typeck/src/method/prelude_edition_lints.rs
View file

@ -2,6 +2,7 @@ use std::fmt::Write;
use hir::def_id::DefId;
use hir::{HirId, ItemKind};
use rustc_ast::join_path_idents;
use rustc_errors::Applicability;
use rustc_hir as hir;
use rustc_lint::{ARRAY_INTO_ITER, BOXED_SLICE_INTO_ITER};
@ -383,13 +384,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
// All that is left is `_`! We need to use the full path. It doesn't matter which one we
// pick, so just take the first one.
match import_items[0].kind {
ItemKind::Use(path, _) => Some(
path.segments
.iter()
.map(|segment| segment.ident.to_string())
.collect::<Vec<_>>()
.join("::"),
),
ItemKind::Use(path, _) => {
Some(join_path_idents(path.segments.iter().map(|seg| seg.ident)))
}
_ => {
span_bug!(span, "unexpected item kind, expected a use: {:?}", import_items[0].kind);
}

6
compiler/rustc_passes/src/check_attr.rs
View file

@ -10,7 +10,7 @@ use std::collections::hash_map::Entry;
use std::slice;
use rustc_abi::{Align, ExternAbi, Size};
use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast};
use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, ast, join_path_syms};
use rustc_attr_data_structures::{AttributeKind, InlineAttr, ReprAttr, find_attr};
use rustc_attr_parsing::{AttributeParser, Late};
use rustc_data_structures::fx::FxHashMap;
@ -678,9 +678,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
allowed_target: Target,
) {
if target != allowed_target {
let path = attr.path();
let path: Vec<_> = path.iter().map(|s| s.as_str()).collect();
let attr_name = path.join("::");
let attr_name = join_path_syms(attr.path());
self.tcx.emit_node_span_lint(
UNUSED_ATTRIBUTES,
hir_id,

29
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -1,6 +1,8 @@
use rustc_ast::ptr::P;
use rustc_ast::visit::{self, Visitor};
use rustc_ast::{self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path};
use rustc_ast::{
self as ast, CRATE_NODE_ID, Crate, ItemKind, ModKind, NodeId, Path, join_path_idents,
};
use rustc_ast_pretty::pprust;
use rustc_attr_data_structures::{
self as attr, AttributeKind, CfgEntry, Stability, StrippedCfgItem, find_attr,
@ -2018,7 +2020,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
}
}
let mut sugg_paths = vec![];
let mut sugg_paths: Vec<(Vec<Ident>, bool)> = vec![];
if let Some(mut def_id) = res.opt_def_id() {
// We can't use `def_path_str` in resolve.
let mut path = vec![def_id];
@ -2031,16 +2033,16 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
}
}
// We will only suggest importing directly if it is accessible through that path.
let path_names: Option<Vec<String>> = path
let path_names: Option<Vec<Ident>> = path
.iter()
.rev()
.map(|def_id| {
self.tcx.opt_item_name(*def_id).map(|n| {
if def_id.is_top_level_module() {
"crate".to_string()
self.tcx.opt_item_name(*def_id).map(|name| {
Ident::with_dummy_span(if def_id.is_top_level_module() {
kw::Crate
} else {
n.to_string()
}
name
})
})
})
.collect();
@ -2084,13 +2086,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
match binding.kind {
NameBindingKind::Import { import, .. } => {
for segment in import.module_path.iter().skip(1) {
path.push(segment.ident.to_string());
path.push(segment.ident);
}
sugg_paths.push((
path.iter()
.cloned()
.chain(vec![ident.to_string()].into_iter())
.collect::<Vec<_>>(),
path.iter().cloned().chain(std::iter::once(ident)).collect::<Vec<_>>(),
true, // re-export
));
}
@ -2126,7 +2125,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
err.subdiagnostic(note);
}
// We prioritize shorter paths, non-core imports and direct imports over the alternatives.
sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0] == "core", *reexport));
sugg_paths.sort_by_key(|(p, reexport)| (p.len(), p[0].name == sym::core, *reexport));
for (sugg, reexport) in sugg_paths {
if not_publicly_reexported {
break;
@ -2136,7 +2135,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
// `tests/ui/imports/issue-55884-2.rs`
continue;
}
let path = sugg.join("::");
let path = join_path_idents(sugg);
let sugg = if reexport {
errors::ImportIdent::ThroughReExport { span: dedup_span, ident, path }
} else {

10
compiler/rustc_resolve/src/rustdoc.rs
View file

@ -7,6 +7,7 @@ use pulldown_cmark::{
};
use rustc_ast as ast;
use rustc_ast::attr::AttributeExt;
use rustc_ast::join_path_syms;
use rustc_ast::util::comments::beautify_doc_string;
use rustc_data_structures::fx::FxIndexMap;
use rustc_data_structures::unord::UnordSet;
@ -259,7 +260,7 @@ pub fn main_body_opts() -> Options {
| Options::ENABLE_SMART_PUNCTUATION
}
fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<String, MalformedGenerics> {
fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<Symbol, MalformedGenerics> {
let mut stripped_segment = String::new();
let mut param_depth = 0;
@ -284,7 +285,7 @@ fn strip_generics_from_path_segment(segment: Vec<char>) -> Result<String, Malfor
}
if param_depth == 0 {
Ok(stripped_segment)
Ok(Symbol::intern(&stripped_segment))
} else {
// The segment has unbalanced angle brackets, e.g. `Vec<T` or `Vec<T>>`
Err(MalformedGenerics::UnbalancedAngleBrackets)
@ -346,9 +347,8 @@ pub fn strip_generics_from_path(path_str: &str) -> Result<Box<str>, MalformedGen
debug!("path_str: {path_str:?}\nstripped segments: {stripped_segments:?}");
let stripped_path = stripped_segments.join("::");
if !stripped_path.is_empty() {
if !stripped_segments.is_empty() {
let stripped_path = join_path_syms(stripped_segments);
Ok(stripped_path.into())
} else {
Err(MalformedGenerics::MissingType)

11
src/librustdoc/clean/utils.rs
View file

@ -3,6 +3,7 @@ use std::fmt::{self, Display, Write as _};
use std::sync::LazyLock as Lazy;
use std::{ascii, mem};
use rustc_ast::join_path_idents;
use rustc_ast::tokenstream::TokenTree;
use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
@ -24,7 +25,7 @@ use crate::clean::{
clean_middle_ty, inline,
};
use crate::core::DocContext;
use crate::display::{Joined as _, MaybeDisplay as _};
use crate::display::Joined as _;
#[cfg(test)]
mod tests;
@ -251,13 +252,7 @@ pub(crate) fn qpath_to_string(p: &hir::QPath<'_>) -> String {
hir::QPath::LangItem(lang_item, ..) => return lang_item.name().to_string(),
};
fmt::from_fn(|f| {
segments
.iter()
.map(|seg| (seg.ident.name != kw::PathRoot).then_some(seg.ident).maybe_display())
.joined("::", f)
})
.to_string()
join_path_idents(segments.iter().map(|seg| seg.ident))
}
pub(crate) fn build_deref_target_impls(

4
src/librustdoc/formats/cache.rs
View file

@ -1,5 +1,6 @@
use std::mem;
use rustc_ast::join_path_syms;
use rustc_attr_data_structures::StabilityLevel;
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet};
@ -13,7 +14,6 @@ use crate::core::DocContext;
use crate::fold::DocFolder;
use crate::formats::Impl;
use crate::formats::item_type::ItemType;
use crate::html::format::join_with_double_colon;
use crate::html::markdown::short_markdown_summary;
use crate::html::render::IndexItem;
use crate::html::render::search_index::get_function_type_for_search;
@ -558,7 +558,7 @@ fn add_item_to_search_index(tcx: TyCtxt<'_>, cache: &mut Cache, item: &clean::It
clean::ItemKind::ImportItem(import) => import.source.did.unwrap_or(item_def_id),
_ => item_def_id,
};
let path = join_with_double_colon(parent_path);
let path = join_path_syms(parent_path);
let impl_id = if let Some(ParentStackItem::Impl { item_id, .. }) = cache.parent_stack.last() {
item_id.as_def_id()
} else {

23
src/librustdoc/html/format.rs
View file

@ -14,6 +14,7 @@ use std::slice;
use itertools::{Either, Itertools};
use rustc_abi::ExternAbi;
use rustc_ast::join_path_syms;
use rustc_attr_data_structures::{ConstStability, StabilityLevel, StableSince};
use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
@ -25,7 +26,7 @@ use rustc_span::symbol::kw;
use rustc_span::{Symbol, sym};
use tracing::{debug, trace};
use super::url_parts_builder::{UrlPartsBuilder, estimate_item_path_byte_length};
use super::url_parts_builder::UrlPartsBuilder;
use crate::clean::types::ExternalLocation;
use crate::clean::utils::find_nearest_parent_module;
use crate::clean::{self, ExternalCrate, PrimitiveType};
@ -369,18 +370,6 @@ pub(crate) enum HrefError {
NotInExternalCache,
}
// Panics if `syms` is empty.
pub(crate) fn join_with_double_colon(syms: &[Symbol]) -> String {
let mut s = String::with_capacity(estimate_item_path_byte_length(syms.len()));
// NOTE: using `Joined::joined` here causes a noticeable perf regression
s.push_str(syms[0].as_str());
for sym in &syms[1..] {
s.push_str("::");
s.push_str(sym.as_str());
}
s
}
/// This function is to get the external macro path because they are not in the cache used in
/// `href_with_root_path`.
fn generate_macro_def_id_path(
@ -672,7 +661,7 @@ pub(crate) fn link_tooltip(
write!(f, "{}", cx.tcx().item_name(id))?;
} else if !fqp.is_empty() {
write!(f, "{shortty} ")?;
fqp.iter().joined("::", f)?;
write!(f, "{}", join_path_syms(fqp))?;
}
Ok(())
})
@ -703,7 +692,7 @@ fn resolved_path(
write!(
f,
"{path}::{anchor}",
path = join_with_double_colon(&fqp[..fqp.len() - 1]),
path = join_path_syms(&fqp[..fqp.len() - 1]),
anchor = print_anchor(did, *fqp.last().unwrap(), cx)
)
} else {
@ -835,7 +824,7 @@ pub(crate) fn print_anchor(did: DefId, text: Symbol, cx: &Context<'_>) -> impl D
write!(
f,
r#"<a class="{short_ty}" href="{url}" title="{short_ty} {path}">{text}</a>"#,
path = join_with_double_colon(&fqp),
path = join_path_syms(fqp),
text = EscapeBodyText(text.as_str()),
)
} else {
@ -1095,7 +1084,7 @@ impl clean::QPathData {
title=\"type {path}::{name}\">{name}</a>",
shortty = ItemType::AssocType,
name = assoc.name,
path = join_with_double_colon(&path),
path = join_path_syms(path),
)
} else {
write!(f, "{}", assoc.name)

4
src/librustdoc/html/render/context.rs
View file

@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
use std::sync::mpsc::{Receiver, channel};
use askama::Template;
use rustc_ast::join_path_syms;
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
use rustc_hir::def_id::{DefIdMap, LOCAL_CRATE};
use rustc_middle::ty::TyCtxt;
@ -27,7 +28,6 @@ use crate::formats::FormatRenderer;
use crate::formats::cache::Cache;
use crate::formats::item_type::ItemType;
use crate::html::escape::Escape;
use crate::html::format::join_with_double_colon;
use crate::html::markdown::{self, ErrorCodes, IdMap, plain_text_summary};
use crate::html::render::write_shared::write_shared;
use crate::html::url_parts_builder::UrlPartsBuilder;
@ -211,7 +211,7 @@ impl<'tcx> Context<'tcx> {
title.push_str(" in ");
}
// No need to include the namespace for primitive types and keywords
title.push_str(&join_with_double_colon(&self.current));
title.push_str(&join_path_syms(&self.current));
};
title.push_str(" - Rust");
let tyname = it.type_();

9
src/librustdoc/html/render/mod.rs
View file

@ -49,6 +49,7 @@ use std::{fs, str};
use askama::Template;
use itertools::Either;
use rustc_ast::join_path_syms;
use rustc_attr_data_structures::{
ConstStability, DeprecatedSince, Deprecation, RustcVersion, StabilityLevel, StableSince,
};
@ -74,9 +75,9 @@ use crate::formats::cache::Cache;
use crate::formats::item_type::ItemType;
use crate::html::escape::Escape;
use crate::html::format::{
Ending, HrefError, PrintWithSpace, href, join_with_double_colon, print_abi_with_space,
print_constness_with_space, print_default_space, print_generic_bounds, print_where_clause,
visibility_print_with_space, write_str,
Ending, HrefError, PrintWithSpace, href, print_abi_with_space, print_constness_with_space,
print_default_space, print_generic_bounds, print_where_clause, visibility_print_with_space,
write_str,
};
use crate::html::markdown::{
HeadingOffset, IdMap, Markdown, MarkdownItemInfo, MarkdownSummaryLine,
@ -2555,7 +2556,7 @@ fn collect_paths_for_type(first_ty: &clean::Type, cache: &Cache) -> Vec<String>
let fqp = cache.exact_paths.get(&did).or_else(get_extern);
if let Some(path) = fqp {
out.push(join_with_double_colon(path));
out.push(join_path_syms(path));
}
};

9
src/librustdoc/html/render/print_item.rs
View file

@ -4,6 +4,7 @@ use std::iter;
use askama::Template;
use rustc_abi::VariantIdx;
use rustc_ast::join_path_syms;
use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
use rustc_hir as hir;
use rustc_hir::def::CtorKind;
@ -30,8 +31,8 @@ use crate::formats::Impl;
use crate::formats::item_type::ItemType;
use crate::html::escape::{Escape, EscapeBodyTextWithWbr};
use crate::html::format::{
Ending, PrintWithSpace, join_with_double_colon, print_abi_with_space,
print_constness_with_space, print_where_clause, visibility_print_with_space,
Ending, PrintWithSpace, print_abi_with_space, print_constness_with_space, print_where_clause,
visibility_print_with_space,
};
use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
use crate::html::render::{document_full, document_item_info};
@ -1424,7 +1425,7 @@ fn item_type_alias(cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) ->
iter::repeat_n("..", cx.current.len()).chain(iter::once("type.impl")).collect();
js_src_path.extend(target_fqp[..target_fqp.len() - 1].iter().copied());
js_src_path.push_fmt(format_args!("{target_type}.{}.js", target_fqp.last().unwrap()));
let self_path = fmt::from_fn(|f| self_fqp.iter().joined("::", f));
let self_path = join_path_syms(self_fqp);
write!(
w,
"<script src=\"{src}\" data-self-path=\"{self_path}\" async></script>",
@ -2256,7 +2257,7 @@ pub(crate) fn compare_names(left: &str, right: &str) -> Ordering {
}
pub(super) fn full_path(cx: &Context<'_>, item: &clean::Item) -> String {
let mut s = join_with_double_colon(&cx.current);
let mut s = join_path_syms(&cx.current);
s.push_str("::");
s.push_str(item.name.unwrap().as_str());
s

14
src/librustdoc/html/render/search_index.rs
View file

@ -4,6 +4,7 @@ use std::collections::hash_map::Entry;
use std::collections::{BTreeMap, VecDeque};
use encode::{bitmap_to_string, write_vlqhex_to_string};
use rustc_ast::join_path_syms;
use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
use rustc_middle::ty::TyCtxt;
use rustc_span::def_id::DefId;
@ -17,7 +18,6 @@ use crate::clean::types::{Function, Generics, ItemId, Type, WherePredicate};
use crate::clean::{self, utils};
use crate::formats::cache::{Cache, OrphanImplItem};
use crate::formats::item_type::ItemType;
use crate::html::format::join_with_double_colon;
use crate::html::markdown::short_markdown_summary;
use crate::html::render::ordered_json::OrderedJson;
use crate::html::render::{self, IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
@ -78,7 +78,7 @@ pub(crate) fn build_index(
ty: item.type_(),
defid: item.item_id.as_def_id(),
name: item.name.unwrap(),
path: join_with_double_colon(&fqp[..fqp.len() - 1]),
path: join_path_syms(&fqp[..fqp.len() - 1]),
desc,
parent: Some(parent),
parent_idx: None,
@ -416,7 +416,7 @@ pub(crate) fn build_index(
if fqp.len() < 2 {
return None;
}
join_with_double_colon(&fqp[..fqp.len() - 1])
join_path_syms(&fqp[..fqp.len() - 1])
};
if path == item.path {
return None;
@ -427,10 +427,10 @@ pub(crate) fn build_index(
let i = <isize as TryInto<usize>>::try_into(parent_idx).unwrap();
item.path = {
let p = &crate_paths[i].1;
join_with_double_colon(&p[..p.len() - 1])
join_path_syms(&p[..p.len() - 1])
};
item.exact_path =
crate_paths[i].2.as_ref().map(|xp| join_with_double_colon(&xp[..xp.len() - 1]));
crate_paths[i].2.as_ref().map(|xp| join_path_syms(&xp[..xp.len() - 1]));
}
// Omit the parent path if it is same to that of the prior item.
@ -549,11 +549,11 @@ pub(crate) fn build_index(
});
continue;
}
let full_path = join_with_double_colon(&path[..path.len() - 1]);
let full_path = join_path_syms(&path[..path.len() - 1]);
let full_exact_path = exact
.as_ref()
.filter(|exact| exact.last() == path.last() && exact.len() >= 2)
.map(|exact| join_with_double_colon(&exact[..exact.len() - 1]));
.map(|exact| join_path_syms(&exact[..exact.len() - 1]));
let exact_path = extra_paths.len() + self.items.len();
let exact_path = full_exact_path.as_ref().map(|full_exact_path| match extra_paths
.entry(full_exact_path.clone())

4
src/librustdoc/html/render/write_shared.rs
View file

@ -26,6 +26,7 @@ use std::{fmt, fs};
use indexmap::IndexMap;
use regex::Regex;
use rustc_ast::join_path_syms;
use rustc_data_structures::flock;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
use rustc_middle::ty::TyCtxt;
@ -43,7 +44,6 @@ use crate::docfs::PathError;
use crate::error::Error;
use crate::formats::Impl;
use crate::formats::item_type::ItemType;
use crate::html::format::join_with_double_colon;
use crate::html::layout;
use crate::html::render::ordered_json::{EscapedJson, OrderedJson};
use crate::html::render::search_index::{SerializedSearchIndex, build_index};
@ -608,7 +608,7 @@ impl TypeAliasPart {
for &(type_alias_fqp, type_alias_item) in type_aliases {
cx.id_map.borrow_mut().clear();
cx.deref_id_map.borrow_mut().clear();
let type_alias_fqp = join_with_double_colon(&type_alias_fqp);
let type_alias_fqp = join_path_syms(type_alias_fqp);
if let Some(ret) = &mut ret {
ret.aliases.push(type_alias_fqp);
} else {

12
src/librustdoc/html/url_parts_builder.rs
View file

@ -117,7 +117,7 @@ impl UrlPartsBuilder {
/// This is just a guess at the average length of a URL part,
/// used for [`String::with_capacity`] calls in the [`FromIterator`]
/// and [`Extend`] impls, and for [estimating item path lengths].
/// and [`Extend`] impls.
///
/// The value `8` was chosen for two main reasons:
///
@ -125,18 +125,8 @@ impl UrlPartsBuilder {
/// * jemalloc's size classes are all multiples of eight,
/// which means that the amount of memory it allocates will often match
/// the amount requested, avoiding wasted bytes.
///
/// [estimating item path lengths]: estimate_item_path_byte_length
const AVG_PART_LENGTH: usize = 8;
/// Estimate the number of bytes in an item's path, based on how many segments it has.
///
/// **Note:** This is only to be used with, e.g., [`String::with_capacity()`];
/// the return value is just a rough estimate.
pub(crate) const fn estimate_item_path_byte_length(segment_count: usize) -> usize {
AVG_PART_LENGTH * segment_count
}
impl<'a> FromIterator<&'a str> for UrlPartsBuilder {
fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
let iter = iter.into_iter();

3
src/tools/clippy/clippy_lints/src/methods/from_iter_instead_of_collect.rs
View file

@ -4,6 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_sugg;
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::implements_trait;
use clippy_utils::{is_path_diagnostic_item, sugg};
use rustc_ast::join_path_idents;
use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::{self as hir, Expr, ExprKind, GenericArg, QPath, TyKind};
@ -47,7 +48,7 @@ fn build_full_type(cx: &LateContext<'_>, hir_ty: &hir::Ty<'_>, app: &mut Applica
&& let QPath::Resolved(None, ty_path) = &ty_qpath
&& let Res::Def(_, ty_did) = ty_path.res
{
let mut ty_str = itertools::join(ty_path.segments.iter().map(|s| s.ident), "::");
let mut ty_str = join_path_idents(ty_path.segments.iter().map(|seg| seg.ident));
let mut first = true;
let mut append = |arg: &str| {
write!(&mut ty_str, "{}{arg}", [", ", "<"][usize::from(first)]).unwrap();

17
src/tools/clippy/clippy_utils/src/lib.rs
View file

@ -89,6 +89,7 @@ use std::sync::{Mutex, MutexGuard, OnceLock};
use itertools::Itertools;
use rustc_abi::Integer;
use rustc_ast::join_path_syms;
use rustc_ast::ast::{self, LitKind, RangeLimits};
use rustc_attr_data_structures::{AttributeKind, find_attr};
use rustc_data_structures::fx::FxHashMap;
@ -3245,8 +3246,8 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
// a::b::c ::d::sym refers to
// e::f::sym:: ::
// result should be super::super::super::super::e::f
if let DefPathData::TypeNs(s) = l {
path.push(s.to_string());
if let DefPathData::TypeNs(sym) = l {
path.push(sym);
}
if let DefPathData::TypeNs(_) = r {
go_up_by += 1;
@ -3256,7 +3257,7 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
// a::b::sym:: :: refers to
// c::d::e ::f::sym
// when looking at `f`
Left(DefPathData::TypeNs(sym)) => path.push(sym.to_string()),
Left(DefPathData::TypeNs(sym)) => path.push(sym),
// consider:
// a::b::c ::d::sym refers to
// e::f::sym:: ::
@ -3268,17 +3269,17 @@ fn maybe_get_relative_path(from: &DefPath, to: &DefPath, max_super: usize) -> St
if go_up_by > max_super {
// `super` chain would be too long, just use the absolute path instead
once(String::from("crate"))
.chain(to.data.iter().filter_map(|el| {
join_path_syms(
once(kw::Crate).chain(to.data.iter().filter_map(|el| {
if let DefPathData::TypeNs(sym) = el.data {
Some(sym.to_string())
Some(sym)
} else {
None
}
}))
.join("::")
)
} else {
repeat_n(String::from("super"), go_up_by).chain(path).join("::")
join_path_syms(repeat_n(kw::Super, go_up_by).chain(path))
}
}

2
tests/ui/asm/naked-invalid-attr.stderr
View file

@ -8,7 +8,7 @@ error[E0736]: attribute incompatible with `#[unsafe(naked)]`
--> $DIR/naked-invalid-attr.rs:56:3
|
LL | #[::a]
| ^^^ the `{{root}}::a` attribute is incompatible with `#[unsafe(naked)]`
| ^^^ the `::a` attribute is incompatible with `#[unsafe(naked)]`
...
LL | #[unsafe(naked)]
| ---------------- function marked with `#[unsafe(naked)]` here