1use crate::{MaybePath, path_def_id, sym};
8use rustc_ast::Mutability;
9use rustc_data_structures::fx::FxHashMap;
10use rustc_hir::def::Namespace::{MacroNS, TypeNS, ValueNS};
11use rustc_hir::def::{DefKind, Namespace, Res};
12use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
13use rustc_hir::{ImplItemRef, ItemKind, Node, OwnerId, TraitItemRef, UseKind};
14use rustc_lint::LateContext;
15use rustc_middle::ty::fast_reject::SimplifiedType;
16use rustc_middle::ty::{FloatTy, IntTy, Ty, TyCtxt, UintTy};
17use rustc_span::{Ident, STDLIB_STABLE_CRATES, Symbol};
18use std::sync::OnceLock;
19
20#[derive(Clone, Copy, PartialEq, Debug)]
23pub enum PathNS {
24 Type,
25 Value,
26 Macro,
27
28 Arbitrary,
34}
35
36impl PathNS {
37 fn matches(self, ns: Option<Namespace>) -> bool {
38 let required = match self {
39 PathNS::Type => TypeNS,
40 PathNS::Value => ValueNS,
41 PathNS::Macro => MacroNS,
42 PathNS::Arbitrary => return true,
43 };
44
45 ns == Some(required)
46 }
47}
48
49pub struct PathLookup {
60 ns: PathNS,
61 path: &'static [Symbol],
62 once: OnceLock<Vec<DefId>>,
63}
64
65impl PathLookup {
66 #[doc(hidden)]
68 pub const fn new(ns: PathNS, path: &'static [Symbol]) -> Self {
69 Self {
70 ns,
71 path,
72 once: OnceLock::new(),
73 }
74 }
75
76 pub fn get(&self, cx: &LateContext<'_>) -> &[DefId] {
78 self.once.get_or_init(|| lookup_path(cx.tcx, self.ns, self.path))
79 }
80
81 pub fn only(&self, cx: &LateContext<'_>) -> Option<DefId> {
86 let ids = self.get(cx);
87 debug_assert!(STDLIB_STABLE_CRATES.contains(&self.path[0]));
88 debug_assert!(ids.len() <= 1, "{ids:?}");
89 ids.first().copied()
90 }
91
92 pub fn matches(&self, cx: &LateContext<'_>, def_id: DefId) -> bool {
94 self.get(cx).contains(&def_id)
95 }
96
97 pub fn matches_path<'tcx>(&self, cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> bool {
99 path_def_id(cx, maybe_path).is_some_and(|def_id| self.matches(cx, def_id))
100 }
101
102 pub fn matches_ty(&self, cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
104 ty.ty_adt_def().is_some_and(|adt| self.matches(cx, adt.did()))
105 }
106}
107
108macro_rules! path_macros {
109 ($($name:ident: $ns:expr,)*) => {
110 $(
111 #[doc(hidden)]
113 #[macro_export]
114 macro_rules! $name {
115 ($$($$seg:ident $$(::)?)*) => {
116 PathLookup::new($ns, &[$$(sym::$$seg,)*])
117 };
118 }
119 )*
120 };
121}
122
123path_macros! {
124 type_path: PathNS::Type,
125 value_path: PathNS::Value,
126 macro_path: PathNS::Macro,
127}
128
129pub static ALIGN_OF: PathLookup = value_path!(core::mem::align_of);
131pub static CHAR_TO_DIGIT: PathLookup = value_path!(char::to_digit);
132pub static CONCAT: PathLookup = macro_path!(core::concat);
133pub static IO_ERROR_NEW: PathLookup = value_path!(std::io::Error::new);
134pub static IO_ERRORKIND_OTHER_CTOR: PathLookup = value_path!(std::io::ErrorKind::Other);
135pub static ITER_STEP: PathLookup = type_path!(core::iter::Step);
136pub static SLICE_FROM_REF: PathLookup = value_path!(core::slice::from_ref);
137
138pub static FUTURES_IO_ASYNCREADEXT: PathLookup = type_path!(futures_util::AsyncReadExt);
140pub static FUTURES_IO_ASYNCWRITEEXT: PathLookup = type_path!(futures_util::AsyncWriteExt);
141pub static ITERTOOLS_NEXT_TUPLE: PathLookup = value_path!(itertools::Itertools::next_tuple);
142pub static PARKING_LOT_GUARDS: [PathLookup; 3] = [
143 type_path!(lock_api::mutex::MutexGuard),
144 type_path!(lock_api::rwlock::RwLockReadGuard),
145 type_path!(lock_api::rwlock::RwLockWriteGuard),
146];
147pub static REGEX_BUILDER_NEW: PathLookup = value_path!(regex::RegexBuilder::new);
148pub static REGEX_BYTES_BUILDER_NEW: PathLookup = value_path!(regex::bytes::RegexBuilder::new);
149pub static REGEX_BYTES_NEW: PathLookup = value_path!(regex::bytes::Regex::new);
150pub static REGEX_BYTES_SET_NEW: PathLookup = value_path!(regex::bytes::RegexSet::new);
151pub static REGEX_NEW: PathLookup = value_path!(regex::Regex::new);
152pub static REGEX_SET_NEW: PathLookup = value_path!(regex::RegexSet::new);
153pub static SERDE_DESERIALIZE: PathLookup = type_path!(serde::de::Deserialize);
154pub static SERDE_DE_VISITOR: PathLookup = type_path!(serde::de::Visitor);
155pub static TOKIO_FILE_OPTIONS: PathLookup = value_path!(tokio::fs::File::options);
156pub static TOKIO_IO_ASYNCREADEXT: PathLookup = type_path!(tokio::io::AsyncReadExt);
157pub static TOKIO_IO_ASYNCWRITEEXT: PathLookup = type_path!(tokio::io::AsyncWriteExt);
158pub static TOKIO_IO_OPEN_OPTIONS: PathLookup = type_path!(tokio::fs::OpenOptions);
159pub static TOKIO_IO_OPEN_OPTIONS_NEW: PathLookup = value_path!(tokio::fs::OpenOptions::new);
160pub static LAZY_STATIC: PathLookup = macro_path!(lazy_static::lazy_static);
161pub static ONCE_CELL_SYNC_LAZY: PathLookup = type_path!(once_cell::sync::Lazy);
162pub static ONCE_CELL_SYNC_LAZY_NEW: PathLookup = value_path!(once_cell::sync::Lazy::new);
163
164pub fn lookup_path_str(tcx: TyCtxt<'_>, ns: PathNS, path: &str) -> Vec<DefId> {
170 let path: Vec<Symbol> = path.split("::").map(Symbol::intern).collect();
171 lookup_path(tcx, ns, &path)
172}
173
174pub fn lookup_path(tcx: TyCtxt<'_>, ns: PathNS, path: &[Symbol]) -> Vec<DefId> {
187 let (root, rest) = match *path {
188 [] | [_] => return Vec::new(),
189 [root, ref rest @ ..] => (root, rest),
190 };
191
192 let mut out = Vec::new();
193 for &base in find_crates(tcx, root).iter().chain(find_primitive_impls(tcx, root)) {
194 lookup_with_base(tcx, base, ns, rest, &mut out);
195 }
196 out
197}
198
199pub fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> &'static [DefId] {
201 static BY_NAME: OnceLock<FxHashMap<Symbol, Vec<DefId>>> = OnceLock::new();
202 let map = BY_NAME.get_or_init(|| {
203 let mut map = FxHashMap::default();
204 map.insert(tcx.crate_name(LOCAL_CRATE), vec![LOCAL_CRATE.as_def_id()]);
205 for &num in tcx.crates(()) {
206 map.entry(tcx.crate_name(num)).or_default().push(num.as_def_id());
207 }
208 map
209 });
210 match map.get(&name) {
211 Some(def_ids) => def_ids,
212 None => &[],
213 }
214}
215
216fn find_primitive_impls(tcx: TyCtxt<'_>, name: Symbol) -> &[DefId] {
217 let ty = match name {
218 sym::bool => SimplifiedType::Bool,
219 sym::char => SimplifiedType::Char,
220 sym::str => SimplifiedType::Str,
221 sym::array => SimplifiedType::Array,
222 sym::slice => SimplifiedType::Slice,
223 sym::const_ptr => SimplifiedType::Ptr(Mutability::Not),
227 sym::mut_ptr => SimplifiedType::Ptr(Mutability::Mut),
228 sym::isize => SimplifiedType::Int(IntTy::Isize),
229 sym::i8 => SimplifiedType::Int(IntTy::I8),
230 sym::i16 => SimplifiedType::Int(IntTy::I16),
231 sym::i32 => SimplifiedType::Int(IntTy::I32),
232 sym::i64 => SimplifiedType::Int(IntTy::I64),
233 sym::i128 => SimplifiedType::Int(IntTy::I128),
234 sym::usize => SimplifiedType::Uint(UintTy::Usize),
235 sym::u8 => SimplifiedType::Uint(UintTy::U8),
236 sym::u16 => SimplifiedType::Uint(UintTy::U16),
237 sym::u32 => SimplifiedType::Uint(UintTy::U32),
238 sym::u64 => SimplifiedType::Uint(UintTy::U64),
239 sym::u128 => SimplifiedType::Uint(UintTy::U128),
240 sym::f32 => SimplifiedType::Float(FloatTy::F32),
241 sym::f64 => SimplifiedType::Float(FloatTy::F64),
242 _ => return &[],
243 };
244
245 tcx.incoherent_impls(ty)
246}
247
248fn lookup_with_base(tcx: TyCtxt<'_>, mut base: DefId, ns: PathNS, mut path: &[Symbol], out: &mut Vec<DefId>) {
250 loop {
251 match *path {
252 [segment] => {
253 out.extend(item_child_by_name(tcx, base, ns, segment));
254
255 let inherent_impl_children = tcx
258 .inherent_impls(base)
259 .iter()
260 .filter_map(|&impl_def_id| item_child_by_name(tcx, impl_def_id, ns, segment));
261 out.extend(inherent_impl_children);
262
263 return;
264 },
265 [segment, ref rest @ ..] => {
266 path = rest;
267 let Some(child) = item_child_by_name(tcx, base, PathNS::Type, segment) else {
268 return;
269 };
270 base = child;
271 },
272 [] => unreachable!(),
273 }
274 }
275}
276
277fn item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, ns: PathNS, name: Symbol) -> Option<DefId> {
278 if let Some(local_id) = def_id.as_local() {
279 local_item_child_by_name(tcx, local_id, ns, name)
280 } else {
281 non_local_item_child_by_name(tcx, def_id, ns, name)
282 }
283}
284
285fn local_item_child_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, ns: PathNS, name: Symbol) -> Option<DefId> {
286 let root_mod;
287 let item_kind = match tcx.hir_node_by_def_id(local_id) {
288 Node::Crate(r#mod) => {
289 root_mod = ItemKind::Mod(Ident::dummy(), r#mod);
290 &root_mod
291 },
292 Node::Item(item) => &item.kind,
293 _ => return None,
294 };
295
296 let res = |ident: Ident, owner_id: OwnerId| {
297 if ident.name == name && ns.matches(tcx.def_kind(owner_id).ns()) {
298 Some(owner_id.to_def_id())
299 } else {
300 None
301 }
302 };
303
304 match item_kind {
305 ItemKind::Mod(_, r#mod) => r#mod.item_ids.iter().find_map(|&item_id| {
306 let item = tcx.hir_item(item_id);
307 if let ItemKind::Use(path, UseKind::Single(ident)) = item.kind {
308 if ident.name == name {
309 path.res
310 .iter()
311 .find(|res| ns.matches(res.ns()))
312 .and_then(Res::opt_def_id)
313 } else {
314 None
315 }
316 } else {
317 res(item.kind.ident()?, item_id.owner_id)
318 }
319 }),
320 ItemKind::Impl(r#impl) => r#impl
321 .items
322 .iter()
323 .find_map(|&ImplItemRef { ident, id, .. }| res(ident, id.owner_id)),
324 ItemKind::Trait(.., trait_item_refs) => trait_item_refs
325 .iter()
326 .find_map(|&TraitItemRef { ident, id, .. }| res(ident, id.owner_id)),
327 _ => None,
328 }
329}
330
331fn non_local_item_child_by_name(tcx: TyCtxt<'_>, def_id: DefId, ns: PathNS, name: Symbol) -> Option<DefId> {
332 match tcx.def_kind(def_id) {
333 DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx.module_children(def_id).iter().find_map(|child| {
334 if child.ident.name == name && ns.matches(child.res.ns()) {
335 child.res.opt_def_id()
336 } else {
337 None
338 }
339 }),
340 DefKind::Impl { .. } => tcx
341 .associated_item_def_ids(def_id)
342 .iter()
343 .copied()
344 .find(|assoc_def_id| tcx.item_name(*assoc_def_id) == name && ns.matches(tcx.def_kind(assoc_def_id).ns())),
345 _ => None,
346 }
347}