aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_hir
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_hir')
-rw-r--r--crates/ra_hir/Cargo.toml25
-rw-r--r--crates/ra_hir/src/code_model.rs1695
-rw-r--r--crates/ra_hir/src/db.rs21
-rw-r--r--crates/ra_hir/src/diagnostics.rs8
-rw-r--r--crates/ra_hir/src/from_id.rs247
-rw-r--r--crates/ra_hir/src/has_source.rs135
-rw-r--r--crates/ra_hir/src/lib.rs59
-rw-r--r--crates/ra_hir/src/semantics.rs731
-rw-r--r--crates/ra_hir/src/semantics/source_to_def.rs276
-rw-r--r--crates/ra_hir/src/source_analyzer.rs535
10 files changed, 0 insertions, 3732 deletions
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml
deleted file mode 100644
index c260bb193..000000000
--- a/crates/ra_hir/Cargo.toml
+++ /dev/null
@@ -1,25 +0,0 @@
1[package]
2edition = "2018"
3name = "ra_hir"
4version = "0.1.0"
5authors = ["rust-analyzer developers"]
6license = "MIT OR Apache-2.0"
7
8[lib]
9doctest = false
10
11[dependencies]
12log = "0.4.8"
13rustc-hash = "1.1.0"
14either = "1.5.3"
15arrayvec = "0.5.1"
16
17itertools = "0.9.0"
18
19stdx = { path = "../stdx" }
20ra_syntax = { path = "../ra_syntax" }
21ra_db = { path = "../ra_db" }
22ra_prof = { path = "../ra_prof" }
23hir_expand = { path = "../ra_hir_expand", package = "ra_hir_expand" }
24hir_def = { path = "../ra_hir_def", package = "ra_hir_def" }
25hir_ty = { path = "../ra_hir_ty", package = "ra_hir_ty" }
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
deleted file mode 100644
index 27cdabea0..000000000
--- a/crates/ra_hir/src/code_model.rs
+++ /dev/null
@@ -1,1695 +0,0 @@
1//! FIXME: write short doc here
2use std::{iter, sync::Arc};
3
4use arrayvec::ArrayVec;
5use either::Either;
6use hir_def::{
7 adt::StructKind,
8 adt::VariantData,
9 builtin_type::BuiltinType,
10 docs::Documentation,
11 expr::{BindingAnnotation, Pat, PatId},
12 import_map,
13 per_ns::PerNs,
14 resolver::{HasResolver, Resolver},
15 src::HasSource as _,
16 type_ref::{Mutability, TypeRef},
17 AdtId, AssocContainerId, ConstId, DefWithBodyId, EnumId, FunctionId, GenericDefId, HasModule,
18 ImplId, LocalEnumVariantId, LocalFieldId, LocalModuleId, Lookup, ModuleId, StaticId, StructId,
19 TraitId, TypeAliasId, TypeParamId, UnionId,
20};
21use hir_expand::{
22 diagnostics::DiagnosticSink,
23 name::{name, AsName},
24 MacroDefId, MacroDefKind,
25};
26use hir_ty::{
27 autoderef,
28 display::{HirDisplayError, HirFormatter},
29 method_resolution, ApplicationTy, CallableDefId, Canonical, FnSig, GenericPredicate,
30 InEnvironment, Substs, TraitEnvironment, Ty, TyDefId, TypeCtor,
31};
32use ra_db::{CrateId, Edition, FileId};
33use ra_prof::profile;
34use ra_syntax::{
35 ast::{self, AttrsOwner, NameOwner},
36 AstNode,
37};
38use rustc_hash::FxHashSet;
39use stdx::impl_from;
40
41use crate::{
42 db::{DefDatabase, HirDatabase},
43 has_source::HasSource,
44 HirDisplay, InFile, Name,
45};
46
47/// hir::Crate describes a single crate. It's the main interface with which
48/// a crate's dependencies interact. Mostly, it should be just a proxy for the
49/// root module.
50#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
51pub struct Crate {
52 pub(crate) id: CrateId,
53}
54
55#[derive(Debug)]
56pub struct CrateDependency {
57 pub krate: Crate,
58 pub name: Name,
59}
60
61impl Crate {
62 pub fn dependencies(self, db: &dyn HirDatabase) -> Vec<CrateDependency> {
63 db.crate_graph()[self.id]
64 .dependencies
65 .iter()
66 .map(|dep| {
67 let krate = Crate { id: dep.crate_id };
68 let name = dep.as_name();
69 CrateDependency { krate, name }
70 })
71 .collect()
72 }
73
74 // FIXME: add `transitive_reverse_dependencies`.
75 pub fn reverse_dependencies(self, db: &dyn HirDatabase) -> Vec<Crate> {
76 let crate_graph = db.crate_graph();
77 crate_graph
78 .iter()
79 .filter(|&krate| {
80 crate_graph[krate].dependencies.iter().any(|it| it.crate_id == self.id)
81 })
82 .map(|id| Crate { id })
83 .collect()
84 }
85
86 pub fn root_module(self, db: &dyn HirDatabase) -> Option<Module> {
87 let module_id = db.crate_def_map(self.id).root;
88 Some(Module::new(self, module_id))
89 }
90
91 pub fn root_file(self, db: &dyn HirDatabase) -> FileId {
92 db.crate_graph()[self.id].root_file_id
93 }
94
95 pub fn edition(self, db: &dyn HirDatabase) -> Edition {
96 db.crate_graph()[self.id].edition
97 }
98
99 pub fn display_name(self, db: &dyn HirDatabase) -> Option<String> {
100 db.crate_graph()[self.id].display_name.clone()
101 }
102
103 pub fn query_external_importables(
104 self,
105 db: &dyn DefDatabase,
106 query: &str,
107 ) -> impl Iterator<Item = Either<ModuleDef, MacroDef>> {
108 import_map::search_dependencies(
109 db,
110 self.into(),
111 import_map::Query::new(query).anchor_end().case_sensitive().limit(40),
112 )
113 .into_iter()
114 .map(|item| match item {
115 ItemInNs::Types(mod_id) | ItemInNs::Values(mod_id) => Either::Left(mod_id.into()),
116 ItemInNs::Macros(mac_id) => Either::Right(mac_id.into()),
117 })
118 }
119
120 pub fn all(db: &dyn HirDatabase) -> Vec<Crate> {
121 db.crate_graph().iter().map(|id| Crate { id }).collect()
122 }
123}
124
125#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
126pub struct Module {
127 pub(crate) id: ModuleId,
128}
129
130/// The defs which can be visible in the module.
131#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
132pub enum ModuleDef {
133 Module(Module),
134 Function(Function),
135 Adt(Adt),
136 // Can't be directly declared, but can be imported.
137 EnumVariant(EnumVariant),
138 Const(Const),
139 Static(Static),
140 Trait(Trait),
141 TypeAlias(TypeAlias),
142 BuiltinType(BuiltinType),
143}
144impl_from!(
145 Module,
146 Function,
147 Adt(Struct, Enum, Union),
148 EnumVariant,
149 Const,
150 Static,
151 Trait,
152 TypeAlias,
153 BuiltinType
154 for ModuleDef
155);
156
157impl ModuleDef {
158 pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
159 match self {
160 ModuleDef::Module(it) => it.parent(db),
161 ModuleDef::Function(it) => Some(it.module(db)),
162 ModuleDef::Adt(it) => Some(it.module(db)),
163 ModuleDef::EnumVariant(it) => Some(it.module(db)),
164 ModuleDef::Const(it) => Some(it.module(db)),
165 ModuleDef::Static(it) => Some(it.module(db)),
166 ModuleDef::Trait(it) => Some(it.module(db)),
167 ModuleDef::TypeAlias(it) => Some(it.module(db)),
168 ModuleDef::BuiltinType(_) => None,
169 }
170 }
171
172 pub fn definition_visibility(&self, db: &dyn HirDatabase) -> Option<Visibility> {
173 let module = match self {
174 ModuleDef::Module(it) => it.parent(db)?,
175 ModuleDef::Function(it) => return Some(it.visibility(db)),
176 ModuleDef::Adt(it) => it.module(db),
177 ModuleDef::EnumVariant(it) => {
178 let parent = it.parent_enum(db);
179 let module = it.module(db);
180 return module.visibility_of(db, &ModuleDef::Adt(Adt::Enum(parent)));
181 }
182 ModuleDef::Const(it) => return Some(it.visibility(db)),
183 ModuleDef::Static(it) => it.module(db),
184 ModuleDef::Trait(it) => it.module(db),
185 ModuleDef::TypeAlias(it) => return Some(it.visibility(db)),
186 ModuleDef::BuiltinType(_) => return None,
187 };
188
189 module.visibility_of(db, self)
190 }
191
192 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
193 match self {
194 ModuleDef::Adt(it) => Some(it.name(db)),
195 ModuleDef::Trait(it) => Some(it.name(db)),
196 ModuleDef::Function(it) => Some(it.name(db)),
197 ModuleDef::EnumVariant(it) => Some(it.name(db)),
198 ModuleDef::TypeAlias(it) => Some(it.name(db)),
199
200 ModuleDef::Module(it) => it.name(db),
201 ModuleDef::Const(it) => it.name(db),
202 ModuleDef::Static(it) => it.name(db),
203
204 ModuleDef::BuiltinType(it) => Some(it.as_name()),
205 }
206 }
207}
208
209pub use hir_def::{
210 attr::Attrs, item_scope::ItemInNs, item_tree::ItemTreeNode, visibility::Visibility,
211 AssocItemId, AssocItemLoc,
212};
213
214impl Module {
215 pub(crate) fn new(krate: Crate, crate_module_id: LocalModuleId) -> Module {
216 Module { id: ModuleId { krate: krate.id, local_id: crate_module_id } }
217 }
218
219 /// Name of this module.
220 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
221 let def_map = db.crate_def_map(self.id.krate);
222 let parent = def_map[self.id.local_id].parent?;
223 def_map[parent].children.iter().find_map(|(name, module_id)| {
224 if *module_id == self.id.local_id {
225 Some(name.clone())
226 } else {
227 None
228 }
229 })
230 }
231
232 /// Returns the crate this module is part of.
233 pub fn krate(self) -> Crate {
234 Crate { id: self.id.krate }
235 }
236
237 /// Topmost parent of this module. Every module has a `crate_root`, but some
238 /// might be missing `krate`. This can happen if a module's file is not included
239 /// in the module tree of any target in `Cargo.toml`.
240 pub fn crate_root(self, db: &dyn HirDatabase) -> Module {
241 let def_map = db.crate_def_map(self.id.krate);
242 self.with_module_id(def_map.root)
243 }
244
245 /// Iterates over all child modules.
246 pub fn children(self, db: &dyn HirDatabase) -> impl Iterator<Item = Module> {
247 let def_map = db.crate_def_map(self.id.krate);
248 let children = def_map[self.id.local_id]
249 .children
250 .iter()
251 .map(|(_, module_id)| self.with_module_id(*module_id))
252 .collect::<Vec<_>>();
253 children.into_iter()
254 }
255
256 /// Finds a parent module.
257 pub fn parent(self, db: &dyn HirDatabase) -> Option<Module> {
258 let def_map = db.crate_def_map(self.id.krate);
259 let parent_id = def_map[self.id.local_id].parent?;
260 Some(self.with_module_id(parent_id))
261 }
262
263 pub fn path_to_root(self, db: &dyn HirDatabase) -> Vec<Module> {
264 let mut res = vec![self];
265 let mut curr = self;
266 while let Some(next) = curr.parent(db) {
267 res.push(next);
268 curr = next
269 }
270 res
271 }
272
273 /// Returns a `ModuleScope`: a set of items, visible in this module.
274 pub fn scope(
275 self,
276 db: &dyn HirDatabase,
277 visible_from: Option<Module>,
278 ) -> Vec<(Name, ScopeDef)> {
279 db.crate_def_map(self.id.krate)[self.id.local_id]
280 .scope
281 .entries()
282 .filter_map(|(name, def)| {
283 if let Some(m) = visible_from {
284 let filtered =
285 def.filter_visibility(|vis| vis.is_visible_from(db.upcast(), m.id));
286 if filtered.is_none() && !def.is_none() {
287 None
288 } else {
289 Some((name, filtered))
290 }
291 } else {
292 Some((name, def))
293 }
294 })
295 .flat_map(|(name, def)| {
296 ScopeDef::all_items(def).into_iter().map(move |item| (name.clone(), item))
297 })
298 .collect()
299 }
300
301 pub fn visibility_of(self, db: &dyn HirDatabase, def: &ModuleDef) -> Option<Visibility> {
302 db.crate_def_map(self.id.krate)[self.id.local_id].scope.visibility_of(def.clone().into())
303 }
304
305 pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
306 let _p = profile("Module::diagnostics");
307 let crate_def_map = db.crate_def_map(self.id.krate);
308 crate_def_map.add_diagnostics(db.upcast(), self.id.local_id, sink);
309 for decl in self.declarations(db) {
310 match decl {
311 crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
312 crate::ModuleDef::Module(m) => {
313 // Only add diagnostics from inline modules
314 if crate_def_map[m.id.local_id].origin.is_inline() {
315 m.diagnostics(db, sink)
316 }
317 }
318 _ => (),
319 }
320 }
321
322 for impl_def in self.impl_defs(db) {
323 for item in impl_def.items(db) {
324 if let AssocItem::Function(f) = item {
325 f.diagnostics(db, sink);
326 }
327 }
328 }
329 }
330
331 pub fn declarations(self, db: &dyn HirDatabase) -> Vec<ModuleDef> {
332 let def_map = db.crate_def_map(self.id.krate);
333 def_map[self.id.local_id].scope.declarations().map(ModuleDef::from).collect()
334 }
335
336 pub fn impl_defs(self, db: &dyn HirDatabase) -> Vec<ImplDef> {
337 let def_map = db.crate_def_map(self.id.krate);
338 def_map[self.id.local_id].scope.impls().map(ImplDef::from).collect()
339 }
340
341 pub(crate) fn with_module_id(self, module_id: LocalModuleId) -> Module {
342 Module::new(self.krate(), module_id)
343 }
344
345 /// Finds a path that can be used to refer to the given item from within
346 /// this module, if possible.
347 pub fn find_use_path(
348 self,
349 db: &dyn DefDatabase,
350 item: impl Into<ItemInNs>,
351 ) -> Option<hir_def::path::ModPath> {
352 hir_def::find_path::find_path(db, item.into(), self.into())
353 }
354}
355
356#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
357pub struct Field {
358 pub(crate) parent: VariantDef,
359 pub(crate) id: LocalFieldId,
360}
361
362#[derive(Debug, PartialEq, Eq)]
363pub enum FieldSource {
364 Named(ast::RecordField),
365 Pos(ast::TupleField),
366}
367
368impl Field {
369 pub fn name(&self, db: &dyn HirDatabase) -> Name {
370 self.parent.variant_data(db).fields()[self.id].name.clone()
371 }
372
373 /// Returns the type as in the signature of the struct (i.e., with
374 /// placeholder types for type parameters). This is good for showing
375 /// signature help, but not so good to actually get the type of the field
376 /// when you actually have a variable of the struct.
377 pub fn signature_ty(&self, db: &dyn HirDatabase) -> Type {
378 let var_id = self.parent.into();
379 let generic_def_id: GenericDefId = match self.parent {
380 VariantDef::Struct(it) => it.id.into(),
381 VariantDef::Union(it) => it.id.into(),
382 VariantDef::EnumVariant(it) => it.parent.id.into(),
383 };
384 let substs = Substs::type_params(db, generic_def_id);
385 let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
386 Type::new(db, self.parent.module(db).id.krate, var_id, ty)
387 }
388
389 pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
390 self.parent
391 }
392}
393
394impl HasVisibility for Field {
395 fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
396 let variant_data = self.parent.variant_data(db);
397 let visibility = &variant_data.fields()[self.id].visibility;
398 let parent_id: hir_def::VariantId = self.parent.into();
399 visibility.resolve(db.upcast(), &parent_id.resolver(db.upcast()))
400 }
401}
402
403#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
404pub struct Struct {
405 pub(crate) id: StructId,
406}
407
408impl Struct {
409 pub fn module(self, db: &dyn HirDatabase) -> Module {
410 Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
411 }
412
413 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
414 Some(self.module(db).krate())
415 }
416
417 pub fn name(self, db: &dyn HirDatabase) -> Name {
418 db.struct_data(self.id).name.clone()
419 }
420
421 pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
422 db.struct_data(self.id)
423 .variant_data
424 .fields()
425 .iter()
426 .map(|(id, _)| Field { parent: self.into(), id })
427 .collect()
428 }
429
430 pub fn ty(self, db: &dyn HirDatabase) -> Type {
431 Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
432 }
433
434 fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
435 db.struct_data(self.id).variant_data.clone()
436 }
437}
438
439#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
440pub struct Union {
441 pub(crate) id: UnionId,
442}
443
444impl Union {
445 pub fn name(self, db: &dyn HirDatabase) -> Name {
446 db.union_data(self.id).name.clone()
447 }
448
449 pub fn module(self, db: &dyn HirDatabase) -> Module {
450 Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
451 }
452
453 pub fn ty(self, db: &dyn HirDatabase) -> Type {
454 Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
455 }
456
457 pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
458 db.union_data(self.id)
459 .variant_data
460 .fields()
461 .iter()
462 .map(|(id, _)| Field { parent: self.into(), id })
463 .collect()
464 }
465
466 fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
467 db.union_data(self.id).variant_data.clone()
468 }
469}
470
471#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
472pub struct Enum {
473 pub(crate) id: EnumId,
474}
475
476impl Enum {
477 pub fn module(self, db: &dyn HirDatabase) -> Module {
478 Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
479 }
480
481 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
482 Some(self.module(db).krate())
483 }
484
485 pub fn name(self, db: &dyn HirDatabase) -> Name {
486 db.enum_data(self.id).name.clone()
487 }
488
489 pub fn variants(self, db: &dyn HirDatabase) -> Vec<EnumVariant> {
490 db.enum_data(self.id)
491 .variants
492 .iter()
493 .map(|(id, _)| EnumVariant { parent: self, id })
494 .collect()
495 }
496
497 pub fn ty(self, db: &dyn HirDatabase) -> Type {
498 Type::from_def(db, self.id.lookup(db.upcast()).container.module(db.upcast()).krate, self.id)
499 }
500}
501
502#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
503pub struct EnumVariant {
504 pub(crate) parent: Enum,
505 pub(crate) id: LocalEnumVariantId,
506}
507
508impl EnumVariant {
509 pub fn module(self, db: &dyn HirDatabase) -> Module {
510 self.parent.module(db)
511 }
512 pub fn parent_enum(self, _db: &dyn HirDatabase) -> Enum {
513 self.parent
514 }
515
516 pub fn name(self, db: &dyn HirDatabase) -> Name {
517 db.enum_data(self.parent.id).variants[self.id].name.clone()
518 }
519
520 pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
521 self.variant_data(db)
522 .fields()
523 .iter()
524 .map(|(id, _)| Field { parent: self.into(), id })
525 .collect()
526 }
527
528 pub fn kind(self, db: &dyn HirDatabase) -> StructKind {
529 self.variant_data(db).kind()
530 }
531
532 pub(crate) fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
533 db.enum_data(self.parent.id).variants[self.id].variant_data.clone()
534 }
535}
536
537/// A Data Type
538#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
539pub enum Adt {
540 Struct(Struct),
541 Union(Union),
542 Enum(Enum),
543}
544impl_from!(Struct, Union, Enum for Adt);
545
546impl Adt {
547 pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
548 let subst = db.generic_defaults(self.into());
549 subst.iter().any(|ty| &ty.value == &Ty::Unknown)
550 }
551
552 /// Turns this ADT into a type. Any type parameters of the ADT will be
553 /// turned into unknown types, which is good for e.g. finding the most
554 /// general set of completions, but will not look very nice when printed.
555 pub fn ty(self, db: &dyn HirDatabase) -> Type {
556 let id = AdtId::from(self);
557 Type::from_def(db, id.module(db.upcast()).krate, id)
558 }
559
560 pub fn module(self, db: &dyn HirDatabase) -> Module {
561 match self {
562 Adt::Struct(s) => s.module(db),
563 Adt::Union(s) => s.module(db),
564 Adt::Enum(e) => e.module(db),
565 }
566 }
567
568 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
569 Some(self.module(db).krate())
570 }
571
572 pub fn name(self, db: &dyn HirDatabase) -> Name {
573 match self {
574 Adt::Struct(s) => s.name(db),
575 Adt::Union(u) => u.name(db),
576 Adt::Enum(e) => e.name(db),
577 }
578 }
579}
580
581#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
582pub enum VariantDef {
583 Struct(Struct),
584 Union(Union),
585 EnumVariant(EnumVariant),
586}
587impl_from!(Struct, Union, EnumVariant for VariantDef);
588
589impl VariantDef {
590 pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
591 match self {
592 VariantDef::Struct(it) => it.fields(db),
593 VariantDef::Union(it) => it.fields(db),
594 VariantDef::EnumVariant(it) => it.fields(db),
595 }
596 }
597
598 pub fn module(self, db: &dyn HirDatabase) -> Module {
599 match self {
600 VariantDef::Struct(it) => it.module(db),
601 VariantDef::Union(it) => it.module(db),
602 VariantDef::EnumVariant(it) => it.module(db),
603 }
604 }
605
606 pub fn name(&self, db: &dyn HirDatabase) -> Name {
607 match self {
608 VariantDef::Struct(s) => s.name(db),
609 VariantDef::Union(u) => u.name(db),
610 VariantDef::EnumVariant(e) => e.name(db),
611 }
612 }
613
614 pub(crate) fn variant_data(self, db: &dyn HirDatabase) -> Arc<VariantData> {
615 match self {
616 VariantDef::Struct(it) => it.variant_data(db),
617 VariantDef::Union(it) => it.variant_data(db),
618 VariantDef::EnumVariant(it) => it.variant_data(db),
619 }
620 }
621}
622
623/// The defs which have a body.
624#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
625pub enum DefWithBody {
626 Function(Function),
627 Static(Static),
628 Const(Const),
629}
630impl_from!(Function, Const, Static for DefWithBody);
631
632impl DefWithBody {
633 pub fn module(self, db: &dyn HirDatabase) -> Module {
634 match self {
635 DefWithBody::Const(c) => c.module(db),
636 DefWithBody::Function(f) => f.module(db),
637 DefWithBody::Static(s) => s.module(db),
638 }
639 }
640
641 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
642 match self {
643 DefWithBody::Function(f) => Some(f.name(db)),
644 DefWithBody::Static(s) => s.name(db),
645 DefWithBody::Const(c) => c.name(db),
646 }
647 }
648}
649
650#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
651pub struct Function {
652 pub(crate) id: FunctionId,
653}
654
655impl Function {
656 pub fn module(self, db: &dyn HirDatabase) -> Module {
657 self.id.lookup(db.upcast()).module(db.upcast()).into()
658 }
659
660 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
661 Some(self.module(db).krate())
662 }
663
664 pub fn name(self, db: &dyn HirDatabase) -> Name {
665 db.function_data(self.id).name.clone()
666 }
667
668 pub fn has_self_param(self, db: &dyn HirDatabase) -> bool {
669 db.function_data(self.id).has_self_param
670 }
671
672 pub fn params(self, db: &dyn HirDatabase) -> Vec<TypeRef> {
673 db.function_data(self.id).params.clone()
674 }
675
676 pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
677 db.function_data(self.id).is_unsafe
678 }
679
680 pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
681 hir_ty::diagnostics::validate_body(db, self.id.into(), sink)
682 }
683}
684
685impl HasVisibility for Function {
686 fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
687 let function_data = db.function_data(self.id);
688 let visibility = &function_data.visibility;
689 visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
690 }
691}
692
693#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
694pub struct Const {
695 pub(crate) id: ConstId,
696}
697
698impl Const {
699 pub fn module(self, db: &dyn HirDatabase) -> Module {
700 Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
701 }
702
703 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
704 Some(self.module(db).krate())
705 }
706
707 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
708 db.const_data(self.id).name.clone()
709 }
710}
711
712impl HasVisibility for Const {
713 fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
714 let function_data = db.const_data(self.id);
715 let visibility = &function_data.visibility;
716 visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
717 }
718}
719
720#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
721pub struct Static {
722 pub(crate) id: StaticId,
723}
724
725impl Static {
726 pub fn module(self, db: &dyn HirDatabase) -> Module {
727 Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
728 }
729
730 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
731 Some(self.module(db).krate())
732 }
733
734 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
735 db.static_data(self.id).name.clone()
736 }
737
738 pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
739 db.static_data(self.id).mutable
740 }
741}
742
743#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
744pub struct Trait {
745 pub(crate) id: TraitId,
746}
747
748impl Trait {
749 pub fn module(self, db: &dyn HirDatabase) -> Module {
750 Module { id: self.id.lookup(db.upcast()).container.module(db.upcast()) }
751 }
752
753 pub fn name(self, db: &dyn HirDatabase) -> Name {
754 db.trait_data(self.id).name.clone()
755 }
756
757 pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
758 db.trait_data(self.id).items.iter().map(|(_name, it)| (*it).into()).collect()
759 }
760
761 pub fn is_auto(self, db: &dyn HirDatabase) -> bool {
762 db.trait_data(self.id).auto
763 }
764}
765
766#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
767pub struct TypeAlias {
768 pub(crate) id: TypeAliasId,
769}
770
771impl TypeAlias {
772 pub fn has_non_default_type_params(self, db: &dyn HirDatabase) -> bool {
773 let subst = db.generic_defaults(self.id.into());
774 subst.iter().any(|ty| &ty.value == &Ty::Unknown)
775 }
776
777 pub fn module(self, db: &dyn HirDatabase) -> Module {
778 Module { id: self.id.lookup(db.upcast()).module(db.upcast()) }
779 }
780
781 pub fn krate(self, db: &dyn HirDatabase) -> Option<Crate> {
782 Some(self.module(db).krate())
783 }
784
785 pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
786 db.type_alias_data(self.id).type_ref.clone()
787 }
788
789 pub fn ty(self, db: &dyn HirDatabase) -> Type {
790 Type::from_def(db, self.id.lookup(db.upcast()).module(db.upcast()).krate, self.id)
791 }
792
793 pub fn name(self, db: &dyn HirDatabase) -> Name {
794 db.type_alias_data(self.id).name.clone()
795 }
796}
797
798impl HasVisibility for TypeAlias {
799 fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
800 let function_data = db.type_alias_data(self.id);
801 let visibility = &function_data.visibility;
802 visibility.resolve(db.upcast(), &self.id.resolver(db.upcast()))
803 }
804}
805
806#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
807pub struct MacroDef {
808 pub(crate) id: MacroDefId,
809}
810
811impl MacroDef {
812 /// FIXME: right now, this just returns the root module of the crate that
813 /// defines this macro. The reasons for this is that macros are expanded
814 /// early, in `ra_hir_expand`, where modules simply do not exist yet.
815 pub fn module(self, db: &dyn HirDatabase) -> Option<Module> {
816 let krate = self.id.krate?;
817 let module_id = db.crate_def_map(krate).root;
818 Some(Module::new(Crate { id: krate }, module_id))
819 }
820
821 /// XXX: this parses the file
822 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
823 self.source(db).value.name().map(|it| it.as_name())
824 }
825
826 /// Indicate it is a proc-macro
827 pub fn is_proc_macro(&self) -> bool {
828 matches!(self.id.kind, MacroDefKind::CustomDerive(_))
829 }
830
831 /// Indicate it is a derive macro
832 pub fn is_derive_macro(&self) -> bool {
833 matches!(self.id.kind, MacroDefKind::CustomDerive(_) | MacroDefKind::BuiltInDerive(_))
834 }
835}
836
837/// Invariant: `inner.as_assoc_item(db).is_some()`
838/// We do not actively enforce this invariant.
839#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
840pub enum AssocItem {
841 Function(Function),
842 Const(Const),
843 TypeAlias(TypeAlias),
844}
845pub enum AssocItemContainer {
846 Trait(Trait),
847 ImplDef(ImplDef),
848}
849pub trait AsAssocItem {
850 fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem>;
851}
852
853impl AsAssocItem for Function {
854 fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
855 as_assoc_item(db, AssocItem::Function, self.id)
856 }
857}
858impl AsAssocItem for Const {
859 fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
860 as_assoc_item(db, AssocItem::Const, self.id)
861 }
862}
863impl AsAssocItem for TypeAlias {
864 fn as_assoc_item(self, db: &dyn HirDatabase) -> Option<AssocItem> {
865 as_assoc_item(db, AssocItem::TypeAlias, self.id)
866 }
867}
868fn as_assoc_item<ID, DEF, CTOR, AST>(db: &dyn HirDatabase, ctor: CTOR, id: ID) -> Option<AssocItem>
869where
870 ID: Lookup<Data = AssocItemLoc<AST>>,
871 DEF: From<ID>,
872 CTOR: FnOnce(DEF) -> AssocItem,
873 AST: ItemTreeNode,
874{
875 match id.lookup(db.upcast()).container {
876 AssocContainerId::TraitId(_) | AssocContainerId::ImplId(_) => Some(ctor(DEF::from(id))),
877 AssocContainerId::ContainerId(_) => None,
878 }
879}
880
881impl AssocItem {
882 pub fn module(self, db: &dyn HirDatabase) -> Module {
883 match self {
884 AssocItem::Function(f) => f.module(db),
885 AssocItem::Const(c) => c.module(db),
886 AssocItem::TypeAlias(t) => t.module(db),
887 }
888 }
889 pub fn container(self, db: &dyn HirDatabase) -> AssocItemContainer {
890 let container = match self {
891 AssocItem::Function(it) => it.id.lookup(db.upcast()).container,
892 AssocItem::Const(it) => it.id.lookup(db.upcast()).container,
893 AssocItem::TypeAlias(it) => it.id.lookup(db.upcast()).container,
894 };
895 match container {
896 AssocContainerId::TraitId(id) => AssocItemContainer::Trait(id.into()),
897 AssocContainerId::ImplId(id) => AssocItemContainer::ImplDef(id.into()),
898 AssocContainerId::ContainerId(_) => panic!("invalid AssocItem"),
899 }
900 }
901}
902
903impl HasVisibility for AssocItem {
904 fn visibility(&self, db: &dyn HirDatabase) -> Visibility {
905 match self {
906 AssocItem::Function(f) => f.visibility(db),
907 AssocItem::Const(c) => c.visibility(db),
908 AssocItem::TypeAlias(t) => t.visibility(db),
909 }
910 }
911}
912
913#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
914pub enum GenericDef {
915 Function(Function),
916 Adt(Adt),
917 Trait(Trait),
918 TypeAlias(TypeAlias),
919 ImplDef(ImplDef),
920 // enum variants cannot have generics themselves, but their parent enums
921 // can, and this makes some code easier to write
922 EnumVariant(EnumVariant),
923 // consts can have type parameters from their parents (i.e. associated consts of traits)
924 Const(Const),
925}
926impl_from!(
927 Function,
928 Adt(Struct, Enum, Union),
929 Trait,
930 TypeAlias,
931 ImplDef,
932 EnumVariant,
933 Const
934 for GenericDef
935);
936
937impl GenericDef {
938 pub fn params(self, db: &dyn HirDatabase) -> Vec<TypeParam> {
939 let generics: Arc<hir_def::generics::GenericParams> = db.generic_params(self.into());
940 generics
941 .types
942 .iter()
943 .map(|(local_id, _)| TypeParam { id: TypeParamId { parent: self.into(), local_id } })
944 .collect()
945 }
946}
947
948#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
949pub struct Local {
950 pub(crate) parent: DefWithBodyId,
951 pub(crate) pat_id: PatId,
952}
953
954impl Local {
955 pub fn is_param(self, db: &dyn HirDatabase) -> bool {
956 let src = self.source(db);
957 match src.value {
958 Either::Left(bind_pat) => {
959 bind_pat.syntax().ancestors().any(|it| ast::Param::can_cast(it.kind()))
960 }
961 Either::Right(_self_param) => true,
962 }
963 }
964
965 // FIXME: why is this an option? It shouldn't be?
966 pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {
967 let body = db.body(self.parent.into());
968 match &body[self.pat_id] {
969 Pat::Bind { name, .. } => Some(name.clone()),
970 _ => None,
971 }
972 }
973
974 pub fn is_self(self, db: &dyn HirDatabase) -> bool {
975 self.name(db) == Some(name![self])
976 }
977
978 pub fn is_mut(self, db: &dyn HirDatabase) -> bool {
979 let body = db.body(self.parent.into());
980 match &body[self.pat_id] {
981 Pat::Bind { mode, .. } => match mode {
982 BindingAnnotation::Mutable | BindingAnnotation::RefMut => true,
983 _ => false,
984 },
985 _ => false,
986 }
987 }
988
989 pub fn parent(self, _db: &dyn HirDatabase) -> DefWithBody {
990 self.parent.into()
991 }
992
993 pub fn module(self, db: &dyn HirDatabase) -> Module {
994 self.parent(db).module(db)
995 }
996
997 pub fn ty(self, db: &dyn HirDatabase) -> Type {
998 let def = DefWithBodyId::from(self.parent);
999 let infer = db.infer(def);
1000 let ty = infer[self.pat_id].clone();
1001 let krate = def.module(db.upcast()).krate;
1002 Type::new(db, krate, def, ty)
1003 }
1004
1005 pub fn source(self, db: &dyn HirDatabase) -> InFile<Either<ast::IdentPat, ast::SelfParam>> {
1006 let (_body, source_map) = db.body_with_source_map(self.parent.into());
1007 let src = source_map.pat_syntax(self.pat_id).unwrap(); // Hmm...
1008 let root = src.file_syntax(db.upcast());
1009 src.map(|ast| {
1010 ast.map_left(|it| it.cast().unwrap().to_node(&root)).map_right(|it| it.to_node(&root))
1011 })
1012 }
1013}
1014
1015#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1016pub struct TypeParam {
1017 pub(crate) id: TypeParamId,
1018}
1019
1020impl TypeParam {
1021 pub fn name(self, db: &dyn HirDatabase) -> Name {
1022 let params = db.generic_params(self.id.parent);
1023 params.types[self.id.local_id].name.clone().unwrap_or_else(Name::missing)
1024 }
1025
1026 pub fn module(self, db: &dyn HirDatabase) -> Module {
1027 self.id.parent.module(db.upcast()).into()
1028 }
1029
1030 pub fn ty(self, db: &dyn HirDatabase) -> Type {
1031 let resolver = self.id.parent.resolver(db.upcast());
1032 let environment = TraitEnvironment::lower(db, &resolver);
1033 let ty = Ty::Placeholder(self.id);
1034 Type {
1035 krate: self.id.parent.module(db.upcast()).krate,
1036 ty: InEnvironment { value: ty, environment },
1037 }
1038 }
1039
1040 pub fn default(self, db: &dyn HirDatabase) -> Option<Type> {
1041 let params = db.generic_defaults(self.id.parent);
1042 let local_idx = hir_ty::param_idx(db, self.id)?;
1043 let resolver = self.id.parent.resolver(db.upcast());
1044 let environment = TraitEnvironment::lower(db, &resolver);
1045 let ty = params.get(local_idx)?.clone();
1046 let subst = Substs::type_params(db, self.id.parent);
1047 let ty = ty.subst(&subst.prefix(local_idx));
1048 Some(Type {
1049 krate: self.id.parent.module(db.upcast()).krate,
1050 ty: InEnvironment { value: ty, environment },
1051 })
1052 }
1053}
1054
1055// FIXME: rename from `ImplDef` to `Impl`
1056#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
1057pub struct ImplDef {
1058 pub(crate) id: ImplId,
1059}
1060
1061impl ImplDef {
1062 pub fn all_in_crate(db: &dyn HirDatabase, krate: Crate) -> Vec<ImplDef> {
1063 let inherent = db.inherent_impls_in_crate(krate.id);
1064 let trait_ = db.trait_impls_in_crate(krate.id);
1065
1066 inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
1067 }
1068 pub fn for_trait(db: &dyn HirDatabase, krate: Crate, trait_: Trait) -> Vec<ImplDef> {
1069 let impls = db.trait_impls_in_crate(krate.id);
1070 impls.for_trait(trait_.id).map(Self::from).collect()
1071 }
1072
1073 pub fn target_trait(self, db: &dyn HirDatabase) -> Option<TypeRef> {
1074 db.impl_data(self.id).target_trait.clone()
1075 }
1076
1077 pub fn target_type(self, db: &dyn HirDatabase) -> TypeRef {
1078 db.impl_data(self.id).target_type.clone()
1079 }
1080
1081 pub fn target_ty(self, db: &dyn HirDatabase) -> Type {
1082 let impl_data = db.impl_data(self.id);
1083 let resolver = self.id.resolver(db.upcast());
1084 let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
1085 let environment = TraitEnvironment::lower(db, &resolver);
1086 let ty = Ty::from_hir(&ctx, &impl_data.target_type);
1087 Type {
1088 krate: self.id.lookup(db.upcast()).container.module(db.upcast()).krate,
1089 ty: InEnvironment { value: ty, environment },
1090 }
1091 }
1092
1093 pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
1094 db.impl_data(self.id).items.iter().map(|it| (*it).into()).collect()
1095 }
1096
1097 pub fn is_negative(self, db: &dyn HirDatabase) -> bool {
1098 db.impl_data(self.id).is_negative
1099 }
1100
1101 pub fn module(self, db: &dyn HirDatabase) -> Module {
1102 self.id.lookup(db.upcast()).container.module(db.upcast()).into()
1103 }
1104
1105 pub fn krate(self, db: &dyn HirDatabase) -> Crate {
1106 Crate { id: self.module(db).id.krate }
1107 }
1108
1109 pub fn is_builtin_derive(self, db: &dyn HirDatabase) -> Option<InFile<ast::Attr>> {
1110 let src = self.source(db);
1111 let item = src.file_id.is_builtin_derive(db.upcast())?;
1112 let hygenic = hir_expand::hygiene::Hygiene::new(db.upcast(), item.file_id);
1113
1114 let attr = item
1115 .value
1116 .attrs()
1117 .filter_map(|it| {
1118 let path = hir_def::path::ModPath::from_src(it.path()?, &hygenic)?;
1119 if path.as_ident()?.to_string() == "derive" {
1120 Some(it)
1121 } else {
1122 None
1123 }
1124 })
1125 .last()?;
1126
1127 Some(item.with_value(attr))
1128 }
1129}
1130
1131#[derive(Clone, PartialEq, Eq, Debug)]
1132pub struct Type {
1133 krate: CrateId,
1134 ty: InEnvironment<Ty>,
1135}
1136
1137impl Type {
1138 pub(crate) fn new_with_resolver(
1139 db: &dyn HirDatabase,
1140 resolver: &Resolver,
1141 ty: Ty,
1142 ) -> Option<Type> {
1143 let krate = resolver.krate()?;
1144 Some(Type::new_with_resolver_inner(db, krate, resolver, ty))
1145 }
1146 pub(crate) fn new_with_resolver_inner(
1147 db: &dyn HirDatabase,
1148 krate: CrateId,
1149 resolver: &Resolver,
1150 ty: Ty,
1151 ) -> Type {
1152 let environment = TraitEnvironment::lower(db, &resolver);
1153 Type { krate, ty: InEnvironment { value: ty, environment } }
1154 }
1155
1156 fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
1157 let resolver = lexical_env.resolver(db.upcast());
1158 let environment = TraitEnvironment::lower(db, &resolver);
1159 Type { krate, ty: InEnvironment { value: ty, environment } }
1160 }
1161
1162 fn from_def(
1163 db: &dyn HirDatabase,
1164 krate: CrateId,
1165 def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
1166 ) -> Type {
1167 let substs = Substs::build_for_def(db, def).fill_with_unknown().build();
1168 let ty = db.ty(def.into()).subst(&substs);
1169 Type::new(db, krate, def, ty)
1170 }
1171
1172 pub fn is_unit(&self) -> bool {
1173 matches!(
1174 self.ty.value,
1175 Ty::Apply(ApplicationTy { ctor: TypeCtor::Tuple { cardinality: 0 }, .. })
1176 )
1177 }
1178 pub fn is_bool(&self) -> bool {
1179 matches!(self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. }))
1180 }
1181
1182 pub fn is_mutable_reference(&self) -> bool {
1183 matches!(
1184 self.ty.value,
1185 Ty::Apply(ApplicationTy { ctor: TypeCtor::Ref(Mutability::Mut), .. })
1186 )
1187 }
1188
1189 pub fn is_unknown(&self) -> bool {
1190 matches!(self.ty.value, Ty::Unknown)
1191 }
1192
1193 /// Checks that particular type `ty` implements `std::future::Future`.
1194 /// This function is used in `.await` syntax completion.
1195 pub fn impls_future(&self, db: &dyn HirDatabase) -> bool {
1196 let krate = self.krate;
1197
1198 let std_future_trait =
1199 db.lang_item(krate, "future_trait".into()).and_then(|it| it.as_trait());
1200 let std_future_trait = match std_future_trait {
1201 Some(it) => it,
1202 None => return false,
1203 };
1204
1205 let canonical_ty = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
1206 method_resolution::implements_trait(
1207 &canonical_ty,
1208 db,
1209 self.ty.environment.clone(),
1210 krate,
1211 std_future_trait,
1212 )
1213 }
1214
1215 pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
1216 let trait_ref = hir_ty::TraitRef {
1217 trait_: trait_.id,
1218 substs: Substs::build_for_def(db, trait_.id)
1219 .push(self.ty.value.clone())
1220 .fill(args.iter().map(|t| t.ty.value.clone()))
1221 .build(),
1222 };
1223
1224 let goal = Canonical {
1225 value: hir_ty::InEnvironment::new(
1226 self.ty.environment.clone(),
1227 hir_ty::Obligation::Trait(trait_ref),
1228 ),
1229 kinds: Arc::new([]),
1230 };
1231
1232 db.trait_solve(self.krate, goal).is_some()
1233 }
1234
1235 pub fn as_callable(&self, db: &dyn HirDatabase) -> Option<Callable> {
1236 let def = match self.ty.value {
1237 Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(def), parameters: _ }) => Some(def),
1238 _ => None,
1239 };
1240
1241 let sig = self.ty.value.callable_sig(db)?;
1242 Some(Callable { ty: self.clone(), sig, def, is_bound_method: false })
1243 }
1244
1245 pub fn is_closure(&self) -> bool {
1246 matches!(&self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::Closure { .. }, .. }))
1247 }
1248
1249 pub fn is_fn(&self) -> bool {
1250 matches!(&self.ty.value,
1251 Ty::Apply(ApplicationTy { ctor: TypeCtor::FnDef(..), .. }) |
1252 Ty::Apply(ApplicationTy { ctor: TypeCtor::FnPtr { .. }, .. })
1253 )
1254 }
1255
1256 pub fn is_raw_ptr(&self) -> bool {
1257 matches!(&self.ty.value, Ty::Apply(ApplicationTy { ctor: TypeCtor::RawPtr(..), .. }))
1258 }
1259
1260 pub fn contains_unknown(&self) -> bool {
1261 return go(&self.ty.value);
1262
1263 fn go(ty: &Ty) -> bool {
1264 match ty {
1265 Ty::Unknown => true,
1266 Ty::Apply(a_ty) => a_ty.parameters.iter().any(go),
1267 _ => false,
1268 }
1269 }
1270 }
1271
1272 pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
1273 if let Ty::Apply(a_ty) = &self.ty.value {
1274 let variant_id = match a_ty.ctor {
1275 TypeCtor::Adt(AdtId::StructId(s)) => s.into(),
1276 TypeCtor::Adt(AdtId::UnionId(u)) => u.into(),
1277 _ => return Vec::new(),
1278 };
1279
1280 return db
1281 .field_types(variant_id)
1282 .iter()
1283 .map(|(local_id, ty)| {
1284 let def = Field { parent: variant_id.into(), id: local_id };
1285 let ty = ty.clone().subst(&a_ty.parameters);
1286 (def, self.derived(ty))
1287 })
1288 .collect();
1289 };
1290 Vec::new()
1291 }
1292
1293 pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
1294 let mut res = Vec::new();
1295 if let Ty::Apply(a_ty) = &self.ty.value {
1296 if let TypeCtor::Tuple { .. } = a_ty.ctor {
1297 for ty in a_ty.parameters.iter() {
1298 let ty = ty.clone();
1299 res.push(self.derived(ty));
1300 }
1301 }
1302 };
1303 res
1304 }
1305
1306 pub fn autoderef<'a>(&'a self, db: &'a dyn HirDatabase) -> impl Iterator<Item = Type> + 'a {
1307 // There should be no inference vars in types passed here
1308 // FIXME check that?
1309 let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
1310 let environment = self.ty.environment.clone();
1311 let ty = InEnvironment { value: canonical, environment };
1312 autoderef(db, Some(self.krate), ty)
1313 .map(|canonical| canonical.value)
1314 .map(move |ty| self.derived(ty))
1315 }
1316
1317 // This would be nicer if it just returned an iterator, but that runs into
1318 // lifetime problems, because we need to borrow temp `CrateImplDefs`.
1319 pub fn iterate_assoc_items<T>(
1320 self,
1321 db: &dyn HirDatabase,
1322 krate: Crate,
1323 mut callback: impl FnMut(AssocItem) -> Option<T>,
1324 ) -> Option<T> {
1325 for krate in self.ty.value.def_crates(db, krate.id)? {
1326 let impls = db.inherent_impls_in_crate(krate);
1327
1328 for impl_def in impls.for_self_ty(&self.ty.value) {
1329 for &item in db.impl_data(*impl_def).items.iter() {
1330 if let Some(result) = callback(item.into()) {
1331 return Some(result);
1332 }
1333 }
1334 }
1335 }
1336 None
1337 }
1338
1339 pub fn iterate_method_candidates<T>(
1340 &self,
1341 db: &dyn HirDatabase,
1342 krate: Crate,
1343 traits_in_scope: &FxHashSet<TraitId>,
1344 name: Option<&Name>,
1345 mut callback: impl FnMut(&Ty, Function) -> Option<T>,
1346 ) -> Option<T> {
1347 // There should be no inference vars in types passed here
1348 // FIXME check that?
1349 // FIXME replace Unknown by bound vars here
1350 let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
1351
1352 let env = self.ty.environment.clone();
1353 let krate = krate.id;
1354
1355 method_resolution::iterate_method_candidates(
1356 &canonical,
1357 db,
1358 env,
1359 krate,
1360 traits_in_scope,
1361 name,
1362 method_resolution::LookupMode::MethodCall,
1363 |ty, it| match it {
1364 AssocItemId::FunctionId(f) => callback(ty, f.into()),
1365 _ => None,
1366 },
1367 )
1368 }
1369
1370 pub fn iterate_path_candidates<T>(
1371 &self,
1372 db: &dyn HirDatabase,
1373 krate: Crate,
1374 traits_in_scope: &FxHashSet<TraitId>,
1375 name: Option<&Name>,
1376 mut callback: impl FnMut(&Ty, AssocItem) -> Option<T>,
1377 ) -> Option<T> {
1378 // There should be no inference vars in types passed here
1379 // FIXME check that?
1380 // FIXME replace Unknown by bound vars here
1381 let canonical = Canonical { value: self.ty.value.clone(), kinds: Arc::new([]) };
1382
1383 let env = self.ty.environment.clone();
1384 let krate = krate.id;
1385
1386 method_resolution::iterate_method_candidates(
1387 &canonical,
1388 db,
1389 env,
1390 krate,
1391 traits_in_scope,
1392 name,
1393 method_resolution::LookupMode::Path,
1394 |ty, it| callback(ty, it.into()),
1395 )
1396 }
1397
1398 pub fn as_adt(&self) -> Option<Adt> {
1399 let (adt, _subst) = self.ty.value.as_adt()?;
1400 Some(adt.into())
1401 }
1402
1403 pub fn as_dyn_trait(&self) -> Option<Trait> {
1404 self.ty.value.dyn_trait().map(Into::into)
1405 }
1406
1407 pub fn as_impl_traits(&self, db: &dyn HirDatabase) -> Option<Vec<Trait>> {
1408 self.ty.value.impl_trait_bounds(db).map(|it| {
1409 it.into_iter()
1410 .filter_map(|pred| match pred {
1411 hir_ty::GenericPredicate::Implemented(trait_ref) => {
1412 Some(Trait::from(trait_ref.trait_))
1413 }
1414 _ => None,
1415 })
1416 .collect()
1417 })
1418 }
1419
1420 pub fn as_associated_type_parent_trait(&self, db: &dyn HirDatabase) -> Option<Trait> {
1421 self.ty.value.associated_type_parent_trait(db).map(Into::into)
1422 }
1423
1424 // FIXME: provide required accessors such that it becomes implementable from outside.
1425 pub fn is_equal_for_find_impls(&self, other: &Type) -> bool {
1426 match (&self.ty.value, &other.ty.value) {
1427 (Ty::Apply(a_original_ty), Ty::Apply(ApplicationTy { ctor, parameters })) => match ctor
1428 {
1429 TypeCtor::Ref(..) => match parameters.as_single() {
1430 Ty::Apply(a_ty) => a_original_ty.ctor == a_ty.ctor,
1431 _ => false,
1432 },
1433 _ => a_original_ty.ctor == *ctor,
1434 },
1435 _ => false,
1436 }
1437 }
1438
1439 fn derived(&self, ty: Ty) -> Type {
1440 Type {
1441 krate: self.krate,
1442 ty: InEnvironment { value: ty, environment: self.ty.environment.clone() },
1443 }
1444 }
1445
1446 pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
1447 // TypeWalk::walk for a Ty at first visits parameters and only after that the Ty itself.
1448 // We need a different order here.
1449
1450 fn walk_substs(
1451 db: &dyn HirDatabase,
1452 type_: &Type,
1453 substs: &Substs,
1454 cb: &mut impl FnMut(Type),
1455 ) {
1456 for ty in substs.iter() {
1457 walk_type(db, &type_.derived(ty.clone()), cb);
1458 }
1459 }
1460
1461 fn walk_bounds(
1462 db: &dyn HirDatabase,
1463 type_: &Type,
1464 bounds: &[GenericPredicate],
1465 cb: &mut impl FnMut(Type),
1466 ) {
1467 for pred in bounds {
1468 match pred {
1469 GenericPredicate::Implemented(trait_ref) => {
1470 cb(type_.clone());
1471 walk_substs(db, type_, &trait_ref.substs, cb);
1472 }
1473 _ => (),
1474 }
1475 }
1476 }
1477
1478 fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
1479 let ty = type_.ty.value.strip_references();
1480 match ty {
1481 Ty::Apply(ApplicationTy { ctor, parameters }) => {
1482 match ctor {
1483 TypeCtor::Adt(_) => {
1484 cb(type_.derived(ty.clone()));
1485 }
1486 TypeCtor::AssociatedType(_) => {
1487 if let Some(_) = ty.associated_type_parent_trait(db) {
1488 cb(type_.derived(ty.clone()));
1489 }
1490 }
1491 _ => (),
1492 }
1493
1494 // adt params, tuples, etc...
1495 walk_substs(db, type_, parameters, cb);
1496 }
1497 Ty::Opaque(opaque_ty) => {
1498 if let Some(bounds) = ty.impl_trait_bounds(db) {
1499 walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
1500 }
1501
1502 walk_substs(db, type_, &opaque_ty.parameters, cb);
1503 }
1504 Ty::Placeholder(_) => {
1505 if let Some(bounds) = ty.impl_trait_bounds(db) {
1506 walk_bounds(db, &type_.derived(ty.clone()), &bounds, cb);
1507 }
1508 }
1509 Ty::Dyn(bounds) => {
1510 walk_bounds(db, &type_.derived(ty.clone()), bounds.as_ref(), cb);
1511 }
1512
1513 _ => (),
1514 }
1515 }
1516
1517 walk_type(db, self, &mut cb);
1518 }
1519}
1520
1521impl HirDisplay for Type {
1522 fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> {
1523 self.ty.value.hir_fmt(f)
1524 }
1525}
1526
1527// FIXME: closures
1528#[derive(Debug)]
1529pub struct Callable {
1530 ty: Type,
1531 sig: FnSig,
1532 def: Option<CallableDefId>,
1533 pub(crate) is_bound_method: bool,
1534}
1535
1536pub enum CallableKind {
1537 Function(Function),
1538 TupleStruct(Struct),
1539 TupleEnumVariant(EnumVariant),
1540 Closure,
1541}
1542
1543impl Callable {
1544 pub fn kind(&self) -> CallableKind {
1545 match self.def {
1546 Some(CallableDefId::FunctionId(it)) => CallableKind::Function(it.into()),
1547 Some(CallableDefId::StructId(it)) => CallableKind::TupleStruct(it.into()),
1548 Some(CallableDefId::EnumVariantId(it)) => CallableKind::TupleEnumVariant(it.into()),
1549 None => CallableKind::Closure,
1550 }
1551 }
1552 pub fn receiver_param(&self, db: &dyn HirDatabase) -> Option<ast::SelfParam> {
1553 let func = match self.def {
1554 Some(CallableDefId::FunctionId(it)) if self.is_bound_method => it,
1555 _ => return None,
1556 };
1557 let src = func.lookup(db.upcast()).source(db.upcast());
1558 let param_list = src.value.param_list()?;
1559 param_list.self_param()
1560 }
1561 pub fn n_params(&self) -> usize {
1562 self.sig.params().len() - if self.is_bound_method { 1 } else { 0 }
1563 }
1564 pub fn params(
1565 &self,
1566 db: &dyn HirDatabase,
1567 ) -> Vec<(Option<Either<ast::SelfParam, ast::Pat>>, Type)> {
1568 let types = self
1569 .sig
1570 .params()
1571 .iter()
1572 .skip(if self.is_bound_method { 1 } else { 0 })
1573 .map(|ty| self.ty.derived(ty.clone()));
1574 let patterns = match self.def {
1575 Some(CallableDefId::FunctionId(func)) => {
1576 let src = func.lookup(db.upcast()).source(db.upcast());
1577 src.value.param_list().map(|param_list| {
1578 param_list
1579 .self_param()
1580 .map(|it| Some(Either::Left(it)))
1581 .filter(|_| !self.is_bound_method)
1582 .into_iter()
1583 .chain(param_list.params().map(|it| it.pat().map(Either::Right)))
1584 })
1585 }
1586 _ => None,
1587 };
1588 patterns.into_iter().flatten().chain(iter::repeat(None)).zip(types).collect()
1589 }
1590 pub fn return_type(&self) -> Type {
1591 self.ty.derived(self.sig.ret().clone())
1592 }
1593}
1594
1595/// For IDE only
1596#[derive(Debug)]
1597pub enum ScopeDef {
1598 ModuleDef(ModuleDef),
1599 MacroDef(MacroDef),
1600 GenericParam(TypeParam),
1601 ImplSelfType(ImplDef),
1602 AdtSelfType(Adt),
1603 Local(Local),
1604 Unknown,
1605}
1606
1607impl ScopeDef {
1608 pub fn all_items(def: PerNs) -> ArrayVec<[Self; 3]> {
1609 let mut items = ArrayVec::new();
1610
1611 match (def.take_types(), def.take_values()) {
1612 (Some(m1), None) => items.push(ScopeDef::ModuleDef(m1.into())),
1613 (None, Some(m2)) => items.push(ScopeDef::ModuleDef(m2.into())),
1614 (Some(m1), Some(m2)) => {
1615 // Some items, like unit structs and enum variants, are
1616 // returned as both a type and a value. Here we want
1617 // to de-duplicate them.
1618 if m1 != m2 {
1619 items.push(ScopeDef::ModuleDef(m1.into()));
1620 items.push(ScopeDef::ModuleDef(m2.into()));
1621 } else {
1622 items.push(ScopeDef::ModuleDef(m1.into()));
1623 }
1624 }
1625 (None, None) => {}
1626 };
1627
1628 if let Some(macro_def_id) = def.take_macros() {
1629 items.push(ScopeDef::MacroDef(macro_def_id.into()));
1630 }
1631
1632 if items.is_empty() {
1633 items.push(ScopeDef::Unknown);
1634 }
1635
1636 items
1637 }
1638}
1639
1640#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1641pub enum AttrDef {
1642 Module(Module),
1643 Field(Field),
1644 Adt(Adt),
1645 Function(Function),
1646 EnumVariant(EnumVariant),
1647 Static(Static),
1648 Const(Const),
1649 Trait(Trait),
1650 TypeAlias(TypeAlias),
1651 MacroDef(MacroDef),
1652}
1653
1654impl_from!(
1655 Module,
1656 Field,
1657 Adt(Struct, Enum, Union),
1658 EnumVariant,
1659 Static,
1660 Const,
1661 Function,
1662 Trait,
1663 TypeAlias,
1664 MacroDef
1665 for AttrDef
1666);
1667
1668pub trait HasAttrs {
1669 fn attrs(self, db: &dyn HirDatabase) -> Attrs;
1670}
1671
1672impl<T: Into<AttrDef>> HasAttrs for T {
1673 fn attrs(self, db: &dyn HirDatabase) -> Attrs {
1674 let def: AttrDef = self.into();
1675 db.attrs(def.into())
1676 }
1677}
1678
1679pub trait Docs {
1680 fn docs(&self, db: &dyn HirDatabase) -> Option<Documentation>;
1681}
1682impl<T: Into<AttrDef> + Copy> Docs for T {
1683 fn docs(&self, db: &dyn HirDatabase) -> Option<Documentation> {
1684 let def: AttrDef = (*self).into();
1685 db.documentation(def.into())
1686 }
1687}
1688
1689pub trait HasVisibility {
1690 fn visibility(&self, db: &dyn HirDatabase) -> Visibility;
1691 fn is_visible_from(&self, db: &dyn HirDatabase, module: Module) -> bool {
1692 let vis = self.visibility(db);
1693 vis.is_visible_from(db.upcast(), module.id)
1694 }
1695}
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
deleted file mode 100644
index 07333c453..000000000
--- a/crates/ra_hir/src/db.rs
+++ /dev/null
@@ -1,21 +0,0 @@
1//! FIXME: write short doc here
2
3pub use hir_def::db::{
4 AttrsQuery, BodyQuery, BodyWithSourceMapQuery, ConstDataQuery, CrateDefMapQueryQuery,
5 CrateLangItemsQuery, DefDatabase, DefDatabaseStorage, DocumentationQuery, EnumDataQuery,
6 ExprScopesQuery, FunctionDataQuery, GenericParamsQuery, ImplDataQuery, ImportMapQuery,
7 InternConstQuery, InternDatabase, InternDatabaseStorage, InternEnumQuery, InternFunctionQuery,
8 InternImplQuery, InternStaticQuery, InternStructQuery, InternTraitQuery, InternTypeAliasQuery,
9 InternUnionQuery, ItemTreeQuery, LangItemQuery, ModuleLangItemsQuery, StaticDataQuery,
10 StructDataQuery, TraitDataQuery, TypeAliasDataQuery, UnionDataQuery,
11};
12pub use hir_expand::db::{
13 AstDatabase, AstDatabaseStorage, AstIdMapQuery, InternEagerExpansionQuery, InternMacroQuery,
14 MacroArgTextQuery, MacroDefQuery, MacroExpandQuery, ParseMacroQuery,
15};
16pub use hir_ty::db::*;
17
18#[test]
19fn hir_database_is_object_safe() {
20 fn _assert_object_safe(_: &dyn HirDatabase) {}
21}
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
deleted file mode 100644
index 266b513dc..000000000
--- a/crates/ra_hir/src/diagnostics.rs
+++ /dev/null
@@ -1,8 +0,0 @@
1//! FIXME: write short doc here
2pub use hir_def::diagnostics::UnresolvedModule;
3pub use hir_expand::diagnostics::{
4 AstDiagnostic, Diagnostic, DiagnosticSink, DiagnosticSinkBuilder,
5};
6pub use hir_ty::diagnostics::{
7 MismatchedArgCount, MissingFields, MissingMatchArms, MissingOkInTailExpr, NoSuchField,
8};
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
deleted file mode 100644
index 679ae8121..000000000
--- a/crates/ra_hir/src/from_id.rs
+++ /dev/null
@@ -1,247 +0,0 @@
1//! Utility module for converting between hir_def ids and code_model wrappers.
2//!
3//! It's unclear if we need this long-term, but it's definitelly useful while we
4//! are splitting the hir.
5
6use hir_def::{
7 expr::PatId, AdtId, AssocItemId, AttrDefId, DefWithBodyId, EnumVariantId, FieldId,
8 GenericDefId, ModuleDefId, VariantId,
9};
10
11use crate::{
12 code_model::ItemInNs, Adt, AssocItem, AttrDef, DefWithBody, EnumVariant, Field, GenericDef,
13 Local, MacroDef, ModuleDef, VariantDef,
14};
15
16macro_rules! from_id {
17 ($(($id:path, $ty:path)),*) => {$(
18 impl From<$id> for $ty {
19 fn from(id: $id) -> $ty {
20 $ty { id }
21 }
22 }
23 impl From<$ty> for $id {
24 fn from(ty: $ty) -> $id {
25 ty.id
26 }
27 }
28 )*}
29}
30
31from_id![
32 (ra_db::CrateId, crate::Crate),
33 (hir_def::ModuleId, crate::Module),
34 (hir_def::StructId, crate::Struct),
35 (hir_def::UnionId, crate::Union),
36 (hir_def::EnumId, crate::Enum),
37 (hir_def::TypeAliasId, crate::TypeAlias),
38 (hir_def::TraitId, crate::Trait),
39 (hir_def::StaticId, crate::Static),
40 (hir_def::ConstId, crate::Const),
41 (hir_def::FunctionId, crate::Function),
42 (hir_def::ImplId, crate::ImplDef),
43 (hir_def::TypeParamId, crate::TypeParam),
44 (hir_expand::MacroDefId, crate::MacroDef)
45];
46
47impl From<AdtId> for Adt {
48 fn from(id: AdtId) -> Self {
49 match id {
50 AdtId::StructId(it) => Adt::Struct(it.into()),
51 AdtId::UnionId(it) => Adt::Union(it.into()),
52 AdtId::EnumId(it) => Adt::Enum(it.into()),
53 }
54 }
55}
56
57impl From<Adt> for AdtId {
58 fn from(id: Adt) -> Self {
59 match id {
60 Adt::Struct(it) => AdtId::StructId(it.id),
61 Adt::Union(it) => AdtId::UnionId(it.id),
62 Adt::Enum(it) => AdtId::EnumId(it.id),
63 }
64 }
65}
66
67impl From<EnumVariantId> for EnumVariant {
68 fn from(id: EnumVariantId) -> Self {
69 EnumVariant { parent: id.parent.into(), id: id.local_id }
70 }
71}
72
73impl From<EnumVariant> for EnumVariantId {
74 fn from(def: EnumVariant) -> Self {
75 EnumVariantId { parent: def.parent.id, local_id: def.id }
76 }
77}
78
79impl From<ModuleDefId> for ModuleDef {
80 fn from(id: ModuleDefId) -> Self {
81 match id {
82 ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
83 ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
84 ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
85 ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
86 ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
87 ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
88 ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
89 ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
90 ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it),
91 }
92 }
93}
94
95impl From<ModuleDef> for ModuleDefId {
96 fn from(id: ModuleDef) -> Self {
97 match id {
98 ModuleDef::Module(it) => ModuleDefId::ModuleId(it.into()),
99 ModuleDef::Function(it) => ModuleDefId::FunctionId(it.into()),
100 ModuleDef::Adt(it) => ModuleDefId::AdtId(it.into()),
101 ModuleDef::EnumVariant(it) => ModuleDefId::EnumVariantId(it.into()),
102 ModuleDef::Const(it) => ModuleDefId::ConstId(it.into()),
103 ModuleDef::Static(it) => ModuleDefId::StaticId(it.into()),
104 ModuleDef::Trait(it) => ModuleDefId::TraitId(it.into()),
105 ModuleDef::TypeAlias(it) => ModuleDefId::TypeAliasId(it.into()),
106 ModuleDef::BuiltinType(it) => ModuleDefId::BuiltinType(it),
107 }
108 }
109}
110
111impl From<DefWithBody> for DefWithBodyId {
112 fn from(def: DefWithBody) -> Self {
113 match def {
114 DefWithBody::Function(it) => DefWithBodyId::FunctionId(it.id),
115 DefWithBody::Static(it) => DefWithBodyId::StaticId(it.id),
116 DefWithBody::Const(it) => DefWithBodyId::ConstId(it.id),
117 }
118 }
119}
120
121impl From<DefWithBodyId> for DefWithBody {
122 fn from(def: DefWithBodyId) -> Self {
123 match def {
124 DefWithBodyId::FunctionId(it) => DefWithBody::Function(it.into()),
125 DefWithBodyId::StaticId(it) => DefWithBody::Static(it.into()),
126 DefWithBodyId::ConstId(it) => DefWithBody::Const(it.into()),
127 }
128 }
129}
130
131impl From<AssocItemId> for AssocItem {
132 fn from(def: AssocItemId) -> Self {
133 match def {
134 AssocItemId::FunctionId(it) => AssocItem::Function(it.into()),
135 AssocItemId::TypeAliasId(it) => AssocItem::TypeAlias(it.into()),
136 AssocItemId::ConstId(it) => AssocItem::Const(it.into()),
137 }
138 }
139}
140
141impl From<GenericDef> for GenericDefId {
142 fn from(def: GenericDef) -> Self {
143 match def {
144 GenericDef::Function(it) => GenericDefId::FunctionId(it.id),
145 GenericDef::Adt(it) => GenericDefId::AdtId(it.into()),
146 GenericDef::Trait(it) => GenericDefId::TraitId(it.id),
147 GenericDef::TypeAlias(it) => GenericDefId::TypeAliasId(it.id),
148 GenericDef::ImplDef(it) => GenericDefId::ImplId(it.id),
149 GenericDef::EnumVariant(it) => {
150 GenericDefId::EnumVariantId(EnumVariantId { parent: it.parent.id, local_id: it.id })
151 }
152 GenericDef::Const(it) => GenericDefId::ConstId(it.id),
153 }
154 }
155}
156
157impl From<Adt> for GenericDefId {
158 fn from(id: Adt) -> Self {
159 match id {
160 Adt::Struct(it) => it.id.into(),
161 Adt::Union(it) => it.id.into(),
162 Adt::Enum(it) => it.id.into(),
163 }
164 }
165}
166
167impl From<VariantId> for VariantDef {
168 fn from(def: VariantId) -> Self {
169 match def {
170 VariantId::StructId(it) => VariantDef::Struct(it.into()),
171 VariantId::EnumVariantId(it) => VariantDef::EnumVariant(it.into()),
172 VariantId::UnionId(it) => VariantDef::Union(it.into()),
173 }
174 }
175}
176
177impl From<VariantDef> for VariantId {
178 fn from(def: VariantDef) -> Self {
179 match def {
180 VariantDef::Struct(it) => VariantId::StructId(it.id),
181 VariantDef::EnumVariant(it) => VariantId::EnumVariantId(it.into()),
182 VariantDef::Union(it) => VariantId::UnionId(it.id),
183 }
184 }
185}
186
187impl From<Field> for FieldId {
188 fn from(def: Field) -> Self {
189 FieldId { parent: def.parent.into(), local_id: def.id }
190 }
191}
192
193impl From<FieldId> for Field {
194 fn from(def: FieldId) -> Self {
195 Field { parent: def.parent.into(), id: def.local_id }
196 }
197}
198
199impl From<AttrDef> for AttrDefId {
200 fn from(def: AttrDef) -> Self {
201 match def {
202 AttrDef::Module(it) => AttrDefId::ModuleId(it.id),
203 AttrDef::Field(it) => AttrDefId::FieldId(it.into()),
204 AttrDef::Adt(it) => AttrDefId::AdtId(it.into()),
205 AttrDef::Function(it) => AttrDefId::FunctionId(it.id),
206 AttrDef::EnumVariant(it) => AttrDefId::EnumVariantId(it.into()),
207 AttrDef::Static(it) => AttrDefId::StaticId(it.id),
208 AttrDef::Const(it) => AttrDefId::ConstId(it.id),
209 AttrDef::Trait(it) => AttrDefId::TraitId(it.id),
210 AttrDef::TypeAlias(it) => AttrDefId::TypeAliasId(it.id),
211 AttrDef::MacroDef(it) => AttrDefId::MacroDefId(it.id),
212 }
213 }
214}
215
216impl From<AssocItem> for GenericDefId {
217 fn from(item: AssocItem) -> Self {
218 match item {
219 AssocItem::Function(f) => f.id.into(),
220 AssocItem::Const(c) => c.id.into(),
221 AssocItem::TypeAlias(t) => t.id.into(),
222 }
223 }
224}
225
226impl From<(DefWithBodyId, PatId)> for Local {
227 fn from((parent, pat_id): (DefWithBodyId, PatId)) -> Self {
228 Local { parent, pat_id }
229 }
230}
231
232impl From<MacroDef> for ItemInNs {
233 fn from(macro_def: MacroDef) -> Self {
234 ItemInNs::Macros(macro_def.into())
235 }
236}
237
238impl From<ModuleDef> for ItemInNs {
239 fn from(module_def: ModuleDef) -> Self {
240 match module_def {
241 ModuleDef::Static(_) | ModuleDef::Const(_) | ModuleDef::Function(_) => {
242 ItemInNs::Values(module_def.into())
243 }
244 _ => ItemInNs::Types(module_def.into()),
245 }
246 }
247}
diff --git a/crates/ra_hir/src/has_source.rs b/crates/ra_hir/src/has_source.rs
deleted file mode 100644
index f2eb70057..000000000
--- a/crates/ra_hir/src/has_source.rs
+++ /dev/null
@@ -1,135 +0,0 @@
1//! Provides set of implementation for hir's objects that allows get back location in file.
2
3use either::Either;
4use hir_def::{
5 nameres::{ModuleOrigin, ModuleSource},
6 src::{HasChildSource, HasSource as _},
7 Lookup, VariantId,
8};
9use ra_syntax::ast;
10
11use crate::{
12 db::HirDatabase, Const, Enum, EnumVariant, Field, FieldSource, Function, ImplDef, MacroDef,
13 Module, Static, Struct, Trait, TypeAlias, TypeParam, Union,
14};
15
16pub use hir_expand::InFile;
17
18pub trait HasSource {
19 type Ast;
20 fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast>;
21}
22
23/// NB: Module is !HasSource, because it has two source nodes at the same time:
24/// definition and declaration.
25impl Module {
26 /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
27 pub fn definition_source(self, db: &dyn HirDatabase) -> InFile<ModuleSource> {
28 let def_map = db.crate_def_map(self.id.krate);
29 def_map[self.id.local_id].definition_source(db.upcast())
30 }
31
32 pub fn is_mod_rs(self, db: &dyn HirDatabase) -> bool {
33 let def_map = db.crate_def_map(self.id.krate);
34 match def_map[self.id.local_id].origin {
35 ModuleOrigin::File { is_mod_rs, .. } => is_mod_rs,
36 _ => false,
37 }
38 }
39
40 /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`.
41 /// `None` for the crate root.
42 pub fn declaration_source(self, db: &dyn HirDatabase) -> Option<InFile<ast::Module>> {
43 let def_map = db.crate_def_map(self.id.krate);
44 def_map[self.id.local_id].declaration_source(db.upcast())
45 }
46}
47
48impl HasSource for Field {
49 type Ast = FieldSource;
50 fn source(self, db: &dyn HirDatabase) -> InFile<FieldSource> {
51 let var = VariantId::from(self.parent);
52 let src = var.child_source(db.upcast());
53 src.map(|it| match it[self.id].clone() {
54 Either::Left(it) => FieldSource::Pos(it),
55 Either::Right(it) => FieldSource::Named(it),
56 })
57 }
58}
59impl HasSource for Struct {
60 type Ast = ast::Struct;
61 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Struct> {
62 self.id.lookup(db.upcast()).source(db.upcast())
63 }
64}
65impl HasSource for Union {
66 type Ast = ast::Union;
67 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Union> {
68 self.id.lookup(db.upcast()).source(db.upcast())
69 }
70}
71impl HasSource for Enum {
72 type Ast = ast::Enum;
73 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Enum> {
74 self.id.lookup(db.upcast()).source(db.upcast())
75 }
76}
77impl HasSource for EnumVariant {
78 type Ast = ast::Variant;
79 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Variant> {
80 self.parent.id.child_source(db.upcast()).map(|map| map[self.id].clone())
81 }
82}
83impl HasSource for Function {
84 type Ast = ast::Fn;
85 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Fn> {
86 self.id.lookup(db.upcast()).source(db.upcast())
87 }
88}
89impl HasSource for Const {
90 type Ast = ast::Const;
91 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Const> {
92 self.id.lookup(db.upcast()).source(db.upcast())
93 }
94}
95impl HasSource for Static {
96 type Ast = ast::Static;
97 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Static> {
98 self.id.lookup(db.upcast()).source(db.upcast())
99 }
100}
101impl HasSource for Trait {
102 type Ast = ast::Trait;
103 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Trait> {
104 self.id.lookup(db.upcast()).source(db.upcast())
105 }
106}
107impl HasSource for TypeAlias {
108 type Ast = ast::TypeAlias;
109 fn source(self, db: &dyn HirDatabase) -> InFile<ast::TypeAlias> {
110 self.id.lookup(db.upcast()).source(db.upcast())
111 }
112}
113impl HasSource for MacroDef {
114 type Ast = ast::MacroCall;
115 fn source(self, db: &dyn HirDatabase) -> InFile<ast::MacroCall> {
116 InFile {
117 file_id: self.id.ast_id.expect("MacroDef without ast_id").file_id,
118 value: self.id.ast_id.expect("MacroDef without ast_id").to_node(db.upcast()),
119 }
120 }
121}
122impl HasSource for ImplDef {
123 type Ast = ast::Impl;
124 fn source(self, db: &dyn HirDatabase) -> InFile<ast::Impl> {
125 self.id.lookup(db.upcast()).source(db.upcast())
126 }
127}
128
129impl HasSource for TypeParam {
130 type Ast = Either<ast::Trait, ast::TypeParam>;
131 fn source(self, db: &dyn HirDatabase) -> InFile<Self::Ast> {
132 let child_source = self.id.parent.child_source(db.upcast());
133 child_source.map(|it| it[self.id.local_id].clone())
134 }
135}
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
deleted file mode 100644
index 31f3241c9..000000000
--- a/crates/ra_hir/src/lib.rs
+++ /dev/null
@@ -1,59 +0,0 @@
1//! HIR (previously known as descriptors) provides a high-level object oriented
2//! access to Rust code.
3//!
4//! The principal difference between HIR and syntax trees is that HIR is bound
5//! to a particular crate instance. That is, it has cfg flags and features
6//! applied. So, the relation between syntax and HIR is many-to-one.
7//!
8//! HIR is the public API of the all of the compiler logic above syntax trees.
9//! It is written in "OO" style. Each type is self contained (as in, it knows it's
10//! parents and full context). It should be "clean code".
11//!
12//! `ra_hir_*` crates are the implementation of the compiler logic.
13//! They are written in "ECS" style, with relatively little abstractions.
14//! Many types are not self-contained, and explicitly use local indexes, arenas, etc.
15//!
16//! `ra_hir` is what insulates the "we don't know how to actually write an incremental compiler"
17//! from the ide with completions, hovers, etc. It is a (soft, internal) boundary:
18//! https://www.tedinski.com/2018/02/06/system-boundaries.html.
19
20#![recursion_limit = "512"]
21
22mod semantics;
23pub mod db;
24mod source_analyzer;
25
26pub mod diagnostics;
27
28mod from_id;
29mod code_model;
30
31mod has_source;
32
33pub use crate::{
34 code_model::{
35 Adt, AsAssocItem, AssocItem, AssocItemContainer, AttrDef, Callable, CallableKind, Const,
36 Crate, CrateDependency, DefWithBody, Docs, Enum, EnumVariant, Field, FieldSource, Function,
37 GenericDef, HasAttrs, HasVisibility, ImplDef, Local, MacroDef, Module, ModuleDef, ScopeDef,
38 Static, Struct, Trait, Type, TypeAlias, TypeParam, Union, VariantDef, Visibility,
39 },
40 has_source::HasSource,
41 semantics::{original_range, PathResolution, Semantics, SemanticsScope},
42};
43
44pub use hir_def::{
45 adt::StructKind,
46 attr::Attrs,
47 body::scope::ExprScopes,
48 builtin_type::BuiltinType,
49 docs::Documentation,
50 nameres::ModuleSource,
51 path::{ModPath, Path, PathKind},
52 type_ref::Mutability,
53};
54pub use hir_expand::{
55 hygiene::Hygiene, name::Name, HirFileId, InFile, MacroCallId, MacroCallLoc,
56 MacroDefId, /* FIXME */
57 MacroFile, Origin,
58};
59pub use hir_ty::display::HirDisplay;
diff --git a/crates/ra_hir/src/semantics.rs b/crates/ra_hir/src/semantics.rs
deleted file mode 100644
index 307b336f2..000000000
--- a/crates/ra_hir/src/semantics.rs
+++ /dev/null
@@ -1,731 +0,0 @@
1//! See `Semantics`.
2
3mod source_to_def;
4
5use std::{cell::RefCell, fmt, iter::successors};
6
7use hir_def::{
8 resolver::{self, HasResolver, Resolver},
9 AsMacroCall, FunctionId, TraitId, VariantId,
10};
11use hir_expand::{diagnostics::AstDiagnostic, hygiene::Hygiene, ExpansionInfo};
12use hir_ty::associated_type_shorthand_candidates;
13use itertools::Itertools;
14use ra_db::{FileId, FileRange};
15use ra_prof::profile;
16use ra_syntax::{
17 algo::{find_node_at_offset, skip_trivia_token},
18 ast, AstNode, Direction, SyntaxNode, SyntaxToken, TextRange, TextSize,
19};
20use rustc_hash::{FxHashMap, FxHashSet};
21
22use crate::{
23 db::HirDatabase,
24 diagnostics::Diagnostic,
25 semantics::source_to_def::{ChildContainer, SourceToDefCache, SourceToDefCtx},
26 source_analyzer::{resolve_hir_path, resolve_hir_path_qualifier, SourceAnalyzer},
27 AssocItem, Callable, Field, Function, HirFileId, ImplDef, InFile, Local, MacroDef, Module,
28 ModuleDef, Name, Origin, Path, ScopeDef, Trait, Type, TypeAlias, TypeParam, VariantDef,
29};
30use resolver::TypeNs;
31
32#[derive(Debug, Clone, PartialEq, Eq)]
33pub enum PathResolution {
34 /// An item
35 Def(ModuleDef),
36 /// A local binding (only value namespace)
37 Local(Local),
38 /// A generic parameter
39 TypeParam(TypeParam),
40 SelfType(ImplDef),
41 Macro(MacroDef),
42 AssocItem(AssocItem),
43}
44
45impl PathResolution {
46 fn in_type_ns(&self) -> Option<TypeNs> {
47 match self {
48 PathResolution::Def(ModuleDef::Adt(adt)) => Some(TypeNs::AdtId((*adt).into())),
49 PathResolution::Def(ModuleDef::BuiltinType(builtin)) => {
50 Some(TypeNs::BuiltinType(*builtin))
51 }
52 PathResolution::Def(ModuleDef::Const(_))
53 | PathResolution::Def(ModuleDef::EnumVariant(_))
54 | PathResolution::Def(ModuleDef::Function(_))
55 | PathResolution::Def(ModuleDef::Module(_))
56 | PathResolution::Def(ModuleDef::Static(_))
57 | PathResolution::Def(ModuleDef::Trait(_)) => None,
58 PathResolution::Def(ModuleDef::TypeAlias(alias)) => {
59 Some(TypeNs::TypeAliasId((*alias).into()))
60 }
61 PathResolution::Local(_) | PathResolution::Macro(_) => None,
62 PathResolution::TypeParam(param) => Some(TypeNs::GenericParam((*param).into())),
63 PathResolution::SelfType(impl_def) => Some(TypeNs::SelfType((*impl_def).into())),
64 PathResolution::AssocItem(AssocItem::Const(_))
65 | PathResolution::AssocItem(AssocItem::Function(_)) => None,
66 PathResolution::AssocItem(AssocItem::TypeAlias(alias)) => {
67 Some(TypeNs::TypeAliasId((*alias).into()))
68 }
69 }
70 }
71
72 /// Returns an iterator over associated types that may be specified after this path (using
73 /// `Ty::Assoc` syntax).
74 pub fn assoc_type_shorthand_candidates<R>(
75 &self,
76 db: &dyn HirDatabase,
77 mut cb: impl FnMut(TypeAlias) -> Option<R>,
78 ) -> Option<R> {
79 associated_type_shorthand_candidates(db, self.in_type_ns()?, |_, _, id| cb(id.into()))
80 }
81}
82
83/// Primary API to get semantic information, like types, from syntax trees.
84pub struct Semantics<'db, DB> {
85 pub db: &'db DB,
86 imp: SemanticsImpl<'db>,
87}
88
89pub struct SemanticsImpl<'db> {
90 pub db: &'db dyn HirDatabase,
91 s2d_cache: RefCell<SourceToDefCache>,
92 expansion_info_cache: RefCell<FxHashMap<HirFileId, Option<ExpansionInfo>>>,
93 cache: RefCell<FxHashMap<SyntaxNode, HirFileId>>,
94}
95
96impl<DB> fmt::Debug for Semantics<'_, DB> {
97 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
98 write!(f, "Semantics {{ ... }}")
99 }
100}
101
102impl<'db, DB: HirDatabase> Semantics<'db, DB> {
103 pub fn new(db: &DB) -> Semantics<DB> {
104 let impl_ = SemanticsImpl::new(db);
105 Semantics { db, imp: impl_ }
106 }
107
108 pub fn parse(&self, file_id: FileId) -> ast::SourceFile {
109 self.imp.parse(file_id)
110 }
111
112 pub fn ast<T: AstDiagnostic + Diagnostic>(&self, d: &T) -> <T as AstDiagnostic>::AST {
113 let file_id = d.source().file_id;
114 let root = self.db.parse_or_expand(file_id).unwrap();
115 self.imp.cache(root, file_id);
116 d.ast(self.db.upcast())
117 }
118
119 pub fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
120 self.imp.expand(macro_call)
121 }
122
123 pub fn expand_hypothetical(
124 &self,
125 actual_macro_call: &ast::MacroCall,
126 hypothetical_args: &ast::TokenTree,
127 token_to_map: SyntaxToken,
128 ) -> Option<(SyntaxNode, SyntaxToken)> {
129 self.imp.expand_hypothetical(actual_macro_call, hypothetical_args, token_to_map)
130 }
131
132 pub fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
133 self.imp.descend_into_macros(token)
134 }
135
136 pub fn descend_node_at_offset<N: ast::AstNode>(
137 &self,
138 node: &SyntaxNode,
139 offset: TextSize,
140 ) -> Option<N> {
141 self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
142 }
143
144 pub fn original_range(&self, node: &SyntaxNode) -> FileRange {
145 self.imp.original_range(node)
146 }
147
148 pub fn diagnostics_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
149 self.imp.diagnostics_range(diagnostics)
150 }
151
152 pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
153 self.imp.ancestors_with_macros(node)
154 }
155
156 pub fn ancestors_at_offset_with_macros(
157 &self,
158 node: &SyntaxNode,
159 offset: TextSize,
160 ) -> impl Iterator<Item = SyntaxNode> + '_ {
161 self.imp.ancestors_at_offset_with_macros(node, offset)
162 }
163
164 /// Find a AstNode by offset inside SyntaxNode, if it is inside *Macrofile*,
165 /// search up until it is of the target AstNode type
166 pub fn find_node_at_offset_with_macros<N: AstNode>(
167 &self,
168 node: &SyntaxNode,
169 offset: TextSize,
170 ) -> Option<N> {
171 self.imp.ancestors_at_offset_with_macros(node, offset).find_map(N::cast)
172 }
173
174 /// Find a AstNode by offset inside SyntaxNode, if it is inside *MacroCall*,
175 /// descend it and find again
176 pub fn find_node_at_offset_with_descend<N: AstNode>(
177 &self,
178 node: &SyntaxNode,
179 offset: TextSize,
180 ) -> Option<N> {
181 if let Some(it) = find_node_at_offset(&node, offset) {
182 return Some(it);
183 }
184
185 self.imp.descend_node_at_offset(node, offset).find_map(N::cast)
186 }
187
188 pub fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
189 self.imp.type_of_expr(expr)
190 }
191
192 pub fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
193 self.imp.type_of_pat(pat)
194 }
195
196 pub fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
197 self.imp.type_of_self(param)
198 }
199
200 pub fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<Function> {
201 self.imp.resolve_method_call(call).map(Function::from)
202 }
203
204 pub fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
205 self.imp.resolve_method_call_as_callable(call)
206 }
207
208 pub fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
209 self.imp.resolve_field(field)
210 }
211
212 pub fn resolve_record_field(
213 &self,
214 field: &ast::RecordExprField,
215 ) -> Option<(Field, Option<Local>)> {
216 self.imp.resolve_record_field(field)
217 }
218
219 pub fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
220 self.imp.resolve_record_field_pat(field)
221 }
222
223 pub fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
224 self.imp.resolve_macro_call(macro_call)
225 }
226
227 pub fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
228 self.imp.resolve_path(path)
229 }
230
231 pub fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantDef> {
232 self.imp.resolve_variant(record_lit).map(VariantDef::from)
233 }
234
235 pub fn lower_path(&self, path: &ast::Path) -> Option<Path> {
236 self.imp.lower_path(path)
237 }
238
239 pub fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option<ModuleDef> {
240 self.imp.resolve_bind_pat_to_const(pat)
241 }
242
243 // FIXME: use this instead?
244 // pub fn resolve_name_ref(&self, name_ref: &ast::NameRef) -> Option<???>;
245
246 pub fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
247 self.imp.record_literal_missing_fields(literal)
248 }
249
250 pub fn record_pattern_missing_fields(&self, pattern: &ast::RecordPat) -> Vec<(Field, Type)> {
251 self.imp.record_pattern_missing_fields(pattern)
252 }
253
254 pub fn to_def<T: ToDef>(&self, src: &T) -> Option<T::Def> {
255 let src = self.imp.find_file(src.syntax().clone()).with_value(src).cloned();
256 T::to_def(&self.imp, src)
257 }
258
259 pub fn to_module_def(&self, file: FileId) -> Option<Module> {
260 self.imp.to_module_def(file)
261 }
262
263 pub fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
264 self.imp.scope(node)
265 }
266
267 pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
268 self.imp.scope_at_offset(node, offset)
269 }
270
271 pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
272 self.imp.scope_for_def(def)
273 }
274
275 pub fn assert_contains_node(&self, node: &SyntaxNode) {
276 self.imp.assert_contains_node(node)
277 }
278}
279
280impl<'db> SemanticsImpl<'db> {
281 fn new(db: &'db dyn HirDatabase) -> Self {
282 SemanticsImpl {
283 db,
284 s2d_cache: Default::default(),
285 cache: Default::default(),
286 expansion_info_cache: Default::default(),
287 }
288 }
289
290 fn parse(&self, file_id: FileId) -> ast::SourceFile {
291 let tree = self.db.parse(file_id).tree();
292 self.cache(tree.syntax().clone(), file_id.into());
293 tree
294 }
295
296 fn expand(&self, macro_call: &ast::MacroCall) -> Option<SyntaxNode> {
297 let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
298 let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
299 let file_id = sa.expand(self.db, macro_call)?;
300 let node = self.db.parse_or_expand(file_id)?;
301 self.cache(node.clone(), file_id);
302 Some(node)
303 }
304
305 fn expand_hypothetical(
306 &self,
307 actual_macro_call: &ast::MacroCall,
308 hypothetical_args: &ast::TokenTree,
309 token_to_map: SyntaxToken,
310 ) -> Option<(SyntaxNode, SyntaxToken)> {
311 let macro_call =
312 self.find_file(actual_macro_call.syntax().clone()).with_value(actual_macro_call);
313 let sa = self.analyze2(macro_call.map(|it| it.syntax()), None);
314 let krate = sa.resolver.krate()?;
315 let macro_call_id = macro_call.as_call_id(self.db.upcast(), krate, |path| {
316 sa.resolver.resolve_path_as_macro(self.db.upcast(), &path)
317 })?;
318 hir_expand::db::expand_hypothetical(
319 self.db.upcast(),
320 macro_call_id,
321 hypothetical_args,
322 token_to_map,
323 )
324 }
325
326 fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken {
327 let _p = profile("descend_into_macros");
328 let parent = token.parent();
329 let parent = self.find_file(parent);
330 let sa = self.analyze2(parent.as_ref(), None);
331
332 let token = successors(Some(parent.with_value(token)), |token| {
333 self.db.check_canceled();
334 let macro_call = token.value.ancestors().find_map(ast::MacroCall::cast)?;
335 let tt = macro_call.token_tree()?;
336 if !tt.syntax().text_range().contains_range(token.value.text_range()) {
337 return None;
338 }
339 let file_id = sa.expand(self.db, token.with_value(&macro_call))?;
340 let token = self
341 .expansion_info_cache
342 .borrow_mut()
343 .entry(file_id)
344 .or_insert_with(|| file_id.expansion_info(self.db.upcast()))
345 .as_ref()?
346 .map_token_down(token.as_ref())?;
347
348 self.cache(find_root(&token.value.parent()), token.file_id);
349
350 Some(token)
351 })
352 .last()
353 .unwrap();
354
355 token.value
356 }
357
358 fn descend_node_at_offset(
359 &self,
360 node: &SyntaxNode,
361 offset: TextSize,
362 ) -> impl Iterator<Item = SyntaxNode> + '_ {
363 // Handle macro token cases
364 node.token_at_offset(offset)
365 .map(|token| self.descend_into_macros(token))
366 .map(|it| self.ancestors_with_macros(it.parent()))
367 .flatten()
368 }
369
370 fn original_range(&self, node: &SyntaxNode) -> FileRange {
371 let node = self.find_file(node.clone());
372 original_range(self.db, node.as_ref())
373 }
374
375 fn diagnostics_range(&self, diagnostics: &dyn Diagnostic) -> FileRange {
376 let src = diagnostics.source();
377 let root = self.db.parse_or_expand(src.file_id).unwrap();
378 let node = src.value.to_node(&root);
379 original_range(self.db, src.with_value(&node))
380 }
381
382 fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ {
383 let node = self.find_file(node);
384 node.ancestors_with_macros(self.db.upcast()).map(|it| it.value)
385 }
386
387 fn ancestors_at_offset_with_macros(
388 &self,
389 node: &SyntaxNode,
390 offset: TextSize,
391 ) -> impl Iterator<Item = SyntaxNode> + '_ {
392 node.token_at_offset(offset)
393 .map(|token| self.ancestors_with_macros(token.parent()))
394 .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len())
395 }
396
397 fn type_of_expr(&self, expr: &ast::Expr) -> Option<Type> {
398 self.analyze(expr.syntax()).type_of_expr(self.db, &expr)
399 }
400
401 fn type_of_pat(&self, pat: &ast::Pat) -> Option<Type> {
402 self.analyze(pat.syntax()).type_of_pat(self.db, &pat)
403 }
404
405 fn type_of_self(&self, param: &ast::SelfParam) -> Option<Type> {
406 self.analyze(param.syntax()).type_of_self(self.db, &param)
407 }
408
409 fn resolve_method_call(&self, call: &ast::MethodCallExpr) -> Option<FunctionId> {
410 self.analyze(call.syntax()).resolve_method_call(self.db, call)
411 }
412
413 fn resolve_method_call_as_callable(&self, call: &ast::MethodCallExpr) -> Option<Callable> {
414 // FIXME: this erases Substs
415 let func = self.resolve_method_call(call)?;
416 let ty = self.db.value_ty(func.into());
417 let resolver = self.analyze(call.syntax()).resolver;
418 let ty = Type::new_with_resolver(self.db, &resolver, ty.value)?;
419 let mut res = ty.as_callable(self.db)?;
420 res.is_bound_method = true;
421 Some(res)
422 }
423
424 fn resolve_field(&self, field: &ast::FieldExpr) -> Option<Field> {
425 self.analyze(field.syntax()).resolve_field(self.db, field)
426 }
427
428 fn resolve_record_field(&self, field: &ast::RecordExprField) -> Option<(Field, Option<Local>)> {
429 self.analyze(field.syntax()).resolve_record_field(self.db, field)
430 }
431
432 fn resolve_record_field_pat(&self, field: &ast::RecordPatField) -> Option<Field> {
433 self.analyze(field.syntax()).resolve_record_field_pat(self.db, field)
434 }
435
436 fn resolve_macro_call(&self, macro_call: &ast::MacroCall) -> Option<MacroDef> {
437 let sa = self.analyze(macro_call.syntax());
438 let macro_call = self.find_file(macro_call.syntax().clone()).with_value(macro_call);
439 sa.resolve_macro_call(self.db, macro_call)
440 }
441
442 fn resolve_path(&self, path: &ast::Path) -> Option<PathResolution> {
443 self.analyze(path.syntax()).resolve_path(self.db, path)
444 }
445
446 fn resolve_variant(&self, record_lit: ast::RecordExpr) -> Option<VariantId> {
447 self.analyze(record_lit.syntax()).resolve_variant(self.db, record_lit)
448 }
449
450 fn lower_path(&self, path: &ast::Path) -> Option<Path> {
451 let src = self.find_file(path.syntax().clone());
452 Path::from_src(path.clone(), &Hygiene::new(self.db.upcast(), src.file_id.into()))
453 }
454
455 fn resolve_bind_pat_to_const(&self, pat: &ast::IdentPat) -> Option<ModuleDef> {
456 self.analyze(pat.syntax()).resolve_bind_pat_to_const(self.db, pat)
457 }
458
459 fn record_literal_missing_fields(&self, literal: &ast::RecordExpr) -> Vec<(Field, Type)> {
460 self.analyze(literal.syntax())
461 .record_literal_missing_fields(self.db, literal)
462 .unwrap_or_default()
463 }
464
465 fn record_pattern_missing_fields(&self, pattern: &ast::RecordPat) -> Vec<(Field, Type)> {
466 self.analyze(pattern.syntax())
467 .record_pattern_missing_fields(self.db, pattern)
468 .unwrap_or_default()
469 }
470
471 fn with_ctx<F: FnOnce(&mut SourceToDefCtx) -> T, T>(&self, f: F) -> T {
472 let mut cache = self.s2d_cache.borrow_mut();
473 let mut ctx = SourceToDefCtx { db: self.db, cache: &mut *cache };
474 f(&mut ctx)
475 }
476
477 fn to_module_def(&self, file: FileId) -> Option<Module> {
478 self.with_ctx(|ctx| ctx.file_to_def(file)).map(Module::from)
479 }
480
481 fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> {
482 let node = self.find_file(node.clone());
483 let resolver = self.analyze2(node.as_ref(), None).resolver;
484 SemanticsScope { db: self.db, resolver }
485 }
486
487 fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> {
488 let node = self.find_file(node.clone());
489 let resolver = self.analyze2(node.as_ref(), Some(offset)).resolver;
490 SemanticsScope { db: self.db, resolver }
491 }
492
493 fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> {
494 let resolver = def.id.resolver(self.db.upcast());
495 SemanticsScope { db: self.db, resolver }
496 }
497
498 fn analyze(&self, node: &SyntaxNode) -> SourceAnalyzer {
499 let src = self.find_file(node.clone());
500 self.analyze2(src.as_ref(), None)
501 }
502
503 fn analyze2(&self, src: InFile<&SyntaxNode>, offset: Option<TextSize>) -> SourceAnalyzer {
504 let _p = profile("Semantics::analyze2");
505
506 let container = match self.with_ctx(|ctx| ctx.find_container(src)) {
507 Some(it) => it,
508 None => return SourceAnalyzer::new_for_resolver(Resolver::default(), src),
509 };
510
511 let resolver = match container {
512 ChildContainer::DefWithBodyId(def) => {
513 return SourceAnalyzer::new_for_body(self.db, def, src, offset)
514 }
515 ChildContainer::TraitId(it) => it.resolver(self.db.upcast()),
516 ChildContainer::ImplId(it) => it.resolver(self.db.upcast()),
517 ChildContainer::ModuleId(it) => it.resolver(self.db.upcast()),
518 ChildContainer::EnumId(it) => it.resolver(self.db.upcast()),
519 ChildContainer::VariantId(it) => it.resolver(self.db.upcast()),
520 ChildContainer::TypeAliasId(it) => it.resolver(self.db.upcast()),
521 ChildContainer::GenericDefId(it) => it.resolver(self.db.upcast()),
522 };
523 SourceAnalyzer::new_for_resolver(resolver, src)
524 }
525
526 fn cache(&self, root_node: SyntaxNode, file_id: HirFileId) {
527 assert!(root_node.parent().is_none());
528 let mut cache = self.cache.borrow_mut();
529 let prev = cache.insert(root_node, file_id);
530 assert!(prev == None || prev == Some(file_id))
531 }
532
533 fn assert_contains_node(&self, node: &SyntaxNode) {
534 self.find_file(node.clone());
535 }
536
537 fn lookup(&self, root_node: &SyntaxNode) -> Option<HirFileId> {
538 let cache = self.cache.borrow();
539 cache.get(root_node).copied()
540 }
541
542 fn find_file(&self, node: SyntaxNode) -> InFile<SyntaxNode> {
543 let root_node = find_root(&node);
544 let file_id = self.lookup(&root_node).unwrap_or_else(|| {
545 panic!(
546 "\n\nFailed to lookup {:?} in this Semantics.\n\
547 Make sure to use only query nodes, derived from this instance of Semantics.\n\
548 root node: {:?}\n\
549 known nodes: {}\n\n",
550 node,
551 root_node,
552 self.cache
553 .borrow()
554 .keys()
555 .map(|it| format!("{:?}", it))
556 .collect::<Vec<_>>()
557 .join(", ")
558 )
559 });
560 InFile::new(file_id, node)
561 }
562}
563
564pub trait ToDef: AstNode + Clone {
565 type Def;
566
567 fn to_def(sema: &SemanticsImpl, src: InFile<Self>) -> Option<Self::Def>;
568}
569
570macro_rules! to_def_impls {
571 ($(($def:path, $ast:path, $meth:ident)),* ,) => {$(
572 impl ToDef for $ast {
573 type Def = $def;
574 fn to_def(sema: &SemanticsImpl, src: InFile<Self>) -> Option<Self::Def> {
575 sema.with_ctx(|ctx| ctx.$meth(src)).map(<$def>::from)
576 }
577 }
578 )*}
579}
580
581to_def_impls![
582 (crate::Module, ast::Module, module_to_def),
583 (crate::Struct, ast::Struct, struct_to_def),
584 (crate::Enum, ast::Enum, enum_to_def),
585 (crate::Union, ast::Union, union_to_def),
586 (crate::Trait, ast::Trait, trait_to_def),
587 (crate::ImplDef, ast::Impl, impl_to_def),
588 (crate::TypeAlias, ast::TypeAlias, type_alias_to_def),
589 (crate::Const, ast::Const, const_to_def),
590 (crate::Static, ast::Static, static_to_def),
591 (crate::Function, ast::Fn, fn_to_def),
592 (crate::Field, ast::RecordField, record_field_to_def),
593 (crate::Field, ast::TupleField, tuple_field_to_def),
594 (crate::EnumVariant, ast::Variant, enum_variant_to_def),
595 (crate::TypeParam, ast::TypeParam, type_param_to_def),
596 (crate::MacroDef, ast::MacroCall, macro_call_to_def), // this one is dubious, not all calls are macros
597 (crate::Local, ast::IdentPat, bind_pat_to_def),
598];
599
600fn find_root(node: &SyntaxNode) -> SyntaxNode {
601 node.ancestors().last().unwrap()
602}
603
604#[derive(Debug)]
605pub struct SemanticsScope<'a> {
606 pub db: &'a dyn HirDatabase,
607 resolver: Resolver,
608}
609
610impl<'a> SemanticsScope<'a> {
611 pub fn module(&self) -> Option<Module> {
612 Some(Module { id: self.resolver.module()? })
613 }
614
615 /// Note: `FxHashSet<TraitId>` should be treated as an opaque type, passed into `Type
616 // FIXME: rename to visible_traits to not repeat scope?
617 pub fn traits_in_scope(&self) -> FxHashSet<TraitId> {
618 let resolver = &self.resolver;
619 resolver.traits_in_scope(self.db.upcast())
620 }
621
622 pub fn process_all_names(&self, f: &mut dyn FnMut(Name, ScopeDef)) {
623 let resolver = &self.resolver;
624
625 resolver.process_all_names(self.db.upcast(), &mut |name, def| {
626 let def = match def {
627 resolver::ScopeDef::PerNs(it) => {
628 let items = ScopeDef::all_items(it);
629 for item in items {
630 f(name.clone(), item);
631 }
632 return;
633 }
634 resolver::ScopeDef::ImplSelfType(it) => ScopeDef::ImplSelfType(it.into()),
635 resolver::ScopeDef::AdtSelfType(it) => ScopeDef::AdtSelfType(it.into()),
636 resolver::ScopeDef::GenericParam(id) => ScopeDef::GenericParam(TypeParam { id }),
637 resolver::ScopeDef::Local(pat_id) => {
638 let parent = resolver.body_owner().unwrap().into();
639 ScopeDef::Local(Local { parent, pat_id })
640 }
641 };
642 f(name, def)
643 })
644 }
645
646 pub fn resolve_hir_path(&self, path: &Path) -> Option<PathResolution> {
647 resolve_hir_path(self.db, &self.resolver, path)
648 }
649
650 /// Resolves a path where we know it is a qualifier of another path.
651 ///
652 /// For example, if we have:
653 /// ```
654 /// mod my {
655 /// pub mod foo {
656 /// struct Bar;
657 /// }
658 ///
659 /// pub fn foo() {}
660 /// }
661 /// ```
662 /// then we know that `foo` in `my::foo::Bar` refers to the module, not the function.
663 pub fn resolve_hir_path_qualifier(&self, path: &Path) -> Option<PathResolution> {
664 resolve_hir_path_qualifier(self.db, &self.resolver, path)
665 }
666}
667
668// FIXME: Change `HasSource` trait to work with `Semantics` and remove this?
669pub fn original_range(db: &dyn HirDatabase, node: InFile<&SyntaxNode>) -> FileRange {
670 if let Some(range) = original_range_opt(db, node) {
671 let original_file = range.file_id.original_file(db.upcast());
672 if range.file_id == original_file.into() {
673 return FileRange { file_id: original_file, range: range.value };
674 }
675
676 log::error!("Fail to mapping up more for {:?}", range);
677 return FileRange { file_id: range.file_id.original_file(db.upcast()), range: range.value };
678 }
679
680 // Fall back to whole macro call
681 if let Some(expansion) = node.file_id.expansion_info(db.upcast()) {
682 if let Some(call_node) = expansion.call_node() {
683 return FileRange {
684 file_id: call_node.file_id.original_file(db.upcast()),
685 range: call_node.value.text_range(),
686 };
687 }
688 }
689
690 FileRange { file_id: node.file_id.original_file(db.upcast()), range: node.value.text_range() }
691}
692
693fn original_range_opt(
694 db: &dyn HirDatabase,
695 node: InFile<&SyntaxNode>,
696) -> Option<InFile<TextRange>> {
697 let expansion = node.file_id.expansion_info(db.upcast())?;
698
699 // the input node has only one token ?
700 let single = skip_trivia_token(node.value.first_token()?, Direction::Next)?
701 == skip_trivia_token(node.value.last_token()?, Direction::Prev)?;
702
703 Some(node.value.descendants().find_map(|it| {
704 let first = skip_trivia_token(it.first_token()?, Direction::Next)?;
705 let first = ascend_call_token(db, &expansion, node.with_value(first))?;
706
707 let last = skip_trivia_token(it.last_token()?, Direction::Prev)?;
708 let last = ascend_call_token(db, &expansion, node.with_value(last))?;
709
710 if (!single && first == last) || (first.file_id != last.file_id) {
711 return None;
712 }
713
714 Some(first.with_value(first.value.text_range().cover(last.value.text_range())))
715 })?)
716}
717
718fn ascend_call_token(
719 db: &dyn HirDatabase,
720 expansion: &ExpansionInfo,
721 token: InFile<SyntaxToken>,
722) -> Option<InFile<SyntaxToken>> {
723 let (mapped, origin) = expansion.map_token_up(token.as_ref())?;
724 if origin != Origin::Call {
725 return None;
726 }
727 if let Some(info) = mapped.file_id.expansion_info(db.upcast()) {
728 return ascend_call_token(db, &info, mapped);
729 }
730 Some(mapped)
731}
diff --git a/crates/ra_hir/src/semantics/source_to_def.rs b/crates/ra_hir/src/semantics/source_to_def.rs
deleted file mode 100644
index 863e8e5ff..000000000
--- a/crates/ra_hir/src/semantics/source_to_def.rs
+++ /dev/null
@@ -1,276 +0,0 @@
1//! Maps *syntax* of various definitions to their semantic ids.
2
3use hir_def::{
4 child_by_source::ChildBySource,
5 dyn_map::DynMap,
6 expr::PatId,
7 keys::{self, Key},
8 ConstId, DefWithBodyId, EnumId, EnumVariantId, FieldId, FunctionId, GenericDefId, ImplId,
9 ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId, UnionId, VariantId,
10};
11use hir_expand::{name::AsName, AstId, MacroDefKind};
12use ra_db::FileId;
13use ra_prof::profile;
14use ra_syntax::{
15 ast::{self, NameOwner},
16 match_ast, AstNode, SyntaxNode,
17};
18use rustc_hash::FxHashMap;
19use stdx::impl_from;
20
21use crate::{db::HirDatabase, InFile, MacroDefId};
22
23pub(super) type SourceToDefCache = FxHashMap<ChildContainer, DynMap>;
24
25pub(super) struct SourceToDefCtx<'a, 'b> {
26 pub(super) db: &'b dyn HirDatabase,
27 pub(super) cache: &'a mut SourceToDefCache,
28}
29
30impl SourceToDefCtx<'_, '_> {
31 pub(super) fn file_to_def(&mut self, file: FileId) -> Option<ModuleId> {
32 let _p = profile("SourceBinder::to_module_def");
33 let (krate, local_id) = self.db.relevant_crates(file).iter().find_map(|&crate_id| {
34 let crate_def_map = self.db.crate_def_map(crate_id);
35 let local_id = crate_def_map.modules_for_file(file).next()?;
36 Some((crate_id, local_id))
37 })?;
38 Some(ModuleId { krate, local_id })
39 }
40
41 pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> {
42 let _p = profile("module_to_def");
43 let parent_declaration = src
44 .as_ref()
45 .map(|it| it.syntax())
46 .cloned()
47 .ancestors_with_macros(self.db.upcast())
48 .skip(1)
49 .find_map(|it| {
50 let m = ast::Module::cast(it.value.clone())?;
51 Some(it.with_value(m))
52 });
53
54 let parent_module = match parent_declaration {
55 Some(parent_declaration) => self.module_to_def(parent_declaration),
56 None => {
57 let file_id = src.file_id.original_file(self.db.upcast());
58 self.file_to_def(file_id)
59 }
60 }?;
61
62 let child_name = src.value.name()?.as_name();
63 let def_map = self.db.crate_def_map(parent_module.krate);
64 let child_id = *def_map[parent_module.local_id].children.get(&child_name)?;
65 Some(ModuleId { krate: parent_module.krate, local_id: child_id })
66 }
67
68 pub(super) fn trait_to_def(&mut self, src: InFile<ast::Trait>) -> Option<TraitId> {
69 self.to_def(src, keys::TRAIT)
70 }
71 pub(super) fn impl_to_def(&mut self, src: InFile<ast::Impl>) -> Option<ImplId> {
72 self.to_def(src, keys::IMPL)
73 }
74 pub(super) fn fn_to_def(&mut self, src: InFile<ast::Fn>) -> Option<FunctionId> {
75 self.to_def(src, keys::FUNCTION)
76 }
77 pub(super) fn struct_to_def(&mut self, src: InFile<ast::Struct>) -> Option<StructId> {
78 self.to_def(src, keys::STRUCT)
79 }
80 pub(super) fn enum_to_def(&mut self, src: InFile<ast::Enum>) -> Option<EnumId> {
81 self.to_def(src, keys::ENUM)
82 }
83 pub(super) fn union_to_def(&mut self, src: InFile<ast::Union>) -> Option<UnionId> {
84 self.to_def(src, keys::UNION)
85 }
86 pub(super) fn static_to_def(&mut self, src: InFile<ast::Static>) -> Option<StaticId> {
87 self.to_def(src, keys::STATIC)
88 }
89 pub(super) fn const_to_def(&mut self, src: InFile<ast::Const>) -> Option<ConstId> {
90 self.to_def(src, keys::CONST)
91 }
92 pub(super) fn type_alias_to_def(&mut self, src: InFile<ast::TypeAlias>) -> Option<TypeAliasId> {
93 self.to_def(src, keys::TYPE_ALIAS)
94 }
95 pub(super) fn record_field_to_def(&mut self, src: InFile<ast::RecordField>) -> Option<FieldId> {
96 self.to_def(src, keys::RECORD_FIELD)
97 }
98 pub(super) fn tuple_field_to_def(&mut self, src: InFile<ast::TupleField>) -> Option<FieldId> {
99 self.to_def(src, keys::TUPLE_FIELD)
100 }
101 pub(super) fn enum_variant_to_def(
102 &mut self,
103 src: InFile<ast::Variant>,
104 ) -> Option<EnumVariantId> {
105 self.to_def(src, keys::VARIANT)
106 }
107 pub(super) fn bind_pat_to_def(
108 &mut self,
109 src: InFile<ast::IdentPat>,
110 ) -> Option<(DefWithBodyId, PatId)> {
111 let container = self.find_pat_container(src.as_ref().map(|it| it.syntax()))?;
112 let (_body, source_map) = self.db.body_with_source_map(container);
113 let src = src.map(ast::Pat::from);
114 let pat_id = source_map.node_pat(src.as_ref())?;
115 Some((container, pat_id))
116 }
117
118 fn to_def<Ast: AstNode + 'static, ID: Copy + 'static>(
119 &mut self,
120 src: InFile<Ast>,
121 key: Key<Ast, ID>,
122 ) -> Option<ID> {
123 let container = self.find_container(src.as_ref().map(|it| it.syntax()))?;
124 let db = self.db;
125 let dyn_map =
126 &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
127 dyn_map[key].get(&src).copied()
128 }
129
130 pub(super) fn type_param_to_def(&mut self, src: InFile<ast::TypeParam>) -> Option<TypeParamId> {
131 let container: ChildContainer =
132 self.find_type_param_container(src.as_ref().map(|it| it.syntax()))?.into();
133 let db = self.db;
134 let dyn_map =
135 &*self.cache.entry(container).or_insert_with(|| container.child_by_source(db));
136 dyn_map[keys::TYPE_PARAM].get(&src).copied()
137 }
138
139 // FIXME: use DynMap as well?
140 pub(super) fn macro_call_to_def(&mut self, src: InFile<ast::MacroCall>) -> Option<MacroDefId> {
141 let kind = MacroDefKind::Declarative;
142 let file_id = src.file_id.original_file(self.db.upcast());
143 let krate = self.file_to_def(file_id)?.krate;
144 let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value);
145 let ast_id = Some(AstId::new(src.file_id, file_ast_id));
146 Some(MacroDefId { krate: Some(krate), ast_id, kind, local_inner: false })
147 }
148
149 pub(super) fn find_container(&mut self, src: InFile<&SyntaxNode>) -> Option<ChildContainer> {
150 for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
151 let res: ChildContainer = match_ast! {
152 match (container.value) {
153 ast::Module(it) => {
154 let def = self.module_to_def(container.with_value(it))?;
155 def.into()
156 },
157 ast::Trait(it) => {
158 let def = self.trait_to_def(container.with_value(it))?;
159 def.into()
160 },
161 ast::Impl(it) => {
162 let def = self.impl_to_def(container.with_value(it))?;
163 def.into()
164 },
165 ast::Fn(it) => {
166 let def = self.fn_to_def(container.with_value(it))?;
167 DefWithBodyId::from(def).into()
168 },
169 ast::Struct(it) => {
170 let def = self.struct_to_def(container.with_value(it))?;
171 VariantId::from(def).into()
172 },
173 ast::Enum(it) => {
174 let def = self.enum_to_def(container.with_value(it))?;
175 def.into()
176 },
177 ast::Union(it) => {
178 let def = self.union_to_def(container.with_value(it))?;
179 VariantId::from(def).into()
180 },
181 ast::Static(it) => {
182 let def = self.static_to_def(container.with_value(it))?;
183 DefWithBodyId::from(def).into()
184 },
185 ast::Const(it) => {
186 let def = self.const_to_def(container.with_value(it))?;
187 DefWithBodyId::from(def).into()
188 },
189 ast::TypeAlias(it) => {
190 let def = self.type_alias_to_def(container.with_value(it))?;
191 def.into()
192 },
193 _ => continue,
194 }
195 };
196 return Some(res);
197 }
198
199 let def = self.file_to_def(src.file_id.original_file(self.db.upcast()))?;
200 Some(def.into())
201 }
202
203 fn find_type_param_container(&mut self, src: InFile<&SyntaxNode>) -> Option<GenericDefId> {
204 for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
205 let res: GenericDefId = match_ast! {
206 match (container.value) {
207 ast::Fn(it) => self.fn_to_def(container.with_value(it))?.into(),
208 ast::Struct(it) => self.struct_to_def(container.with_value(it))?.into(),
209 ast::Enum(it) => self.enum_to_def(container.with_value(it))?.into(),
210 ast::Trait(it) => self.trait_to_def(container.with_value(it))?.into(),
211 ast::TypeAlias(it) => self.type_alias_to_def(container.with_value(it))?.into(),
212 ast::Impl(it) => self.impl_to_def(container.with_value(it))?.into(),
213 _ => continue,
214 }
215 };
216 return Some(res);
217 }
218 None
219 }
220
221 fn find_pat_container(&mut self, src: InFile<&SyntaxNode>) -> Option<DefWithBodyId> {
222 for container in src.cloned().ancestors_with_macros(self.db.upcast()).skip(1) {
223 let res: DefWithBodyId = match_ast! {
224 match (container.value) {
225 ast::Const(it) => self.const_to_def(container.with_value(it))?.into(),
226 ast::Static(it) => self.static_to_def(container.with_value(it))?.into(),
227 ast::Fn(it) => self.fn_to_def(container.with_value(it))?.into(),
228 _ => continue,
229 }
230 };
231 return Some(res);
232 }
233 None
234 }
235}
236
237#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
238pub(crate) enum ChildContainer {
239 DefWithBodyId(DefWithBodyId),
240 ModuleId(ModuleId),
241 TraitId(TraitId),
242 ImplId(ImplId),
243 EnumId(EnumId),
244 VariantId(VariantId),
245 TypeAliasId(TypeAliasId),
246 /// XXX: this might be the same def as, for example an `EnumId`. However,
247 /// here the children generic parameters, and not, eg enum variants.
248 GenericDefId(GenericDefId),
249}
250impl_from! {
251 DefWithBodyId,
252 ModuleId,
253 TraitId,
254 ImplId,
255 EnumId,
256 VariantId,
257 TypeAliasId,
258 GenericDefId
259 for ChildContainer
260}
261
262impl ChildContainer {
263 fn child_by_source(self, db: &dyn HirDatabase) -> DynMap {
264 let db = db.upcast();
265 match self {
266 ChildContainer::DefWithBodyId(it) => it.child_by_source(db),
267 ChildContainer::ModuleId(it) => it.child_by_source(db),
268 ChildContainer::TraitId(it) => it.child_by_source(db),
269 ChildContainer::ImplId(it) => it.child_by_source(db),
270 ChildContainer::EnumId(it) => it.child_by_source(db),
271 ChildContainer::VariantId(it) => it.child_by_source(db),
272 ChildContainer::TypeAliasId(_) => DynMap::default(),
273 ChildContainer::GenericDefId(it) => it.child_by_source(db),
274 }
275 }
276}
diff --git a/crates/ra_hir/src/source_analyzer.rs b/crates/ra_hir/src/source_analyzer.rs
deleted file mode 100644
index d0cb62ef0..000000000
--- a/crates/ra_hir/src/source_analyzer.rs
+++ /dev/null
@@ -1,535 +0,0 @@
1//! Lookup hir elements using positions in the source code. This is a lossy
2//! transformation: in general, a single source might correspond to several
3//! modules, functions, etc, due to macros, cfgs and `#[path=]` attributes on
4//! modules.
5//!
6//! So, this modules should not be used during hir construction, it exists
7//! purely for "IDE needs".
8use std::{iter::once, sync::Arc};
9
10use hir_def::{
11 body::{
12 scope::{ExprScopes, ScopeId},
13 Body, BodySourceMap,
14 },
15 expr::{ExprId, Pat, PatId},
16 resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
17 AsMacroCall, DefWithBodyId, FieldId, FunctionId, LocalFieldId, VariantId,
18};
19use hir_expand::{hygiene::Hygiene, name::AsName, HirFileId, InFile};
20use hir_ty::{
21 diagnostics::{record_literal_missing_fields, record_pattern_missing_fields},
22 InferenceResult, Substs, Ty,
23};
24use ra_syntax::{
25 ast::{self, AstNode},
26 SyntaxNode, TextRange, TextSize,
27};
28
29use crate::{
30 db::HirDatabase, semantics::PathResolution, Adt, Const, EnumVariant, Field, Function, Local,
31 MacroDef, ModPath, ModuleDef, Path, PathKind, Static, Struct, Trait, Type, TypeAlias,
32 TypeParam,
33};
34use ra_db::CrateId;
35
36/// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
37/// original source files. It should not be used inside the HIR itself.
38#[derive(Debug)]
39pub(crate) struct SourceAnalyzer {
40 file_id: HirFileId,
41 pub(crate) resolver: Resolver,
42 body: Option<Arc<Body>>,
43 body_source_map: Option<Arc<BodySourceMap>>,
44 infer: Option<Arc<InferenceResult>>,
45 scopes: Option<Arc<ExprScopes>>,
46}
47
48impl SourceAnalyzer {
49 pub(crate) fn new_for_body(
50 db: &dyn HirDatabase,
51 def: DefWithBodyId,
52 node: InFile<&SyntaxNode>,
53 offset: Option<TextSize>,
54 ) -> SourceAnalyzer {
55 let (body, source_map) = db.body_with_source_map(def);
56 let scopes = db.expr_scopes(def);
57 let scope = match offset {
58 None => scope_for(&scopes, &source_map, node),
59 Some(offset) => scope_for_offset(db, &scopes, &source_map, node.with_value(offset)),
60 };
61 let resolver = resolver_for_scope(db.upcast(), def, scope);
62 SourceAnalyzer {
63 resolver,
64 body: Some(body),
65 body_source_map: Some(source_map),
66 infer: Some(db.infer(def)),
67 scopes: Some(scopes),
68 file_id: node.file_id,
69 }
70 }
71
72 pub(crate) fn new_for_resolver(
73 resolver: Resolver,
74 node: InFile<&SyntaxNode>,
75 ) -> SourceAnalyzer {
76 SourceAnalyzer {
77 resolver,
78 body: None,
79 body_source_map: None,
80 infer: None,
81 scopes: None,
82 file_id: node.file_id,
83 }
84 }
85
86 fn expr_id(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<ExprId> {
87 let src = match expr {
88 ast::Expr::MacroCall(call) => {
89 self.expand_expr(db, InFile::new(self.file_id, call.clone()))?
90 }
91 _ => InFile::new(self.file_id, expr.clone()),
92 };
93 let sm = self.body_source_map.as_ref()?;
94 sm.node_expr(src.as_ref())
95 }
96
97 fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
98 // FIXME: macros, see `expr_id`
99 let src = InFile { file_id: self.file_id, value: pat };
100 self.body_source_map.as_ref()?.node_pat(src)
101 }
102
103 fn expand_expr(
104 &self,
105 db: &dyn HirDatabase,
106 expr: InFile<ast::MacroCall>,
107 ) -> Option<InFile<ast::Expr>> {
108 let macro_file = self.body_source_map.as_ref()?.node_macro_file(expr.as_ref())?;
109 let expanded = db.parse_or_expand(macro_file)?;
110
111 let res = match ast::MacroCall::cast(expanded.clone()) {
112 Some(call) => self.expand_expr(db, InFile::new(macro_file, call))?,
113 _ => InFile::new(macro_file, ast::Expr::cast(expanded)?),
114 };
115 Some(res)
116 }
117
118 pub(crate) fn type_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<Type> {
119 let expr_id = self.expr_id(db, expr)?;
120 let ty = self.infer.as_ref()?[expr_id].clone();
121 Type::new_with_resolver(db, &self.resolver, ty)
122 }
123
124 pub(crate) fn type_of_pat(&self, db: &dyn HirDatabase, pat: &ast::Pat) -> Option<Type> {
125 let pat_id = self.pat_id(pat)?;
126 let ty = self.infer.as_ref()?[pat_id].clone();
127 Type::new_with_resolver(db, &self.resolver, ty)
128 }
129
130 pub(crate) fn type_of_self(
131 &self,
132 db: &dyn HirDatabase,
133 param: &ast::SelfParam,
134 ) -> Option<Type> {
135 let src = InFile { file_id: self.file_id, value: param };
136 let pat_id = self.body_source_map.as_ref()?.node_self_param(src)?;
137 let ty = self.infer.as_ref()?[pat_id].clone();
138 Type::new_with_resolver(db, &self.resolver, ty)
139 }
140
141 pub(crate) fn resolve_method_call(
142 &self,
143 db: &dyn HirDatabase,
144 call: &ast::MethodCallExpr,
145 ) -> Option<FunctionId> {
146 let expr_id = self.expr_id(db, &call.clone().into())?;
147 self.infer.as_ref()?.method_resolution(expr_id)
148 }
149
150 pub(crate) fn resolve_field(
151 &self,
152 db: &dyn HirDatabase,
153 field: &ast::FieldExpr,
154 ) -> Option<Field> {
155 let expr_id = self.expr_id(db, &field.clone().into())?;
156 self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
157 }
158
159 pub(crate) fn resolve_record_field(
160 &self,
161 db: &dyn HirDatabase,
162 field: &ast::RecordExprField,
163 ) -> Option<(Field, Option<Local>)> {
164 let expr = field.expr()?;
165 let expr_id = self.expr_id(db, &expr)?;
166 let local = if field.name_ref().is_some() {
167 None
168 } else {
169 let local_name = field.field_name()?.as_name();
170 let path = ModPath::from_segments(PathKind::Plain, once(local_name));
171 match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
172 Some(ValueNs::LocalBinding(pat_id)) => {
173 Some(Local { pat_id, parent: self.resolver.body_owner()? })
174 }
175 _ => None,
176 }
177 };
178 let struct_field = self.infer.as_ref()?.record_field_resolution(expr_id)?;
179 Some((struct_field.into(), local))
180 }
181
182 pub(crate) fn resolve_record_field_pat(
183 &self,
184 _db: &dyn HirDatabase,
185 field: &ast::RecordPatField,
186 ) -> Option<Field> {
187 let pat_id = self.pat_id(&field.pat()?)?;
188 let struct_field = self.infer.as_ref()?.record_field_pat_resolution(pat_id)?;
189 Some(struct_field.into())
190 }
191
192 pub(crate) fn resolve_macro_call(
193 &self,
194 db: &dyn HirDatabase,
195 macro_call: InFile<&ast::MacroCall>,
196 ) -> Option<MacroDef> {
197 let hygiene = Hygiene::new(db.upcast(), macro_call.file_id);
198 let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &hygiene))?;
199 self.resolver.resolve_path_as_macro(db.upcast(), path.mod_path()).map(|it| it.into())
200 }
201
202 pub(crate) fn resolve_bind_pat_to_const(
203 &self,
204 db: &dyn HirDatabase,
205 pat: &ast::IdentPat,
206 ) -> Option<ModuleDef> {
207 let pat_id = self.pat_id(&pat.clone().into())?;
208 let body = self.body.as_ref()?;
209 let path = match &body[pat_id] {
210 Pat::Path(path) => path,
211 _ => return None,
212 };
213 let res = resolve_hir_path(db, &self.resolver, &path)?;
214 match res {
215 PathResolution::Def(def) => Some(def),
216 _ => None,
217 }
218 }
219
220 pub(crate) fn resolve_path(
221 &self,
222 db: &dyn HirDatabase,
223 path: &ast::Path,
224 ) -> Option<PathResolution> {
225 if let Some(path_expr) = path.syntax().parent().and_then(ast::PathExpr::cast) {
226 let expr_id = self.expr_id(db, &path_expr.into())?;
227 if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_expr(expr_id) {
228 return Some(PathResolution::AssocItem(assoc.into()));
229 }
230 if let Some(VariantId::EnumVariantId(variant)) =
231 self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
232 {
233 return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
234 }
235 }
236
237 if let Some(path_pat) = path.syntax().parent().and_then(ast::PathPat::cast) {
238 let pat_id = self.pat_id(&path_pat.into())?;
239 if let Some(assoc) = self.infer.as_ref()?.assoc_resolutions_for_pat(pat_id) {
240 return Some(PathResolution::AssocItem(assoc.into()));
241 }
242 if let Some(VariantId::EnumVariantId(variant)) =
243 self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
244 {
245 return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
246 }
247 }
248
249 if let Some(rec_lit) = path.syntax().parent().and_then(ast::RecordExpr::cast) {
250 let expr_id = self.expr_id(db, &rec_lit.into())?;
251 if let Some(VariantId::EnumVariantId(variant)) =
252 self.infer.as_ref()?.variant_resolution_for_expr(expr_id)
253 {
254 return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
255 }
256 }
257
258 if let Some(rec_pat) = path.syntax().parent().and_then(ast::RecordPat::cast) {
259 let pat_id = self.pat_id(&rec_pat.into())?;
260 if let Some(VariantId::EnumVariantId(variant)) =
261 self.infer.as_ref()?.variant_resolution_for_pat(pat_id)
262 {
263 return Some(PathResolution::Def(ModuleDef::EnumVariant(variant.into())));
264 }
265 }
266
267 // This must be a normal source file rather than macro file.
268 let hir_path =
269 crate::Path::from_src(path.clone(), &Hygiene::new(db.upcast(), self.file_id))?;
270
271 // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we
272 // trying to resolve foo::bar.
273 if let Some(outer_path) = path.syntax().parent().and_then(ast::Path::cast) {
274 if let Some(qualifier) = outer_path.qualifier() {
275 if path == &qualifier {
276 return resolve_hir_path_qualifier(db, &self.resolver, &hir_path);
277 }
278 }
279 }
280
281 resolve_hir_path(db, &self.resolver, &hir_path)
282 }
283
284 pub(crate) fn record_literal_missing_fields(
285 &self,
286 db: &dyn HirDatabase,
287 literal: &ast::RecordExpr,
288 ) -> Option<Vec<(Field, Type)>> {
289 let krate = self.resolver.krate()?;
290 let body = self.body.as_ref()?;
291 let infer = self.infer.as_ref()?;
292
293 let expr_id = self.expr_id(db, &literal.clone().into())?;
294 let substs = match &infer.type_of_expr[expr_id] {
295 Ty::Apply(a_ty) => &a_ty.parameters,
296 _ => return None,
297 };
298
299 let (variant, missing_fields, _exhaustive) =
300 record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
301 let res = self.missing_fields(db, krate, substs, variant, missing_fields);
302 Some(res)
303 }
304
305 pub(crate) fn record_pattern_missing_fields(
306 &self,
307 db: &dyn HirDatabase,
308 pattern: &ast::RecordPat,
309 ) -> Option<Vec<(Field, Type)>> {
310 let krate = self.resolver.krate()?;
311 let body = self.body.as_ref()?;
312 let infer = self.infer.as_ref()?;
313
314 let pat_id = self.pat_id(&pattern.clone().into())?;
315 let substs = match &infer.type_of_pat[pat_id] {
316 Ty::Apply(a_ty) => &a_ty.parameters,
317 _ => return None,
318 };
319
320 let (variant, missing_fields, _exhaustive) =
321 record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
322 let res = self.missing_fields(db, krate, substs, variant, missing_fields);
323 Some(res)
324 }
325
326 fn missing_fields(
327 &self,
328 db: &dyn HirDatabase,
329 krate: CrateId,
330 substs: &Substs,
331 variant: VariantId,
332 missing_fields: Vec<LocalFieldId>,
333 ) -> Vec<(Field, Type)> {
334 let field_types = db.field_types(variant);
335
336 missing_fields
337 .into_iter()
338 .map(|local_id| {
339 let field = FieldId { parent: variant, local_id };
340 let ty = field_types[local_id].clone().subst(substs);
341 (field.into(), Type::new_with_resolver_inner(db, krate, &self.resolver, ty))
342 })
343 .collect()
344 }
345
346 pub(crate) fn expand(
347 &self,
348 db: &dyn HirDatabase,
349 macro_call: InFile<&ast::MacroCall>,
350 ) -> Option<HirFileId> {
351 let krate = self.resolver.krate()?;
352 let macro_call_id = macro_call.as_call_id(db.upcast(), krate, |path| {
353 self.resolver.resolve_path_as_macro(db.upcast(), &path)
354 })?;
355 Some(macro_call_id.as_file()).filter(|it| it.expansion_level(db.upcast()) < 64)
356 }
357
358 pub(crate) fn resolve_variant(
359 &self,
360 db: &dyn HirDatabase,
361 record_lit: ast::RecordExpr,
362 ) -> Option<VariantId> {
363 let infer = self.infer.as_ref()?;
364 let expr_id = self.expr_id(db, &record_lit.into())?;
365 infer.variant_resolution_for_expr(expr_id)
366 }
367}
368
369fn scope_for(
370 scopes: &ExprScopes,
371 source_map: &BodySourceMap,
372 node: InFile<&SyntaxNode>,
373) -> Option<ScopeId> {
374 node.value
375 .ancestors()
376 .filter_map(ast::Expr::cast)
377 .filter_map(|it| source_map.node_expr(InFile::new(node.file_id, &it)))
378 .find_map(|it| scopes.scope_for(it))
379}
380
381fn scope_for_offset(
382 db: &dyn HirDatabase,
383 scopes: &ExprScopes,
384 source_map: &BodySourceMap,
385 offset: InFile<TextSize>,
386) -> Option<ScopeId> {
387 scopes
388 .scope_by_expr()
389 .iter()
390 .filter_map(|(id, scope)| {
391 let source = source_map.expr_syntax(*id).ok()?;
392 // FIXME: correctly handle macro expansion
393 if source.file_id != offset.file_id {
394 return None;
395 }
396 let root = source.file_syntax(db.upcast());
397 let node = source.value.to_node(&root);
398 Some((node.syntax().text_range(), scope))
399 })
400 // find containing scope
401 .min_by_key(|(expr_range, _scope)| {
402 (
403 !(expr_range.start() <= offset.value && offset.value <= expr_range.end()),
404 expr_range.len(),
405 )
406 })
407 .map(|(expr_range, scope)| {
408 adjust(db, scopes, source_map, expr_range, offset).unwrap_or(*scope)
409 })
410}
411
412// XXX: during completion, cursor might be outside of any particular
413// expression. Try to figure out the correct scope...
414fn adjust(
415 db: &dyn HirDatabase,
416 scopes: &ExprScopes,
417 source_map: &BodySourceMap,
418 expr_range: TextRange,
419 offset: InFile<TextSize>,
420) -> Option<ScopeId> {
421 let child_scopes = scopes
422 .scope_by_expr()
423 .iter()
424 .filter_map(|(id, scope)| {
425 let source = source_map.expr_syntax(*id).ok()?;
426 // FIXME: correctly handle macro expansion
427 if source.file_id != offset.file_id {
428 return None;
429 }
430 let root = source.file_syntax(db.upcast());
431 let node = source.value.to_node(&root);
432 Some((node.syntax().text_range(), scope))
433 })
434 .filter(|&(range, _)| {
435 range.start() <= offset.value && expr_range.contains_range(range) && range != expr_range
436 });
437
438 child_scopes
439 .max_by(|&(r1, _), &(r2, _)| {
440 if r1.contains_range(r2) {
441 std::cmp::Ordering::Greater
442 } else if r2.contains_range(r1) {
443 std::cmp::Ordering::Less
444 } else {
445 r1.start().cmp(&r2.start())
446 }
447 })
448 .map(|(_ptr, scope)| *scope)
449}
450
451pub(crate) fn resolve_hir_path(
452 db: &dyn HirDatabase,
453 resolver: &Resolver,
454 path: &crate::Path,
455) -> Option<PathResolution> {
456 let types =
457 resolver.resolve_path_in_type_ns_fully(db.upcast(), path.mod_path()).map(|ty| match ty {
458 TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
459 TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
460 TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
461 PathResolution::Def(Adt::from(it).into())
462 }
463 TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
464 TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
465 TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
466 TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
467 });
468
469 let body_owner = resolver.body_owner();
470 let values =
471 resolver.resolve_path_in_value_ns_fully(db.upcast(), path.mod_path()).and_then(|val| {
472 let res = match val {
473 ValueNs::LocalBinding(pat_id) => {
474 let var = Local { parent: body_owner?.into(), pat_id };
475 PathResolution::Local(var)
476 }
477 ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
478 ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
479 ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
480 ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
481 ValueNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
482 ValueNs::ImplSelf(impl_id) => PathResolution::SelfType(impl_id.into()),
483 };
484 Some(res)
485 });
486
487 let items = resolver
488 .resolve_module_path_in_items(db.upcast(), path.mod_path())
489 .take_types()
490 .map(|it| PathResolution::Def(it.into()));
491
492 types.or(values).or(items).or_else(|| {
493 resolver
494 .resolve_path_as_macro(db.upcast(), path.mod_path())
495 .map(|def| PathResolution::Macro(def.into()))
496 })
497}
498
499/// Resolves a path where we know it is a qualifier of another path.
500///
501/// For example, if we have:
502/// ```
503/// mod my {
504/// pub mod foo {
505/// struct Bar;
506/// }
507///
508/// pub fn foo() {}
509/// }
510/// ```
511/// then we know that `foo` in `my::foo::Bar` refers to the module, not the function.
512pub(crate) fn resolve_hir_path_qualifier(
513 db: &dyn HirDatabase,
514 resolver: &Resolver,
515 path: &crate::Path,
516) -> Option<PathResolution> {
517 let items = resolver
518 .resolve_module_path_in_items(db.upcast(), path.mod_path())
519 .take_types()
520 .map(|it| PathResolution::Def(it.into()));
521
522 if items.is_some() {
523 return items;
524 }
525
526 resolver.resolve_path_in_type_ns_fully(db.upcast(), path.mod_path()).map(|ty| match ty {
527 TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
528 TypeNs::GenericParam(id) => PathResolution::TypeParam(TypeParam { id }),
529 TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => PathResolution::Def(Adt::from(it).into()),
530 TypeNs::EnumVariantId(it) => PathResolution::Def(EnumVariant::from(it).into()),
531 TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
532 TypeNs::BuiltinType(it) => PathResolution::Def(it.into()),
533 TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
534 })
535}
generated by cgit v1.2.3 (git 2.25.1) at 2025-07-22 23:41:53 +0100