use rustc_hash::FxHashMap;

/// Ignored attribute namespaces used by tools.

pub const TOOL_MODULES: &[&str] = &["rustfmt", "clippy"];

pub struct BuiltinAttribute {

pub name: &'static str,

pub template: AttributeTemplate,

LocalModuleId, Lookup, MacroExpander, MacroId, ModuleId, ProcMacroId, UseId,

};

const PREDEFINED_TOOLS: &[SmolStr] = &[

SmolStr::new_static("clippy"),

SmolStr::new_static("rustfmt"),

SmolStr::new_static("diagnostic"),

SmolStr::new_static("miri"),

SmolStr::new_static("rust_analyzer"),

];

/// Contains the results of (early) name resolution.

///

/// A `DefMap` stores the module tree and the definitions that are in scope in every module after

fn_proc_macro_mapping: FxHashMap::default(),

proc_macro_loading_error: None,

registered_attrs: Vec::new(),

registered_tools: Vec::new(),

registered_tools: PREDEFINED_TOOLS.into(),

unstable_features: FxHashSet::default(),

rustc_coherence_is_core: false,

no_core: false,

use triomphe::Arc;

use crate::{

attr::builtin::{find_builtin_attr_idx, TOOL_MODULES},

attr::builtin::find_builtin_attr_idx,

db::DefDatabase,

item_scope::BuiltinShadowMode,

nameres::path_resolution::ResolveMode,

let name = name.to_smol_str();

let pred = |n: &_| *n == name;

let registered = self.data.registered_tools.iter().map(SmolStr::as_str);

let is_tool = TOOL_MODULES.iter().copied().chain(registered).any(pred);

let is_tool = self.data.registered_tools.iter().map(SmolStr::as_str).any(pred);

// FIXME: tool modules can be shadowed by actual modules

if is_tool {

return true;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]

pub struct ToolModule {

krate: Option<CrateId>,

krate: CrateId,

idx: u32,

}

impl ToolModule {

// FIXME: consider crates\hir_def\src\nameres\attr_resolution.rs?

pub(crate) fn by_name(db: &dyn HirDatabase, krate: Crate, name: &str) -> Option<Self> {

if let builtin @ Some(_) = Self::builtin(name) {

return builtin;

}

let krate = krate.id;

let idx =

db.crate_def_map(krate.id).registered_tools().iter().position(|it| it == name)? as u32;

Some(ToolModule { krate: Some(krate.id), idx })

}

fn builtin(name: &str) -> Option<Self> {

hir_def::attr::builtin::TOOL_MODULES

.iter()

.position(|&tool| tool == name)

.map(|idx| ToolModule { krate: None, idx: idx as u32 })

db.crate_def_map(krate).registered_tools().iter().position(|it| it == name)? as u32;

Some(ToolModule { krate, idx })

}

pub fn name(&self, db: &dyn HirDatabase) -> SmolStr {

// FIXME: Return a `Name` here

match self.krate {

Some(krate) => db.crate_def_map(krate).registered_tools()[self.idx as usize].clone(),

None => SmolStr::new(hir_def::attr::builtin::TOOL_MODULES[self.idx as usize]),

}

db.crate_def_map(self.krate).registered_tools()[self.idx as usize].clone()

}

}