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