crates/hir_def/src/data.rs

   1 //! Contains basic data about various HIR declarations.
   2
   3 use std::sync::Arc;
   4
   5 use hir_expand::{name::Name, AstId, ExpandResult, InFile};
   6 use syntax::ast;
   7
   8 use crate::{
   9     attr::Attrs,
  10     body::{Expander, Mark},
  11     db::DefDatabase,
  12     intern::Interned,
  13     item_tree::{self, AssocItem, FnFlags, ItemTreeId, ModItem, Param},
  14     nameres::attr_resolution::ResolvedAttr,
  15     type_ref::{TraitRef, TypeBound, TypeRef},
  16     visibility::RawVisibility,
  17     AssocItemId, AstIdWithPath, ConstId, ConstLoc, FunctionId, FunctionLoc, HasModule, ImplId,
  18     Intern, ItemContainerId, Lookup, ModuleId, StaticId, TraitId, TypeAliasId, TypeAliasLoc,
  19 };
  20
  21 #[derive(Debug, Clone, PartialEq, Eq)]
  22 pub struct FunctionData {
  23     pub name: Name,
  24     pub params: Vec<(Option<Name>, Interned<TypeRef>)>,
  25     pub ret_type: Interned<TypeRef>,
  26     pub async_ret_type: Option<Interned<TypeRef>>,
  27     pub attrs: Attrs,
  28     pub visibility: RawVisibility,
  29     pub abi: Option<Interned<str>>,
  30     pub legacy_const_generics_indices: Vec<u32>,
  31     flags: FnFlags,
  32 }
  33
  34 impl FunctionData {
  35     pub(crate) fn fn_data_query(db: &dyn DefDatabase, func: FunctionId) -> Arc<FunctionData> {
  36         let loc = func.lookup(db);
  37         let krate = loc.container.module(db).krate;
  38         let crate_graph = db.crate_graph();
  39         let cfg_options = &crate_graph[krate].cfg_options;
  40         let item_tree = loc.id.item_tree(db);
  41         let func = &item_tree[loc.id.value];
  42
  43         let enabled_params = func
  44             .params
  45             .clone()
  46             .filter(|&param| item_tree.attrs(db, krate, param.into()).is_cfg_enabled(cfg_options));
  47
  48         // If last cfg-enabled param is a `...` param, it's a varargs function.
  49         let is_varargs = enabled_params
  50             .clone()
  51             .next_back()
  52             .map_or(false, |param| matches!(item_tree[param], Param::Varargs));
  53
  54         let mut flags = func.flags;
  55         if is_varargs {
  56             flags.bits |= FnFlags::IS_VARARGS;
  57         }
  58
  59         if matches!(loc.container, ItemContainerId::ExternBlockId(_)) {
  60             flags.bits |= FnFlags::IS_IN_EXTERN_BLOCK;
  61         }
  62
  63         let legacy_const_generics_indices = item_tree
  64             .attrs(db, krate, ModItem::from(loc.id.value).into())
  65             .by_key("rustc_legacy_const_generics")
  66             .tt_values()
  67             .next()
  68             .map(|arg| parse_rustc_legacy_const_generics(arg))
  69             .unwrap_or_default();
  70
  71         Arc::new(FunctionData {
  72             name: func.name.clone(),
  73             params: enabled_params
  74                 .clone()
  75                 .filter_map(|id| match &item_tree[id] {
  76                     Param::Normal(name, ty) => Some((name.clone(), ty.clone())),
  77                     Param::Varargs => None,
  78                 })
  79                 .collect(),
  80             ret_type: func.ret_type.clone(),
  81             async_ret_type: func.async_ret_type.clone(),
  82             attrs: item_tree.attrs(db, krate, ModItem::from(loc.id.value).into()),
  83             visibility: item_tree[func.visibility].clone(),
  84             abi: func.abi.clone(),
  85             legacy_const_generics_indices,
  86             flags,
  87         })
  88     }
  89
  90     pub fn has_body(&self) -> bool {
  91         self.flags.bits & FnFlags::HAS_BODY != 0
  92     }
  93
  94     /// True if the first param is `self`. This is relevant to decide whether this
  95     /// can be called as a method.
  96     pub fn has_self_param(&self) -> bool {
  97         self.flags.bits & FnFlags::HAS_SELF_PARAM != 0
  98     }
  99
 100     pub fn is_default(&self) -> bool {
 101         self.flags.bits & FnFlags::IS_DEFAULT != 0
 102     }
 103
 104     pub fn is_const(&self) -> bool {
 105         self.flags.bits & FnFlags::IS_CONST != 0
 106     }
 107
 108     pub fn is_async(&self) -> bool {
 109         self.flags.bits & FnFlags::IS_ASYNC != 0
 110     }
 111
 112     pub fn is_unsafe(&self) -> bool {
 113         self.flags.bits & FnFlags::IS_UNSAFE != 0
 114     }
 115
 116     pub fn is_in_extern_block(&self) -> bool {
 117         self.flags.bits & FnFlags::IS_IN_EXTERN_BLOCK != 0
 118     }
 119
 120     pub fn is_varargs(&self) -> bool {
 121         self.flags.bits & FnFlags::IS_VARARGS != 0
 122     }
 123 }
 124
 125 fn parse_rustc_legacy_const_generics(tt: &tt::Subtree) -> Vec<u32> {
 126     let mut indices = Vec::new();
 127     for args in tt.token_trees.chunks(2) {
 128         match &args[0] {
 129             tt::TokenTree::Leaf(tt::Leaf::Literal(lit)) => match lit.text.parse() {
 130                 Ok(index) => indices.push(index),
 131                 Err(_) => break,
 132             },
 133             _ => break,
 134         }
 135
 136         if let Some(comma) = args.get(1) {
 137             match comma {
 138                 tt::TokenTree::Leaf(tt::Leaf::Punct(punct)) if punct.char == ',' => {}
 139                 _ => break,
 140             }
 141         }
 142     }
 143
 144     indices
 145 }
 146
 147 #[derive(Debug, Clone, PartialEq, Eq)]
 148 pub struct TypeAliasData {
 149     pub name: Name,
 150     pub type_ref: Option<Interned<TypeRef>>,
 151     pub visibility: RawVisibility,
 152     pub is_extern: bool,
 153     /// Bounds restricting the type alias itself (eg. `type Ty: Bound;` in a trait or impl).
 154     pub bounds: Vec<Interned<TypeBound>>,
 155 }
 156
 157 impl TypeAliasData {
 158     pub(crate) fn type_alias_data_query(
 159         db: &dyn DefDatabase,
 160         typ: TypeAliasId,
 161     ) -> Arc<TypeAliasData> {
 162         let loc = typ.lookup(db);
 163         let item_tree = loc.id.item_tree(db);
 164         let typ = &item_tree[loc.id.value];
 165
 166         Arc::new(TypeAliasData {
 167             name: typ.name.clone(),
 168             type_ref: typ.type_ref.clone(),
 169             visibility: item_tree[typ.visibility].clone(),
 170             is_extern: matches!(loc.container, ItemContainerId::ExternBlockId(_)),
 171             bounds: typ.bounds.to_vec(),
 172         })
 173     }
 174 }
 175
 176 #[derive(Debug, Clone, PartialEq, Eq)]
 177 pub struct TraitData {
 178     pub name: Name,
 179     pub items: Vec<(Name, AssocItemId)>,
 180     pub is_auto: bool,
 181     pub is_unsafe: bool,
 182     pub visibility: RawVisibility,
 183     /// Whether the trait has `#[rust_skip_array_during_method_dispatch]`. `hir_ty` will ignore
 184     /// method calls to this trait's methods when the receiver is an array and the crate edition is
 185     /// 2015 or 2018.
 186     pub skip_array_during_method_dispatch: bool,
 187 }
 188
 189 impl TraitData {
 190     pub(crate) fn trait_data_query(db: &dyn DefDatabase, tr: TraitId) -> Arc<TraitData> {
 191         let tr_loc = tr.lookup(db);
 192         let item_tree = tr_loc.id.item_tree(db);
 193         let tr_def = &item_tree[tr_loc.id.value];
 194         let _cx = stdx::panic_context::enter(format!(
 195             "trait_data_query({:?} -> {:?} -> {:?})",
 196             tr, tr_loc, tr_def
 197         ));
 198         let name = tr_def.name.clone();
 199         let is_auto = tr_def.is_auto;
 200         let is_unsafe = tr_def.is_unsafe;
 201         let module_id = tr_loc.container;
 202         let container = ItemContainerId::TraitId(tr);
 203         let visibility = item_tree[tr_def.visibility].clone();
 204         let mut expander = Expander::new(db, tr_loc.id.file_id(), module_id);
 205         let skip_array_during_method_dispatch = item_tree
 206             .attrs(db, tr_loc.container.krate(), ModItem::from(tr_loc.id.value).into())
 207             .by_key("rustc_skip_array_during_method_dispatch")
 208             .exists();
 209
 210         let items = collect_items(
 211             db,
 212             module_id,
 213             &mut expander,
 214             tr_def.items.iter().copied(),
 215             tr_loc.id.tree_id(),
 216             container,
 217             100,
 218         );
 219
 220         Arc::new(TraitData {
 221             name,
 222             items,
 223             is_auto,
 224             is_unsafe,
 225             visibility,
 226             skip_array_during_method_dispatch,
 227         })
 228     }
 229
 230     pub fn associated_types(&self) -> impl Iterator<Item = TypeAliasId> + '_ {
 231         self.items.iter().filter_map(|(_name, item)| match item {
 232             AssocItemId::TypeAliasId(t) => Some(*t),
 233             _ => None,
 234         })
 235     }
 236
 237     pub fn associated_type_by_name(&self, name: &Name) -> Option<TypeAliasId> {
 238         self.items.iter().find_map(|(item_name, item)| match item {
 239             AssocItemId::TypeAliasId(t) if item_name == name => Some(*t),
 240             _ => None,
 241         })
 242     }
 243
 244     pub fn method_by_name(&self, name: &Name) -> Option<FunctionId> {
 245         self.items.iter().find_map(|(item_name, item)| match item {
 246             AssocItemId::FunctionId(t) if item_name == name => Some(*t),
 247             _ => None,
 248         })
 249     }
 250 }
 251
 252 #[derive(Debug, Clone, PartialEq, Eq)]
 253 pub struct ImplData {
 254     pub target_trait: Option<Interned<TraitRef>>,
 255     pub self_ty: Interned<TypeRef>,
 256     pub items: Vec<AssocItemId>,
 257     pub is_negative: bool,
 258 }
 259
 260 impl ImplData {
 261     pub(crate) fn impl_data_query(db: &dyn DefDatabase, id: ImplId) -> Arc<ImplData> {
 262         let _p = profile::span("impl_data_query");
 263         let impl_loc = id.lookup(db);
 264
 265         let item_tree = impl_loc.id.item_tree(db);
 266         let impl_def = &item_tree[impl_loc.id.value];
 267         let target_trait = impl_def.target_trait.clone();
 268         let self_ty = impl_def.self_ty.clone();
 269         let is_negative = impl_def.is_negative;
 270         let module_id = impl_loc.container;
 271         let container = ItemContainerId::ImplId(id);
 272         let mut expander = Expander::new(db, impl_loc.id.file_id(), module_id);
 273
 274         let items = collect_items(
 275             db,
 276             module_id,
 277             &mut expander,
 278             impl_def.items.iter().copied(),
 279             impl_loc.id.tree_id(),
 280             container,
 281             100,
 282         );
 283         let items = items.into_iter().map(|(_, item)| item).collect();
 284
 285         Arc::new(ImplData { target_trait, self_ty, items, is_negative })
 286     }
 287 }
 288
 289 #[derive(Debug, Clone, PartialEq, Eq)]
 290 pub struct ConstData {
 291     /// `None` for `const _: () = ();`
 292     pub name: Option<Name>,
 293     pub type_ref: Interned<TypeRef>,
 294     pub visibility: RawVisibility,
 295 }
 296
 297 impl ConstData {
 298     pub(crate) fn const_data_query(db: &dyn DefDatabase, konst: ConstId) -> Arc<ConstData> {
 299         let loc = konst.lookup(db);
 300         let item_tree = loc.id.item_tree(db);
 301         let konst = &item_tree[loc.id.value];
 302
 303         Arc::new(ConstData {
 304             name: konst.name.clone(),
 305             type_ref: konst.type_ref.clone(),
 306             visibility: item_tree[konst.visibility].clone(),
 307         })
 308     }
 309 }
 310
 311 #[derive(Debug, Clone, PartialEq, Eq)]
 312 pub struct StaticData {
 313     pub name: Name,
 314     pub type_ref: Interned<TypeRef>,
 315     pub visibility: RawVisibility,
 316     pub mutable: bool,
 317     pub is_extern: bool,
 318 }
 319
 320 impl StaticData {
 321     pub(crate) fn static_data_query(db: &dyn DefDatabase, konst: StaticId) -> Arc<StaticData> {
 322         let loc = konst.lookup(db);
 323         let item_tree = loc.id.item_tree(db);
 324         let statik = &item_tree[loc.id.value];
 325
 326         Arc::new(StaticData {
 327             name: statik.name.clone(),
 328             type_ref: statik.type_ref.clone(),
 329             visibility: item_tree[statik.visibility].clone(),
 330             mutable: statik.mutable,
 331             is_extern: matches!(loc.container, ItemContainerId::ExternBlockId(_)),
 332         })
 333     }
 334 }
 335
 336 fn collect_items(
 337     db: &dyn DefDatabase,
 338     module: ModuleId,
 339     expander: &mut Expander,
 340     assoc_items: impl Iterator<Item = AssocItem>,
 341     tree_id: item_tree::TreeId,
 342     container: ItemContainerId,
 343     limit: usize,
 344 ) -> Vec<(Name, AssocItemId)> {
 345     if limit == 0 {
 346         return Vec::new();
 347     }
 348
 349     let item_tree = tree_id.item_tree(db);
 350     let crate_graph = db.crate_graph();
 351     let cfg_options = &crate_graph[module.krate].cfg_options;
 352     let def_map = module.def_map(db);
 353
 354     let mut items = Vec::new();
 355     'items: for item in assoc_items {
 356         let attrs = item_tree.attrs(db, module.krate, ModItem::from(item).into());
 357         if !attrs.is_cfg_enabled(cfg_options) {
 358             continue;
 359         }
 360
 361         for attr in &*attrs {
 362             let ast_id = AstIdWithPath {
 363                 path: (*attr.path).clone(),
 364                 ast_id: AstId::new(expander.current_file_id(), item.ast_id(&item_tree).upcast()),
 365             };
 366             if let Ok(ResolvedAttr::Macro(call_id)) =
 367                 def_map.resolve_attr_macro(db, module.local_id, ast_id, attr)
 368             {
 369                 let res = expander.enter_expand_id(db, call_id);
 370                 items.extend(collect_macro_items(db, module, expander, container, limit, res));
 371                 continue 'items;
 372             }
 373         }
 374
 375         match item {
 376             AssocItem::Function(id) => {
 377                 let item = &item_tree[id];
 378                 let def = FunctionLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
 379                 items.push((item.name.clone(), def.into()));
 380             }
 381             AssocItem::Const(id) => {
 382                 let item = &item_tree[id];
 383                 let name = match item.name.clone() {
 384                     Some(name) => name,
 385                     None => continue,
 386                 };
 387                 let def = ConstLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
 388                 items.push((name, def.into()));
 389             }
 390             AssocItem::TypeAlias(id) => {
 391                 let item = &item_tree[id];
 392                 let def = TypeAliasLoc { container, id: ItemTreeId::new(tree_id, id) }.intern(db);
 393                 items.push((item.name.clone(), def.into()));
 394             }
 395             AssocItem::MacroCall(call) => {
 396                 let call = &item_tree[call];
 397                 let ast_id_map = db.ast_id_map(tree_id.file_id());
 398                 let root = db.parse_or_expand(tree_id.file_id()).unwrap();
 399                 let call = ast_id_map.get(call.ast_id).to_node(&root);
 400                 let _cx = stdx::panic_context::enter(format!("collect_items MacroCall: {}", call));
 401                 let res = expander.enter_expand(db, call);
 402
 403                 if let Ok(res) = res {
 404                     items.extend(collect_macro_items(db, module, expander, container, limit, res));
 405                 }
 406             }
 407         }
 408     }
 409
 410     items
 411 }
 412
 413 fn collect_macro_items(
 414     db: &dyn DefDatabase,
 415     module: ModuleId,
 416     expander: &mut Expander,
 417     container: ItemContainerId,
 418     limit: usize,
 419     res: ExpandResult<Option<(Mark, ast::MacroItems)>>,
 420 ) -> Vec<(Name, AssocItemId)> {
 421     if let Some((mark, mac)) = res.value {
 422         let src: InFile<ast::MacroItems> = expander.to_source(mac);
 423         let tree_id = item_tree::TreeId::new(src.file_id, None);
 424         let item_tree = tree_id.item_tree(db);
 425         let iter = item_tree.top_level_items().iter().filter_map(ModItem::as_assoc_item);
 426         let items = collect_items(db, module, expander, iter, tree_id, container, limit - 1);
 427
 428         expander.exit(db, mark);
 429
 430         return items;
 431     }
 432
 433     Vec::new()
 434 }