crates/ra_hir/src/code_model_api.rs

   1 use std::sync::Arc;
   2
   3 use relative_path::RelativePathBuf;
   4 use ra_db::{CrateId, SourceRootId, Edition};
   5 use ra_syntax::{ast::self, TreeArc, SyntaxNode};
   6
   7 use crate::{
   8     Name, ScopesWithSyntaxMapping, Ty, HirFileId,
   9     HirDatabase, PersistentHirDatabase,
  10     type_ref::TypeRef,
  11     nameres::{ModuleScope, Namespace, lower::ImportId},
  12     expr::{Body, BodySyntaxMapping},
  13     ty::InferenceResult,
  14     adt::{EnumVariantId, StructFieldId, VariantDef},
  15     generics::GenericParams,
  16     docs::{Documentation, Docs, docs_from_ast},
  17     module_tree::ModuleId,
  18     ids::{FunctionId, StructId, EnumId, AstItemDef, ConstId, StaticId, TraitId, TypeId},
  19     impl_block::ImplBlock,
  20     resolve::Resolver,
  21 };
  22
  23 /// hir::Crate describes a single crate. It's the main interface with which
  24 /// a crate's dependencies interact. Mostly, it should be just a proxy for the
  25 /// root module.
  26 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  27 pub struct Crate {
  28     pub(crate) crate_id: CrateId,
  29 }
  30
  31 #[derive(Debug)]
  32 pub struct CrateDependency {
  33     pub krate: Crate,
  34     pub name: Name,
  35 }
  36
  37 impl Crate {
  38     pub fn crate_id(&self) -> CrateId {
  39         self.crate_id
  40     }
  41
  42     pub fn dependencies(&self, db: &impl PersistentHirDatabase) -> Vec<CrateDependency> {
  43         self.dependencies_impl(db)
  44     }
  45
  46     pub fn root_module(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
  47         self.root_module_impl(db)
  48     }
  49
  50     pub fn edition(&self, db: &impl PersistentHirDatabase) -> Edition {
  51         let crate_graph = db.crate_graph();
  52         crate_graph.edition(self.crate_id)
  53     }
  54
  55     // TODO: should this be in source_binder?
  56     pub fn source_root_crates(
  57         db: &impl PersistentHirDatabase,
  58         source_root: SourceRootId,
  59     ) -> Vec<Crate> {
  60         let crate_ids = db.source_root_crates(source_root);
  61         crate_ids.iter().map(|&crate_id| Crate { crate_id }).collect()
  62     }
  63 }
  64
  65 #[derive(Debug)]
  66 pub enum Def {
  67     Item,
  68 }
  69
  70 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  71 pub struct Module {
  72     pub(crate) krate: Crate,
  73     pub(crate) module_id: ModuleId,
  74 }
  75
  76 /// The defs which can be visible in the module.
  77 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  78 pub enum ModuleDef {
  79     Module(Module),
  80     Function(Function),
  81     Struct(Struct),
  82     Enum(Enum),
  83     // Can't be directly declared, but can be imported.
  84     EnumVariant(EnumVariant),
  85     Const(Const),
  86     Static(Static),
  87     Trait(Trait),
  88     Type(Type),
  89 }
  90 impl_froms!(ModuleDef: Module, Function, Struct, Enum, EnumVariant, Const, Static, Trait, Type);
  91
  92 pub enum ModuleSource {
  93     SourceFile(TreeArc<ast::SourceFile>),
  94     Module(TreeArc<ast::Module>),
  95 }
  96
  97 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
  98 pub enum Problem {
  99     UnresolvedModule { candidate: RelativePathBuf },
 100     NotDirOwner { move_to: RelativePathBuf, candidate: RelativePathBuf },
 101 }
 102
 103 impl Module {
 104     /// Name of this module.
 105     pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
 106         self.name_impl(db)
 107     }
 108
 109     /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
 110     pub fn definition_source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, ModuleSource) {
 111         self.definition_source_impl(db)
 112     }
 113
 114     /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
 115     /// `None` for the crate root.
 116     pub fn declaration_source(
 117         &self,
 118         db: &impl HirDatabase,
 119     ) -> Option<(HirFileId, TreeArc<ast::Module>)> {
 120         self.declaration_source_impl(db)
 121     }
 122
 123     /// Returns the syntax of the last path segment corresponding to this import
 124     pub fn import_source(
 125         &self,
 126         db: &impl HirDatabase,
 127         import: ImportId,
 128     ) -> TreeArc<ast::PathSegment> {
 129         self.import_source_impl(db, import)
 130     }
 131
 132     /// Returns the crate this module is part of.
 133     pub fn krate(&self, _db: &impl PersistentHirDatabase) -> Option<Crate> {
 134         Some(self.krate)
 135     }
 136
 137     /// Topmost parent of this module. Every module has a `crate_root`, but some
 138     /// might be missing `krate`. This can happen if a module's file is not included
 139     /// in the module tree of any target in `Cargo.toml`.
 140     pub fn crate_root(&self, db: &impl PersistentHirDatabase) -> Module {
 141         self.crate_root_impl(db)
 142     }
 143
 144     /// Finds a child module with the specified name.
 145     pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
 146         self.child_impl(db, name)
 147     }
 148
 149     /// Iterates over all child modules.
 150     pub fn children(&self, db: &impl PersistentHirDatabase) -> impl Iterator<Item = Module> {
 151         self.children_impl(db)
 152     }
 153
 154     /// Finds a parent module.
 155     pub fn parent(&self, db: &impl PersistentHirDatabase) -> Option<Module> {
 156         self.parent_impl(db)
 157     }
 158
 159     pub fn path_to_root(&self, db: &impl HirDatabase) -> Vec<Module> {
 160         let mut res = vec![self.clone()];
 161         let mut curr = self.clone();
 162         while let Some(next) = curr.parent(db) {
 163             res.push(next.clone());
 164             curr = next
 165         }
 166         res
 167     }
 168
 169     /// Returns a `ModuleScope`: a set of items, visible in this module.
 170     pub fn scope(&self, db: &impl HirDatabase) -> ModuleScope {
 171         db.item_map(self.krate)[self.module_id].clone()
 172     }
 173
 174     pub fn problems(&self, db: &impl HirDatabase) -> Vec<(TreeArc<SyntaxNode>, Problem)> {
 175         self.problems_impl(db)
 176     }
 177
 178     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
 179         let item_map = db.item_map(self.krate);
 180         Resolver::default().push_module_scope(item_map, *self)
 181     }
 182
 183     pub fn declarations(self, db: &impl HirDatabase) -> Vec<ModuleDef> {
 184         let (lowered_module, _) = db.lower_module(self);
 185         lowered_module
 186             .declarations
 187             .values()
 188             .cloned()
 189             .flat_map(|per_ns| {
 190                 per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter())
 191             })
 192             .collect()
 193     }
 194
 195     pub fn impl_blocks(self, db: &impl HirDatabase) -> Vec<ImplBlock> {
 196         let module_impl_blocks = db.impls_in_module(self);
 197         module_impl_blocks
 198             .impls
 199             .iter()
 200             .map(|(impl_id, _)| ImplBlock::from_id(self, impl_id))
 201             .collect()
 202     }
 203 }
 204
 205 impl Docs for Module {
 206     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 207         self.declaration_source(db).and_then(|it| docs_from_ast(&*it.1))
 208     }
 209 }
 210
 211 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 212 pub struct StructField {
 213     pub(crate) parent: VariantDef,
 214     pub(crate) id: StructFieldId,
 215 }
 216
 217 #[derive(Debug)]
 218 pub enum FieldSource {
 219     Named(TreeArc<ast::NamedFieldDef>),
 220     Pos(TreeArc<ast::PosFieldDef>),
 221 }
 222
 223 impl StructField {
 224     pub fn name(&self, db: &impl HirDatabase) -> Name {
 225         self.parent.variant_data(db).fields().unwrap()[self.id].name.clone()
 226     }
 227
 228     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, FieldSource) {
 229         self.source_impl(db)
 230     }
 231
 232     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
 233         db.type_for_field(*self)
 234     }
 235
 236     pub fn parent_def(&self, _db: &impl HirDatabase) -> VariantDef {
 237         self.parent
 238     }
 239 }
 240
 241 impl Docs for StructField {
 242     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 243         match self.source(db).1 {
 244             FieldSource::Named(named) => docs_from_ast(&*named),
 245             FieldSource::Pos(..) => return None,
 246         }
 247     }
 248 }
 249
 250 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 251 pub struct Struct {
 252     pub(crate) id: StructId,
 253 }
 254
 255 impl Struct {
 256     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::StructDef>) {
 257         self.id.source(db)
 258     }
 259
 260     pub fn module(&self, db: &impl HirDatabase) -> Module {
 261         self.id.module(db)
 262     }
 263
 264     pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
 265         db.struct_data(*self).name.clone()
 266     }
 267
 268     pub fn fields(&self, db: &impl HirDatabase) -> Vec<StructField> {
 269         db.struct_data(*self)
 270             .variant_data
 271             .fields()
 272             .into_iter()
 273             .flat_map(|it| it.iter())
 274             .map(|(id, _)| StructField { parent: (*self).into(), id })
 275             .collect()
 276     }
 277
 278     pub fn field(&self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
 279         db.struct_data(*self)
 280             .variant_data
 281             .fields()
 282             .into_iter()
 283             .flat_map(|it| it.iter())
 284             .find(|(_id, data)| data.name == *name)
 285             .map(|(id, _)| StructField { parent: (*self).into(), id })
 286     }
 287
 288     pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
 289         db.generic_params((*self).into())
 290     }
 291
 292     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
 293         db.type_for_def((*self).into(), Namespace::Types)
 294     }
 295
 296     pub fn constructor_ty(&self, db: &impl HirDatabase) -> Ty {
 297         db.type_for_def((*self).into(), Namespace::Values)
 298     }
 299
 300     // TODO move to a more general type
 301     /// Builds a resolver for type references inside this struct.
 302     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
 303         // take the outer scope...
 304         let r = self.module(db).resolver(db);
 305         // ...and add generic params, if present
 306         let p = self.generic_params(db);
 307         let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
 308         r
 309     }
 310 }
 311
 312 impl Docs for Struct {
 313     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 314         docs_from_ast(&*self.source(db).1)
 315     }
 316 }
 317
 318 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 319 pub struct Enum {
 320     pub(crate) id: EnumId,
 321 }
 322
 323 impl Enum {
 324     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::EnumDef>) {
 325         self.id.source(db)
 326     }
 327
 328     pub fn module(&self, db: &impl HirDatabase) -> Module {
 329         self.id.module(db)
 330     }
 331
 332     pub fn name(&self, db: &impl HirDatabase) -> Option<Name> {
 333         db.enum_data(*self).name.clone()
 334     }
 335
 336     pub fn variants(&self, db: &impl PersistentHirDatabase) -> Vec<EnumVariant> {
 337         db.enum_data(*self)
 338             .variants
 339             .iter()
 340             .map(|(id, _)| EnumVariant { parent: *self, id })
 341             .collect()
 342     }
 343
 344     pub fn variant(&self, db: &impl PersistentHirDatabase, name: &Name) -> Option<EnumVariant> {
 345         db.enum_data(*self)
 346             .variants
 347             .iter()
 348             .find(|(_id, data)| data.name.as_ref() == Some(name))
 349             .map(|(id, _)| EnumVariant { parent: *self, id })
 350     }
 351
 352     pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
 353         db.generic_params((*self).into())
 354     }
 355
 356     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
 357         db.type_for_def((*self).into(), Namespace::Types)
 358     }
 359
 360     // TODO: move to a more general type
 361     /// Builds a resolver for type references inside this struct.
 362     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
 363         // take the outer scope...
 364         let r = self.module(db).resolver(db);
 365         // ...and add generic params, if present
 366         let p = self.generic_params(db);
 367         let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
 368         r
 369     }
 370 }
 371
 372 impl Docs for Enum {
 373     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 374         docs_from_ast(&*self.source(db).1)
 375     }
 376 }
 377
 378 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 379 pub struct EnumVariant {
 380     pub(crate) parent: Enum,
 381     pub(crate) id: EnumVariantId,
 382 }
 383
 384 impl EnumVariant {
 385     pub fn source(
 386         &self,
 387         db: &impl PersistentHirDatabase,
 388     ) -> (HirFileId, TreeArc<ast::EnumVariant>) {
 389         self.source_impl(db)
 390     }
 391     pub fn module(&self, db: &impl HirDatabase) -> Module {
 392         self.parent.module(db)
 393     }
 394     pub fn parent_enum(&self, _db: &impl PersistentHirDatabase) -> Enum {
 395         self.parent
 396     }
 397
 398     pub fn name(&self, db: &impl PersistentHirDatabase) -> Option<Name> {
 399         db.enum_data(self.parent).variants[self.id].name.clone()
 400     }
 401
 402     pub fn fields(&self, db: &impl HirDatabase) -> Vec<StructField> {
 403         self.variant_data(db)
 404             .fields()
 405             .into_iter()
 406             .flat_map(|it| it.iter())
 407             .map(|(id, _)| StructField { parent: (*self).into(), id })
 408             .collect()
 409     }
 410
 411     pub fn field(&self, db: &impl HirDatabase, name: &Name) -> Option<StructField> {
 412         self.variant_data(db)
 413             .fields()
 414             .into_iter()
 415             .flat_map(|it| it.iter())
 416             .find(|(_id, data)| data.name == *name)
 417             .map(|(id, _)| StructField { parent: (*self).into(), id })
 418     }
 419 }
 420
 421 impl Docs for EnumVariant {
 422     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 423         docs_from_ast(&*self.source(db).1)
 424     }
 425 }
 426
 427 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 428 pub struct Function {
 429     pub(crate) id: FunctionId,
 430 }
 431
 432 /// The declared signature of a function.
 433 #[derive(Debug, Clone, PartialEq, Eq)]
 434 pub struct FnSignature {
 435     pub(crate) name: Name,
 436     pub(crate) params: Vec<TypeRef>,
 437     pub(crate) ret_type: TypeRef,
 438     /// True if the first param is `self`. This is relevant to decide whether this
 439     /// can be called as a method.
 440     pub(crate) has_self_param: bool,
 441 }
 442
 443 impl FnSignature {
 444     pub fn name(&self) -> &Name {
 445         &self.name
 446     }
 447
 448     pub fn params(&self) -> &[TypeRef] {
 449         &self.params
 450     }
 451
 452     pub fn ret_type(&self) -> &TypeRef {
 453         &self.ret_type
 454     }
 455
 456     /// True if the first arg is `self`. This is relevant to decide whether this
 457     /// can be called as a method.
 458     pub fn has_self_param(&self) -> bool {
 459         self.has_self_param
 460     }
 461 }
 462
 463 impl Function {
 464     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::FnDef>) {
 465         self.id.source(db)
 466     }
 467
 468     pub fn module(&self, db: &impl PersistentHirDatabase) -> Module {
 469         self.id.module(db)
 470     }
 471
 472     pub fn name(&self, db: &impl HirDatabase) -> Name {
 473         self.signature(db).name.clone()
 474     }
 475
 476     pub fn body_syntax_mapping(&self, db: &impl HirDatabase) -> Arc<BodySyntaxMapping> {
 477         db.body_syntax_mapping(*self)
 478     }
 479
 480     pub fn body(&self, db: &impl HirDatabase) -> Arc<Body> {
 481         db.body_hir(*self)
 482     }
 483
 484     pub fn ty(&self, db: &impl HirDatabase) -> Ty {
 485         db.type_for_def((*self).into(), Namespace::Values)
 486     }
 487
 488     pub fn scopes(&self, db: &impl HirDatabase) -> ScopesWithSyntaxMapping {
 489         let scopes = db.expr_scopes(*self);
 490         let syntax_mapping = db.body_syntax_mapping(*self);
 491         ScopesWithSyntaxMapping { scopes, syntax_mapping }
 492     }
 493
 494     pub fn signature(&self, db: &impl HirDatabase) -> Arc<FnSignature> {
 495         db.fn_signature(*self)
 496     }
 497
 498     pub fn infer(&self, db: &impl HirDatabase) -> Arc<InferenceResult> {
 499         db.infer(*self)
 500     }
 501
 502     pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
 503         db.generic_params((*self).into())
 504     }
 505
 506     /// The containing impl block, if this is a method.
 507     pub fn impl_block(&self, db: &impl PersistentHirDatabase) -> Option<ImplBlock> {
 508         let module_impls = db.impls_in_module(self.module(db));
 509         ImplBlock::containing(module_impls, (*self).into())
 510     }
 511
 512     // TODO: move to a more general type for 'body-having' items
 513     /// Builds a resolver for code inside this item.
 514     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
 515         // take the outer scope...
 516         let r = self
 517             .impl_block(db)
 518             .map(|ib| ib.resolver(db))
 519             .unwrap_or_else(|| self.module(db).resolver(db));
 520         // ...and add generic params, if present
 521         let p = self.generic_params(db);
 522         let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
 523         r
 524     }
 525 }
 526
 527 impl Docs for Function {
 528     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 529         docs_from_ast(&*self.source(db).1)
 530     }
 531 }
 532
 533 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 534 pub struct Const {
 535     pub(crate) id: ConstId,
 536 }
 537
 538 impl Const {
 539     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::ConstDef>) {
 540         self.id.source(db)
 541     }
 542
 543     pub fn module(&self, db: &impl PersistentHirDatabase) -> Module {
 544         self.id.module(db)
 545     }
 546
 547     /// The containing impl block, if this is a method.
 548     pub fn impl_block(&self, db: &impl PersistentHirDatabase) -> Option<ImplBlock> {
 549         let module_impls = db.impls_in_module(self.module(db));
 550         ImplBlock::containing(module_impls, (*self).into())
 551     }
 552 }
 553
 554 impl Docs for Const {
 555     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 556         docs_from_ast(&*self.source(db).1)
 557     }
 558 }
 559
 560 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 561 pub struct Static {
 562     pub(crate) id: StaticId,
 563 }
 564
 565 impl Static {
 566     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::StaticDef>) {
 567         self.id.source(db)
 568     }
 569
 570     pub fn module(&self, db: &impl PersistentHirDatabase) -> Module {
 571         self.id.module(db)
 572     }
 573 }
 574
 575 impl Docs for Static {
 576     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 577         docs_from_ast(&*self.source(db).1)
 578     }
 579 }
 580
 581 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 582 pub struct Trait {
 583     pub(crate) id: TraitId,
 584 }
 585
 586 impl Trait {
 587     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::TraitDef>) {
 588         self.id.source(db)
 589     }
 590
 591     pub fn module(&self, db: &impl PersistentHirDatabase) -> Module {
 592         self.id.module(db)
 593     }
 594
 595     pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
 596         db.generic_params((*self).into())
 597     }
 598 }
 599
 600 impl Docs for Trait {
 601     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 602         docs_from_ast(&*self.source(db).1)
 603     }
 604 }
 605
 606 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 607 pub struct Type {
 608     pub(crate) id: TypeId,
 609 }
 610
 611 impl Type {
 612     pub fn source(&self, db: &impl PersistentHirDatabase) -> (HirFileId, TreeArc<ast::TypeDef>) {
 613         self.id.source(db)
 614     }
 615
 616     pub fn generic_params(&self, db: &impl PersistentHirDatabase) -> Arc<GenericParams> {
 617         db.generic_params((*self).into())
 618     }
 619
 620     pub fn module(&self, db: &impl PersistentHirDatabase) -> Module {
 621         self.id.module(db)
 622     }
 623
 624     /// The containing impl block, if this is a method.
 625     pub fn impl_block(&self, db: &impl PersistentHirDatabase) -> Option<ImplBlock> {
 626         let module_impls = db.impls_in_module(self.module(db));
 627         ImplBlock::containing(module_impls, (*self).into())
 628     }
 629
 630     pub fn type_ref(self, db: &impl PersistentHirDatabase) -> Arc<TypeRef> {
 631         db.type_alias_ref(self)
 632     }
 633
 634     /// Builds a resolver for the type references in this type alias.
 635     pub fn resolver(&self, db: &impl HirDatabase) -> Resolver {
 636         // take the outer scope...
 637         let r = self
 638             .impl_block(db)
 639             .map(|ib| ib.resolver(db))
 640             .unwrap_or_else(|| self.module(db).resolver(db));
 641         // ...and add generic params, if present
 642         let p = self.generic_params(db);
 643         let r = if !p.params.is_empty() { r.push_generic_params_scope(p) } else { r };
 644         r
 645     }
 646 }
 647
 648 impl Docs for Type {
 649     fn docs(&self, db: &impl HirDatabase) -> Option<Documentation> {
 650         docs_from_ast(&*self.source(db).1)
 651     }
 652 }