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".
8 use std::iter::{self, once};
9
10 use either::Either;
11 use hir_def::{
12 body::{
13 scope::{ExprScopes, ScopeId},
14 Body, BodySourceMap,
15 },
16 hir::{BindingId, ExprId, Pat, PatId},
17 lang_item::LangItem,
18 lower::LowerCtx,
19 macro_id_to_def_id,
20 nameres::MacroSubNs,
21 path::{ModPath, Path, PathKind},
22 resolver::{resolver_for_scope, Resolver, TypeNs, ValueNs},
23 type_ref::Mutability,
24 AsMacroCall, AssocItemId, ConstId, DefWithBodyId, FieldId, FunctionId, ItemContainerId,
25 LocalFieldId, Lookup, ModuleDefId, TraitId, VariantId,
26 };
27 use hir_expand::{
28 builtin_fn_macro::BuiltinFnLikeExpander,
29 hygiene::Hygiene,
30 mod_path::path,
31 name,
32 name::{AsName, Name},
33 HirFileId, InFile,
34 };
35 use hir_ty::{
36 diagnostics::{
37 record_literal_missing_fields, record_pattern_missing_fields, unsafe_expressions,
38 UnsafeExpr,
39 },
40 lang_items::lang_items_for_bin_op,
41 method_resolution, Adjustment, InferenceResult, Interner, Substitution, Ty, TyExt, TyKind,
42 TyLoweringContext,
43 };
44 use itertools::Itertools;
45 use smallvec::SmallVec;
46 use syntax::{
47 ast::{self, AstNode},
48 SyntaxKind, SyntaxNode, TextRange, TextSize,
49 };
50 use triomphe::Arc;
51
52 use crate::{
53 db::HirDatabase, semantics::PathResolution, Adt, AssocItem, BindingMode, BuiltinAttr,
54 BuiltinType, Callable, Const, DeriveHelper, Field, Function, Local, Macro, ModuleDef, Static,
55 Struct, ToolModule, Trait, TraitAlias, Type, TypeAlias, Variant,
56 };
57
58 /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
59 /// original source files. It should not be used inside the HIR itself.
60 #[derive(Debug)]
61 pub(crate) struct SourceAnalyzer {
62 pub(crate) file_id: HirFileId,
63 pub(crate) resolver: Resolver,
64 def: Option<(DefWithBodyId, Arc<Body>, Arc<BodySourceMap>)>,
65 infer: Option<Arc<InferenceResult>>,
66 }
67
68 impl SourceAnalyzer {
69 pub(crate) fn new_for_body(
70 db: &dyn HirDatabase,
71 def: DefWithBodyId,
72 node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
73 offset: Option<TextSize>,
74 ) -> SourceAnalyzer {
75 let (body, source_map) = db.body_with_source_map(def);
76 let scopes = db.expr_scopes(def);
77 let scope = match offset {
78 None => scope_for(&scopes, &source_map, node),
79 Some(offset) => scope_for_offset(db, &scopes, &source_map, node.file_id, offset),
80 };
81 let resolver = resolver_for_scope(db.upcast(), def, scope);
82 SourceAnalyzer {
83 resolver,
84 def: Some((def, body, source_map)),
85 infer: Some(db.infer(def)),
86 file_id,
87 }
88 }
89
90 pub(crate) fn new_for_body_no_infer(
91 db: &dyn HirDatabase,
92 def: DefWithBodyId,
93 node @ InFile { file_id, .. }: InFile<&SyntaxNode>,
94 offset: Option<TextSize>,
95 ) -> SourceAnalyzer {
96 let (body, source_map) = db.body_with_source_map(def);
97 let scopes = db.expr_scopes(def);
98 let scope = match offset {
99 None => scope_for(&scopes, &source_map, node),
100 Some(offset) => scope_for_offset(db, &scopes, &source_map, node.file_id, offset),
101 };
102 let resolver = resolver_for_scope(db.upcast(), def, scope);
103 SourceAnalyzer { resolver, def: Some((def, body, source_map)), infer: None, file_id }
104 }
105
new_for_resolver( resolver: Resolver, node: InFile<&SyntaxNode>, ) -> SourceAnalyzer106 pub(crate) fn new_for_resolver(
107 resolver: Resolver,
108 node: InFile<&SyntaxNode>,
109 ) -> SourceAnalyzer {
110 SourceAnalyzer { resolver, def: None, infer: None, file_id: node.file_id }
111 }
112
body_source_map(&self) -> Option<&BodySourceMap>113 fn body_source_map(&self) -> Option<&BodySourceMap> {
114 self.def.as_ref().map(|(.., source_map)| &**source_map)
115 }
body(&self) -> Option<&Body>116 fn body(&self) -> Option<&Body> {
117 self.def.as_ref().map(|(_, body, _)| &**body)
118 }
119
expr_id(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<ExprId>120 fn expr_id(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<ExprId> {
121 let src = match expr {
122 ast::Expr::MacroExpr(expr) => {
123 self.expand_expr(db, InFile::new(self.file_id, expr.macro_call()?))?
124 }
125 _ => InFile::new(self.file_id, expr.clone()),
126 };
127 let sm = self.body_source_map()?;
128 sm.node_expr(src.as_ref())
129 }
130
pat_id(&self, pat: &ast::Pat) -> Option<PatId>131 fn pat_id(&self, pat: &ast::Pat) -> Option<PatId> {
132 // FIXME: macros, see `expr_id`
133 let src = InFile { file_id: self.file_id, value: pat };
134 self.body_source_map()?.node_pat(src)
135 }
136
binding_id_of_pat(&self, pat: &ast::IdentPat) -> Option<BindingId>137 fn binding_id_of_pat(&self, pat: &ast::IdentPat) -> Option<BindingId> {
138 let pat_id = self.pat_id(&pat.clone().into())?;
139 if let Pat::Bind { id, .. } = self.body()?.pats[pat_id] {
140 Some(id)
141 } else {
142 None
143 }
144 }
145
expand_expr( &self, db: &dyn HirDatabase, expr: InFile<ast::MacroCall>, ) -> Option<InFile<ast::Expr>>146 fn expand_expr(
147 &self,
148 db: &dyn HirDatabase,
149 expr: InFile<ast::MacroCall>,
150 ) -> Option<InFile<ast::Expr>> {
151 let macro_file = self.body_source_map()?.node_macro_file(expr.as_ref())?;
152 let expanded = db.parse_or_expand(macro_file);
153 let res = if let Some(stmts) = ast::MacroStmts::cast(expanded.clone()) {
154 match stmts.expr()? {
155 ast::Expr::MacroExpr(mac) => {
156 self.expand_expr(db, InFile::new(macro_file, mac.macro_call()?))?
157 }
158 expr => InFile::new(macro_file, expr),
159 }
160 } else if let Some(call) = ast::MacroCall::cast(expanded.clone()) {
161 self.expand_expr(db, InFile::new(macro_file, call))?
162 } else {
163 InFile::new(macro_file, ast::Expr::cast(expanded)?)
164 };
165
166 Some(res)
167 }
168
expr_adjustments( &self, db: &dyn HirDatabase, expr: &ast::Expr, ) -> Option<&[Adjustment]>169 pub(crate) fn expr_adjustments(
170 &self,
171 db: &dyn HirDatabase,
172 expr: &ast::Expr,
173 ) -> Option<&[Adjustment]> {
174 let expr_id = self.expr_id(db, expr)?;
175 let infer = self.infer.as_ref()?;
176 infer.expr_adjustments.get(&expr_id).map(|v| &**v)
177 }
178
type_of_expr( &self, db: &dyn HirDatabase, expr: &ast::Expr, ) -> Option<(Type, Option<Type>)>179 pub(crate) fn type_of_expr(
180 &self,
181 db: &dyn HirDatabase,
182 expr: &ast::Expr,
183 ) -> Option<(Type, Option<Type>)> {
184 let expr_id = self.expr_id(db, expr)?;
185 let infer = self.infer.as_ref()?;
186 let coerced = infer
187 .expr_adjustments
188 .get(&expr_id)
189 .and_then(|adjusts| adjusts.last().map(|adjust| adjust.target.clone()));
190 let ty = infer[expr_id].clone();
191 let mk_ty = |ty| Type::new_with_resolver(db, &self.resolver, ty);
192 Some((mk_ty(ty), coerced.map(mk_ty)))
193 }
194
type_of_pat( &self, db: &dyn HirDatabase, pat: &ast::Pat, ) -> Option<(Type, Option<Type>)>195 pub(crate) fn type_of_pat(
196 &self,
197 db: &dyn HirDatabase,
198 pat: &ast::Pat,
199 ) -> Option<(Type, Option<Type>)> {
200 let pat_id = self.pat_id(pat)?;
201 let infer = self.infer.as_ref()?;
202 let coerced = infer
203 .pat_adjustments
204 .get(&pat_id)
205 .and_then(|adjusts| adjusts.last().map(|adjust| adjust.clone()));
206 let ty = infer[pat_id].clone();
207 let mk_ty = |ty| Type::new_with_resolver(db, &self.resolver, ty);
208 Some((mk_ty(ty), coerced.map(mk_ty)))
209 }
210
type_of_binding_in_pat( &self, db: &dyn HirDatabase, pat: &ast::IdentPat, ) -> Option<Type>211 pub(crate) fn type_of_binding_in_pat(
212 &self,
213 db: &dyn HirDatabase,
214 pat: &ast::IdentPat,
215 ) -> Option<Type> {
216 let binding_id = self.binding_id_of_pat(pat)?;
217 let infer = self.infer.as_ref()?;
218 let ty = infer[binding_id].clone();
219 let mk_ty = |ty| Type::new_with_resolver(db, &self.resolver, ty);
220 Some(mk_ty(ty))
221 }
222
type_of_self( &self, db: &dyn HirDatabase, param: &ast::SelfParam, ) -> Option<Type>223 pub(crate) fn type_of_self(
224 &self,
225 db: &dyn HirDatabase,
226 param: &ast::SelfParam,
227 ) -> Option<Type> {
228 let src = InFile { file_id: self.file_id, value: param };
229 let pat_id = self.body_source_map()?.node_self_param(src)?;
230 let ty = self.infer.as_ref()?[pat_id].clone();
231 Some(Type::new_with_resolver(db, &self.resolver, ty))
232 }
233
binding_mode_of_pat( &self, _db: &dyn HirDatabase, pat: &ast::IdentPat, ) -> Option<BindingMode>234 pub(crate) fn binding_mode_of_pat(
235 &self,
236 _db: &dyn HirDatabase,
237 pat: &ast::IdentPat,
238 ) -> Option<BindingMode> {
239 let binding_id = self.binding_id_of_pat(pat)?;
240 let infer = self.infer.as_ref()?;
241 infer.binding_modes.get(binding_id).map(|bm| match bm {
242 hir_ty::BindingMode::Move => BindingMode::Move,
243 hir_ty::BindingMode::Ref(hir_ty::Mutability::Mut) => BindingMode::Ref(Mutability::Mut),
244 hir_ty::BindingMode::Ref(hir_ty::Mutability::Not) => {
245 BindingMode::Ref(Mutability::Shared)
246 }
247 })
248 }
pattern_adjustments( &self, db: &dyn HirDatabase, pat: &ast::Pat, ) -> Option<SmallVec<[Type; 1]>>249 pub(crate) fn pattern_adjustments(
250 &self,
251 db: &dyn HirDatabase,
252 pat: &ast::Pat,
253 ) -> Option<SmallVec<[Type; 1]>> {
254 let pat_id = self.pat_id(pat)?;
255 let infer = self.infer.as_ref()?;
256 Some(
257 infer
258 .pat_adjustments
259 .get(&pat_id)?
260 .iter()
261 .map(|ty| Type::new_with_resolver(db, &self.resolver, ty.clone()))
262 .collect(),
263 )
264 }
265
resolve_method_call_as_callable( &self, db: &dyn HirDatabase, call: &ast::MethodCallExpr, ) -> Option<Callable>266 pub(crate) fn resolve_method_call_as_callable(
267 &self,
268 db: &dyn HirDatabase,
269 call: &ast::MethodCallExpr,
270 ) -> Option<Callable> {
271 let expr_id = self.expr_id(db, &call.clone().into())?;
272 let (func, substs) = self.infer.as_ref()?.method_resolution(expr_id)?;
273 let ty = db.value_ty(func.into()).substitute(Interner, &substs);
274 let ty = Type::new_with_resolver(db, &self.resolver, ty);
275 let mut res = ty.as_callable(db)?;
276 res.is_bound_method = true;
277 Some(res)
278 }
279
resolve_method_call( &self, db: &dyn HirDatabase, call: &ast::MethodCallExpr, ) -> Option<FunctionId>280 pub(crate) fn resolve_method_call(
281 &self,
282 db: &dyn HirDatabase,
283 call: &ast::MethodCallExpr,
284 ) -> Option<FunctionId> {
285 let expr_id = self.expr_id(db, &call.clone().into())?;
286 let (f_in_trait, substs) = self.infer.as_ref()?.method_resolution(expr_id)?;
287
288 Some(self.resolve_impl_method_or_trait_def(db, f_in_trait, substs))
289 }
290
resolve_method_call_fallback( &self, db: &dyn HirDatabase, call: &ast::MethodCallExpr, ) -> Option<Either<FunctionId, FieldId>>291 pub(crate) fn resolve_method_call_fallback(
292 &self,
293 db: &dyn HirDatabase,
294 call: &ast::MethodCallExpr,
295 ) -> Option<Either<FunctionId, FieldId>> {
296 let expr_id = self.expr_id(db, &call.clone().into())?;
297 let inference_result = self.infer.as_ref()?;
298 match inference_result.method_resolution(expr_id) {
299 Some((f_in_trait, substs)) => {
300 Some(Either::Left(self.resolve_impl_method_or_trait_def(db, f_in_trait, substs)))
301 }
302 None => inference_result.field_resolution(expr_id).map(Either::Right),
303 }
304 }
305
resolve_await_to_poll( &self, db: &dyn HirDatabase, await_expr: &ast::AwaitExpr, ) -> Option<FunctionId>306 pub(crate) fn resolve_await_to_poll(
307 &self,
308 db: &dyn HirDatabase,
309 await_expr: &ast::AwaitExpr,
310 ) -> Option<FunctionId> {
311 let mut ty = self.ty_of_expr(db, &await_expr.expr()?)?.clone();
312
313 let into_future_trait = self
314 .resolver
315 .resolve_known_trait(db.upcast(), &path![core::future::IntoFuture])
316 .map(Trait::from);
317
318 if let Some(into_future_trait) = into_future_trait {
319 let type_ = Type::new_with_resolver(db, &self.resolver, ty.clone());
320 if type_.impls_trait(db, into_future_trait, &[]) {
321 let items = into_future_trait.items(db);
322 let into_future_type = items.into_iter().find_map(|item| match item {
323 AssocItem::TypeAlias(alias)
324 if alias.name(db) == hir_expand::name![IntoFuture] =>
325 {
326 Some(alias)
327 }
328 _ => None,
329 })?;
330 let future_trait = type_.normalize_trait_assoc_type(db, &[], into_future_type)?;
331 ty = future_trait.ty;
332 }
333 }
334
335 let future_trait = db.lang_item(self.resolver.krate(), LangItem::Future)?.as_trait()?;
336 let poll_fn = db.lang_item(self.resolver.krate(), LangItem::FuturePoll)?.as_function()?;
337 // HACK: subst for `poll()` coincides with that for `Future` because `poll()` itself
338 // doesn't have any generic parameters, so we skip building another subst for `poll()`.
339 let substs = hir_ty::TyBuilder::subst_for_def(db, future_trait, None).push(ty).build();
340 Some(self.resolve_impl_method_or_trait_def(db, poll_fn, substs))
341 }
342
resolve_prefix_expr( &self, db: &dyn HirDatabase, prefix_expr: &ast::PrefixExpr, ) -> Option<FunctionId>343 pub(crate) fn resolve_prefix_expr(
344 &self,
345 db: &dyn HirDatabase,
346 prefix_expr: &ast::PrefixExpr,
347 ) -> Option<FunctionId> {
348 let (lang_item, fn_name) = match prefix_expr.op_kind()? {
349 ast::UnaryOp::Deref => (LangItem::Deref, name![deref]),
350 ast::UnaryOp::Not => (LangItem::Not, name![not]),
351 ast::UnaryOp::Neg => (LangItem::Neg, name![neg]),
352 };
353 let ty = self.ty_of_expr(db, &prefix_expr.expr()?)?;
354
355 let (op_trait, op_fn) = self.lang_trait_fn(db, lang_item, &fn_name)?;
356 // HACK: subst for all methods coincides with that for their trait because the methods
357 // don't have any generic parameters, so we skip building another subst for the methods.
358 let substs = hir_ty::TyBuilder::subst_for_def(db, op_trait, None).push(ty.clone()).build();
359
360 Some(self.resolve_impl_method_or_trait_def(db, op_fn, substs))
361 }
362
resolve_index_expr( &self, db: &dyn HirDatabase, index_expr: &ast::IndexExpr, ) -> Option<FunctionId>363 pub(crate) fn resolve_index_expr(
364 &self,
365 db: &dyn HirDatabase,
366 index_expr: &ast::IndexExpr,
367 ) -> Option<FunctionId> {
368 let base_ty = self.ty_of_expr(db, &index_expr.base()?)?;
369 let index_ty = self.ty_of_expr(db, &index_expr.index()?)?;
370
371 let (op_trait, op_fn) = self.lang_trait_fn(db, LangItem::Index, &name![index])?;
372 // HACK: subst for all methods coincides with that for their trait because the methods
373 // don't have any generic parameters, so we skip building another subst for the methods.
374 let substs = hir_ty::TyBuilder::subst_for_def(db, op_trait, None)
375 .push(base_ty.clone())
376 .push(index_ty.clone())
377 .build();
378 Some(self.resolve_impl_method_or_trait_def(db, op_fn, substs))
379 }
380
resolve_bin_expr( &self, db: &dyn HirDatabase, binop_expr: &ast::BinExpr, ) -> Option<FunctionId>381 pub(crate) fn resolve_bin_expr(
382 &self,
383 db: &dyn HirDatabase,
384 binop_expr: &ast::BinExpr,
385 ) -> Option<FunctionId> {
386 let op = binop_expr.op_kind()?;
387 let lhs = self.ty_of_expr(db, &binop_expr.lhs()?)?;
388 let rhs = self.ty_of_expr(db, &binop_expr.rhs()?)?;
389
390 let (op_trait, op_fn) = lang_items_for_bin_op(op)
391 .and_then(|(name, lang_item)| self.lang_trait_fn(db, lang_item, &name))?;
392 // HACK: subst for `index()` coincides with that for `Index` because `index()` itself
393 // doesn't have any generic parameters, so we skip building another subst for `index()`.
394 let substs = hir_ty::TyBuilder::subst_for_def(db, op_trait, None)
395 .push(lhs.clone())
396 .push(rhs.clone())
397 .build();
398
399 Some(self.resolve_impl_method_or_trait_def(db, op_fn, substs))
400 }
401
resolve_try_expr( &self, db: &dyn HirDatabase, try_expr: &ast::TryExpr, ) -> Option<FunctionId>402 pub(crate) fn resolve_try_expr(
403 &self,
404 db: &dyn HirDatabase,
405 try_expr: &ast::TryExpr,
406 ) -> Option<FunctionId> {
407 let ty = self.ty_of_expr(db, &try_expr.expr()?)?;
408
409 let op_fn = db.lang_item(self.resolver.krate(), LangItem::TryTraitBranch)?.as_function()?;
410 let op_trait = match op_fn.lookup(db.upcast()).container {
411 ItemContainerId::TraitId(id) => id,
412 _ => return None,
413 };
414 // HACK: subst for `branch()` coincides with that for `Try` because `branch()` itself
415 // doesn't have any generic parameters, so we skip building another subst for `branch()`.
416 let substs = hir_ty::TyBuilder::subst_for_def(db, op_trait, None).push(ty.clone()).build();
417
418 Some(self.resolve_impl_method_or_trait_def(db, op_fn, substs))
419 }
420
resolve_field( &self, db: &dyn HirDatabase, field: &ast::FieldExpr, ) -> Option<Field>421 pub(crate) fn resolve_field(
422 &self,
423 db: &dyn HirDatabase,
424 field: &ast::FieldExpr,
425 ) -> Option<Field> {
426 let expr_id = self.expr_id(db, &field.clone().into())?;
427 self.infer.as_ref()?.field_resolution(expr_id).map(|it| it.into())
428 }
429
resolve_record_field( &self, db: &dyn HirDatabase, field: &ast::RecordExprField, ) -> Option<(Field, Option<Local>, Type)>430 pub(crate) fn resolve_record_field(
431 &self,
432 db: &dyn HirDatabase,
433 field: &ast::RecordExprField,
434 ) -> Option<(Field, Option<Local>, Type)> {
435 let record_expr = ast::RecordExpr::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
436 let expr = ast::Expr::from(record_expr);
437 let expr_id = self.body_source_map()?.node_expr(InFile::new(self.file_id, &expr))?;
438
439 let local_name = field.field_name()?.as_name();
440 let local = if field.name_ref().is_some() {
441 None
442 } else {
443 // Shorthand syntax, resolve to the local
444 let path = Path::from_known_path_with_no_generic(ModPath::from_segments(
445 PathKind::Plain,
446 once(local_name.clone()),
447 ));
448 match self.resolver.resolve_path_in_value_ns_fully(db.upcast(), &path) {
449 Some(ValueNs::LocalBinding(binding_id)) => {
450 Some(Local { binding_id, parent: self.resolver.body_owner()? })
451 }
452 _ => None,
453 }
454 };
455 let (_, subst) = self.infer.as_ref()?.type_of_expr.get(expr_id)?.as_adt()?;
456 let variant = self.infer.as_ref()?.variant_resolution_for_expr(expr_id)?;
457 let variant_data = variant.variant_data(db.upcast());
458 let field = FieldId { parent: variant, local_id: variant_data.field(&local_name)? };
459 let field_ty =
460 db.field_types(variant).get(field.local_id)?.clone().substitute(Interner, subst);
461 Some((field.into(), local, Type::new_with_resolver(db, &self.resolver, field_ty)))
462 }
463
resolve_record_pat_field( &self, db: &dyn HirDatabase, field: &ast::RecordPatField, ) -> Option<(Field, Type)>464 pub(crate) fn resolve_record_pat_field(
465 &self,
466 db: &dyn HirDatabase,
467 field: &ast::RecordPatField,
468 ) -> Option<(Field, Type)> {
469 let field_name = field.field_name()?.as_name();
470 let record_pat = ast::RecordPat::cast(field.syntax().parent().and_then(|p| p.parent())?)?;
471 let pat_id = self.pat_id(&record_pat.into())?;
472 let variant = self.infer.as_ref()?.variant_resolution_for_pat(pat_id)?;
473 let variant_data = variant.variant_data(db.upcast());
474 let field = FieldId { parent: variant, local_id: variant_data.field(&field_name)? };
475 let (_, subst) = self.infer.as_ref()?.type_of_pat.get(pat_id)?.as_adt()?;
476 let field_ty =
477 db.field_types(variant).get(field.local_id)?.clone().substitute(Interner, subst);
478 Some((field.into(), Type::new_with_resolver(db, &self.resolver, field_ty)))
479 }
480
resolve_macro_call( &self, db: &dyn HirDatabase, macro_call: InFile<&ast::MacroCall>, ) -> Option<Macro>481 pub(crate) fn resolve_macro_call(
482 &self,
483 db: &dyn HirDatabase,
484 macro_call: InFile<&ast::MacroCall>,
485 ) -> Option<Macro> {
486 let ctx = LowerCtx::with_file_id(db.upcast(), macro_call.file_id);
487 let path = macro_call.value.path().and_then(|ast| Path::from_src(ast, &ctx))?;
488 self.resolver
489 .resolve_path_as_macro(db.upcast(), path.mod_path()?, Some(MacroSubNs::Bang))
490 .map(|it| it.into())
491 }
492
resolve_bind_pat_to_const( &self, db: &dyn HirDatabase, pat: &ast::IdentPat, ) -> Option<ModuleDef>493 pub(crate) fn resolve_bind_pat_to_const(
494 &self,
495 db: &dyn HirDatabase,
496 pat: &ast::IdentPat,
497 ) -> Option<ModuleDef> {
498 let pat_id = self.pat_id(&pat.clone().into())?;
499 let body = self.body()?;
500 let path = match &body[pat_id] {
501 Pat::Path(path) => path,
502 _ => return None,
503 };
504 let res = resolve_hir_path(db, &self.resolver, path)?;
505 match res {
506 PathResolution::Def(def) => Some(def),
507 _ => None,
508 }
509 }
510
resolve_path( &self, db: &dyn HirDatabase, path: &ast::Path, ) -> Option<PathResolution>511 pub(crate) fn resolve_path(
512 &self,
513 db: &dyn HirDatabase,
514 path: &ast::Path,
515 ) -> Option<PathResolution> {
516 let parent = path.syntax().parent();
517 let parent = || parent.clone();
518
519 let mut prefer_value_ns = false;
520 let resolved = (|| {
521 let infer = self.infer.as_deref()?;
522 if let Some(path_expr) = parent().and_then(ast::PathExpr::cast) {
523 let expr_id = self.expr_id(db, &path_expr.into())?;
524 if let Some((assoc, subs)) = infer.assoc_resolutions_for_expr(expr_id) {
525 let assoc = match assoc {
526 AssocItemId::FunctionId(f_in_trait) => {
527 match infer.type_of_expr.get(expr_id) {
528 None => assoc,
529 Some(func_ty) => {
530 if let TyKind::FnDef(_fn_def, subs) = func_ty.kind(Interner) {
531 self.resolve_impl_method_or_trait_def(
532 db,
533 f_in_trait,
534 subs.clone(),
535 )
536 .into()
537 } else {
538 assoc
539 }
540 }
541 }
542 }
543 AssocItemId::ConstId(const_id) => {
544 self.resolve_impl_const_or_trait_def(db, const_id, subs).into()
545 }
546 assoc => assoc,
547 };
548
549 return Some(PathResolution::Def(AssocItem::from(assoc).into()));
550 }
551 if let Some(VariantId::EnumVariantId(variant)) =
552 infer.variant_resolution_for_expr(expr_id)
553 {
554 return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
555 }
556 prefer_value_ns = true;
557 } else if let Some(path_pat) = parent().and_then(ast::PathPat::cast) {
558 let pat_id = self.pat_id(&path_pat.into())?;
559 if let Some((assoc, subs)) = infer.assoc_resolutions_for_pat(pat_id) {
560 let assoc = match assoc {
561 AssocItemId::ConstId(const_id) => {
562 self.resolve_impl_const_or_trait_def(db, const_id, subs).into()
563 }
564 assoc => assoc,
565 };
566 return Some(PathResolution::Def(AssocItem::from(assoc).into()));
567 }
568 if let Some(VariantId::EnumVariantId(variant)) =
569 infer.variant_resolution_for_pat(pat_id)
570 {
571 return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
572 }
573 } else if let Some(rec_lit) = parent().and_then(ast::RecordExpr::cast) {
574 let expr_id = self.expr_id(db, &rec_lit.into())?;
575 if let Some(VariantId::EnumVariantId(variant)) =
576 infer.variant_resolution_for_expr(expr_id)
577 {
578 return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
579 }
580 } else {
581 let record_pat = parent().and_then(ast::RecordPat::cast).map(ast::Pat::from);
582 let tuple_struct_pat =
583 || parent().and_then(ast::TupleStructPat::cast).map(ast::Pat::from);
584 if let Some(pat) = record_pat.or_else(tuple_struct_pat) {
585 let pat_id = self.pat_id(&pat)?;
586 let variant_res_for_pat = infer.variant_resolution_for_pat(pat_id);
587 if let Some(VariantId::EnumVariantId(variant)) = variant_res_for_pat {
588 return Some(PathResolution::Def(ModuleDef::Variant(variant.into())));
589 }
590 }
591 }
592 None
593 })();
594 if let Some(_) = resolved {
595 return resolved;
596 }
597
598 // This must be a normal source file rather than macro file.
599 let hygiene = Hygiene::new(db.upcast(), self.file_id);
600 let ctx = LowerCtx::with_hygiene(db.upcast(), &hygiene);
601 let hir_path = Path::from_src(path.clone(), &ctx)?;
602
603 // Case where path is a qualifier of a use tree, e.g. foo::bar::{Baz, Qux} where we are
604 // trying to resolve foo::bar.
605 if let Some(use_tree) = parent().and_then(ast::UseTree::cast) {
606 if use_tree.coloncolon_token().is_some() {
607 return resolve_hir_path_qualifier(db, &self.resolver, &hir_path);
608 }
609 }
610
611 let meta_path = path
612 .syntax()
613 .ancestors()
614 .take_while(|it| {
615 let kind = it.kind();
616 ast::Path::can_cast(kind) || ast::Meta::can_cast(kind)
617 })
618 .last()
619 .and_then(ast::Meta::cast);
620
621 // Case where path is a qualifier of another path, e.g. foo::bar::Baz where we are
622 // trying to resolve foo::bar.
623 if path.parent_path().is_some() {
624 return match resolve_hir_path_qualifier(db, &self.resolver, &hir_path) {
625 None if meta_path.is_some() => {
626 path.first_segment().and_then(|it| it.name_ref()).and_then(|name_ref| {
627 ToolModule::by_name(db, self.resolver.krate().into(), &name_ref.text())
628 .map(PathResolution::ToolModule)
629 })
630 }
631 res => res,
632 };
633 } else if let Some(meta_path) = meta_path {
634 // Case where we are resolving the final path segment of a path in an attribute
635 // in this case we have to check for inert/builtin attributes and tools and prioritize
636 // resolution of attributes over other namespaces
637 if let Some(name_ref) = path.as_single_name_ref() {
638 let builtin =
639 BuiltinAttr::by_name(db, self.resolver.krate().into(), &name_ref.text());
640 if let Some(_) = builtin {
641 return builtin.map(PathResolution::BuiltinAttr);
642 }
643
644 if let Some(attr) = meta_path.parent_attr() {
645 let adt = if let Some(field) =
646 attr.syntax().parent().and_then(ast::RecordField::cast)
647 {
648 field.syntax().ancestors().take(4).find_map(ast::Adt::cast)
649 } else if let Some(field) =
650 attr.syntax().parent().and_then(ast::TupleField::cast)
651 {
652 field.syntax().ancestors().take(4).find_map(ast::Adt::cast)
653 } else if let Some(variant) =
654 attr.syntax().parent().and_then(ast::Variant::cast)
655 {
656 variant.syntax().ancestors().nth(2).and_then(ast::Adt::cast)
657 } else {
658 None
659 };
660 if let Some(adt) = adt {
661 let ast_id = db.ast_id_map(self.file_id).ast_id(&adt);
662 if let Some(helpers) = self
663 .resolver
664 .def_map()
665 .derive_helpers_in_scope(InFile::new(self.file_id, ast_id))
666 {
667 // FIXME: Multiple derives can have the same helper
668 let name_ref = name_ref.as_name();
669 for (macro_id, mut helpers) in
670 helpers.iter().group_by(|(_, macro_id, ..)| macro_id).into_iter()
671 {
672 if let Some(idx) = helpers.position(|(name, ..)| *name == name_ref)
673 {
674 return Some(PathResolution::DeriveHelper(DeriveHelper {
675 derive: *macro_id,
676 idx: idx as u32,
677 }));
678 }
679 }
680 }
681 }
682 }
683 }
684 return match resolve_hir_path_as_attr_macro(db, &self.resolver, &hir_path) {
685 Some(m) => Some(PathResolution::Def(ModuleDef::Macro(m))),
686 // this labels any path that starts with a tool module as the tool itself, this is technically wrong
687 // but there is no benefit in differentiating these two cases for the time being
688 None => path.first_segment().and_then(|it| it.name_ref()).and_then(|name_ref| {
689 ToolModule::by_name(db, self.resolver.krate().into(), &name_ref.text())
690 .map(PathResolution::ToolModule)
691 }),
692 };
693 }
694 if parent().map_or(false, |it| ast::Visibility::can_cast(it.kind())) {
695 resolve_hir_path_qualifier(db, &self.resolver, &hir_path)
696 } else {
697 resolve_hir_path_(db, &self.resolver, &hir_path, prefer_value_ns)
698 }
699 }
700
record_literal_missing_fields( &self, db: &dyn HirDatabase, literal: &ast::RecordExpr, ) -> Option<Vec<(Field, Type)>>701 pub(crate) fn record_literal_missing_fields(
702 &self,
703 db: &dyn HirDatabase,
704 literal: &ast::RecordExpr,
705 ) -> Option<Vec<(Field, Type)>> {
706 let body = self.body()?;
707 let infer = self.infer.as_ref()?;
708
709 let expr_id = self.expr_id(db, &literal.clone().into())?;
710 let substs = infer.type_of_expr[expr_id].as_adt()?.1;
711
712 let (variant, missing_fields, _exhaustive) =
713 record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
714 let res = self.missing_fields(db, substs, variant, missing_fields);
715 Some(res)
716 }
717
record_pattern_missing_fields( &self, db: &dyn HirDatabase, pattern: &ast::RecordPat, ) -> Option<Vec<(Field, Type)>>718 pub(crate) fn record_pattern_missing_fields(
719 &self,
720 db: &dyn HirDatabase,
721 pattern: &ast::RecordPat,
722 ) -> Option<Vec<(Field, Type)>> {
723 let body = self.body()?;
724 let infer = self.infer.as_ref()?;
725
726 let pat_id = self.pat_id(&pattern.clone().into())?;
727 let substs = infer.type_of_pat[pat_id].as_adt()?.1;
728
729 let (variant, missing_fields, _exhaustive) =
730 record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
731 let res = self.missing_fields(db, substs, variant, missing_fields);
732 Some(res)
733 }
734
missing_fields( &self, db: &dyn HirDatabase, substs: &Substitution, variant: VariantId, missing_fields: Vec<LocalFieldId>, ) -> Vec<(Field, Type)>735 fn missing_fields(
736 &self,
737 db: &dyn HirDatabase,
738 substs: &Substitution,
739 variant: VariantId,
740 missing_fields: Vec<LocalFieldId>,
741 ) -> Vec<(Field, Type)> {
742 let field_types = db.field_types(variant);
743
744 missing_fields
745 .into_iter()
746 .map(|local_id| {
747 let field = FieldId { parent: variant, local_id };
748 let ty = field_types[local_id].clone().substitute(Interner, substs);
749 (field.into(), Type::new_with_resolver_inner(db, &self.resolver, ty))
750 })
751 .collect()
752 }
753
expand( &self, db: &dyn HirDatabase, macro_call: InFile<&ast::MacroCall>, ) -> Option<HirFileId>754 pub(crate) fn expand(
755 &self,
756 db: &dyn HirDatabase,
757 macro_call: InFile<&ast::MacroCall>,
758 ) -> Option<HirFileId> {
759 let krate = self.resolver.krate();
760 let macro_call_id = macro_call.as_call_id(db.upcast(), krate, |path| {
761 self.resolver
762 .resolve_path_as_macro(db.upcast(), &path, Some(MacroSubNs::Bang))
763 .map(|it| macro_id_to_def_id(db.upcast(), it))
764 })?;
765 Some(macro_call_id.as_file()).filter(|it| it.expansion_level(db.upcast()) < 64)
766 }
767
resolve_variant( &self, db: &dyn HirDatabase, record_lit: ast::RecordExpr, ) -> Option<VariantId>768 pub(crate) fn resolve_variant(
769 &self,
770 db: &dyn HirDatabase,
771 record_lit: ast::RecordExpr,
772 ) -> Option<VariantId> {
773 let infer = self.infer.as_ref()?;
774 let expr_id = self.expr_id(db, &record_lit.into())?;
775 infer.variant_resolution_for_expr(expr_id)
776 }
777
is_unsafe_macro_call( &self, db: &dyn HirDatabase, macro_call: InFile<&ast::MacroCall>, ) -> bool778 pub(crate) fn is_unsafe_macro_call(
779 &self,
780 db: &dyn HirDatabase,
781 macro_call: InFile<&ast::MacroCall>,
782 ) -> bool {
783 // check for asm/global_asm
784 if let Some(mac) = self.resolve_macro_call(db, macro_call) {
785 let ex = match mac.id {
786 hir_def::MacroId::Macro2Id(it) => it.lookup(db.upcast()).expander,
787 hir_def::MacroId::MacroRulesId(it) => it.lookup(db.upcast()).expander,
788 _ => hir_def::MacroExpander::Declarative,
789 };
790 match ex {
791 hir_def::MacroExpander::BuiltIn(e)
792 if e == BuiltinFnLikeExpander::Asm || e == BuiltinFnLikeExpander::GlobalAsm =>
793 {
794 return true
795 }
796 _ => (),
797 }
798 }
799 let macro_expr = match macro_call
800 .map(|it| it.syntax().parent().and_then(ast::MacroExpr::cast))
801 .transpose()
802 {
803 Some(it) => it,
804 None => return false,
805 };
806
807 if let (Some((def, body, sm)), Some(infer)) = (&self.def, &self.infer) {
808 if let Some(expanded_expr) = sm.macro_expansion_expr(macro_expr.as_ref()) {
809 let mut is_unsafe = false;
810 unsafe_expressions(
811 db,
812 infer,
813 *def,
814 body,
815 expanded_expr,
816 &mut |UnsafeExpr { inside_unsafe_block, .. }| is_unsafe |= !inside_unsafe_block,
817 );
818 return is_unsafe;
819 }
820 }
821 false
822 }
823
resolve_impl_method_or_trait_def( &self, db: &dyn HirDatabase, func: FunctionId, substs: Substitution, ) -> FunctionId824 fn resolve_impl_method_or_trait_def(
825 &self,
826 db: &dyn HirDatabase,
827 func: FunctionId,
828 substs: Substitution,
829 ) -> FunctionId {
830 let owner = match self.resolver.body_owner() {
831 Some(it) => it,
832 None => return func,
833 };
834 let env = db.trait_environment_for_body(owner);
835 method_resolution::lookup_impl_method(db, env, func, substs).0
836 }
837
resolve_impl_const_or_trait_def( &self, db: &dyn HirDatabase, const_id: ConstId, subs: Substitution, ) -> ConstId838 fn resolve_impl_const_or_trait_def(
839 &self,
840 db: &dyn HirDatabase,
841 const_id: ConstId,
842 subs: Substitution,
843 ) -> ConstId {
844 let owner = match self.resolver.body_owner() {
845 Some(it) => it,
846 None => return const_id,
847 };
848 let env = db.trait_environment_for_body(owner);
849 method_resolution::lookup_impl_const(db, env, const_id, subs).0
850 }
851
lang_trait_fn( &self, db: &dyn HirDatabase, lang_trait: LangItem, method_name: &Name, ) -> Option<(TraitId, FunctionId)>852 fn lang_trait_fn(
853 &self,
854 db: &dyn HirDatabase,
855 lang_trait: LangItem,
856 method_name: &Name,
857 ) -> Option<(TraitId, FunctionId)> {
858 let trait_id = db.lang_item(self.resolver.krate(), lang_trait)?.as_trait()?;
859 let fn_id = db.trait_data(trait_id).method_by_name(method_name)?;
860 Some((trait_id, fn_id))
861 }
862
ty_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<&Ty>863 fn ty_of_expr(&self, db: &dyn HirDatabase, expr: &ast::Expr) -> Option<&Ty> {
864 self.infer.as_ref()?.type_of_expr.get(self.expr_id(db, expr)?)
865 }
866 }
867
scope_for( scopes: &ExprScopes, source_map: &BodySourceMap, node: InFile<&SyntaxNode>, ) -> Option<ScopeId>868 fn scope_for(
869 scopes: &ExprScopes,
870 source_map: &BodySourceMap,
871 node: InFile<&SyntaxNode>,
872 ) -> Option<ScopeId> {
873 node.value
874 .ancestors()
875 .filter_map(ast::Expr::cast)
876 .filter_map(|it| source_map.node_expr(InFile::new(node.file_id, &it)))
877 .find_map(|it| scopes.scope_for(it))
878 }
879
scope_for_offset( db: &dyn HirDatabase, scopes: &ExprScopes, source_map: &BodySourceMap, from_file: HirFileId, offset: TextSize, ) -> Option<ScopeId>880 fn scope_for_offset(
881 db: &dyn HirDatabase,
882 scopes: &ExprScopes,
883 source_map: &BodySourceMap,
884 from_file: HirFileId,
885 offset: TextSize,
886 ) -> Option<ScopeId> {
887 scopes
888 .scope_by_expr()
889 .iter()
890 .filter_map(|(id, scope)| {
891 let InFile { file_id, value } = source_map.expr_syntax(*id).ok()?;
892 if from_file == file_id {
893 return Some((value.text_range(), scope));
894 }
895
896 // FIXME handle attribute expansion
897 let source = iter::successors(file_id.call_node(db.upcast()), |it| {
898 it.file_id.call_node(db.upcast())
899 })
900 .find(|it| it.file_id == from_file)
901 .filter(|it| it.value.kind() == SyntaxKind::MACRO_CALL)?;
902 Some((source.value.text_range(), scope))
903 })
904 .filter(|(expr_range, _scope)| expr_range.start() <= offset && offset <= expr_range.end())
905 // find containing scope
906 .min_by_key(|(expr_range, _scope)| expr_range.len())
907 .map(|(expr_range, scope)| {
908 adjust(db, scopes, source_map, expr_range, from_file, offset).unwrap_or(*scope)
909 })
910 }
911
912 // XXX: during completion, cursor might be outside of any particular
913 // expression. Try to figure out the correct scope...
adjust( db: &dyn HirDatabase, scopes: &ExprScopes, source_map: &BodySourceMap, expr_range: TextRange, from_file: HirFileId, offset: TextSize, ) -> Option<ScopeId>914 fn adjust(
915 db: &dyn HirDatabase,
916 scopes: &ExprScopes,
917 source_map: &BodySourceMap,
918 expr_range: TextRange,
919 from_file: HirFileId,
920 offset: TextSize,
921 ) -> Option<ScopeId> {
922 let child_scopes = scopes
923 .scope_by_expr()
924 .iter()
925 .filter_map(|(id, scope)| {
926 let source = source_map.expr_syntax(*id).ok()?;
927 // FIXME: correctly handle macro expansion
928 if source.file_id != from_file {
929 return None;
930 }
931 let root = source.file_syntax(db.upcast());
932 let node = source.value.to_node(&root);
933 Some((node.syntax().text_range(), scope))
934 })
935 .filter(|&(range, _)| {
936 range.start() <= offset && expr_range.contains_range(range) && range != expr_range
937 });
938
939 child_scopes
940 .max_by(|&(r1, _), &(r2, _)| {
941 if r1.contains_range(r2) {
942 std::cmp::Ordering::Greater
943 } else if r2.contains_range(r1) {
944 std::cmp::Ordering::Less
945 } else {
946 r1.start().cmp(&r2.start())
947 }
948 })
949 .map(|(_ptr, scope)| *scope)
950 }
951
952 #[inline]
resolve_hir_path( db: &dyn HirDatabase, resolver: &Resolver, path: &Path, ) -> Option<PathResolution>953 pub(crate) fn resolve_hir_path(
954 db: &dyn HirDatabase,
955 resolver: &Resolver,
956 path: &Path,
957 ) -> Option<PathResolution> {
958 resolve_hir_path_(db, resolver, path, false)
959 }
960
961 #[inline]
resolve_hir_path_as_attr_macro( db: &dyn HirDatabase, resolver: &Resolver, path: &Path, ) -> Option<Macro>962 pub(crate) fn resolve_hir_path_as_attr_macro(
963 db: &dyn HirDatabase,
964 resolver: &Resolver,
965 path: &Path,
966 ) -> Option<Macro> {
967 resolver
968 .resolve_path_as_macro(db.upcast(), path.mod_path()?, Some(MacroSubNs::Attr))
969 .map(Into::into)
970 }
971
resolve_hir_path_( db: &dyn HirDatabase, resolver: &Resolver, path: &Path, prefer_value_ns: bool, ) -> Option<PathResolution>972 fn resolve_hir_path_(
973 db: &dyn HirDatabase,
974 resolver: &Resolver,
975 path: &Path,
976 prefer_value_ns: bool,
977 ) -> Option<PathResolution> {
978 let types = || {
979 let (ty, unresolved) = match path.type_anchor() {
980 Some(type_ref) => {
981 let (_, res) = TyLoweringContext::new(db, resolver, resolver.module().into())
982 .lower_ty_ext(type_ref);
983 res.map(|ty_ns| (ty_ns, path.segments().first()))
984 }
985 None => {
986 let (ty, remaining_idx) = resolver.resolve_path_in_type_ns(db.upcast(), path)?;
987 match remaining_idx {
988 Some(remaining_idx) => {
989 if remaining_idx + 1 == path.segments().len() {
990 Some((ty, path.segments().last()))
991 } else {
992 None
993 }
994 }
995 None => Some((ty, None)),
996 }
997 }
998 }?;
999
1000 // If we are in a TypeNs for a Trait, and we have an unresolved name, try to resolve it as a type
1001 // within the trait's associated types.
1002 if let (Some(unresolved), &TypeNs::TraitId(trait_id)) = (&unresolved, &ty) {
1003 if let Some(type_alias_id) =
1004 db.trait_data(trait_id).associated_type_by_name(unresolved.name)
1005 {
1006 return Some(PathResolution::Def(ModuleDefId::from(type_alias_id).into()));
1007 }
1008 }
1009
1010 let res = match ty {
1011 TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
1012 TypeNs::GenericParam(id) => PathResolution::TypeParam(id.into()),
1013 TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
1014 PathResolution::Def(Adt::from(it).into())
1015 }
1016 TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
1017 TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
1018 TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
1019 TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
1020 TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
1021 };
1022 match unresolved {
1023 Some(unresolved) => resolver
1024 .generic_def()
1025 .and_then(|def| {
1026 hir_ty::associated_type_shorthand_candidates(
1027 db,
1028 def,
1029 res.in_type_ns()?,
1030 |name, id| (name == unresolved.name).then_some(id),
1031 )
1032 })
1033 .map(TypeAlias::from)
1034 .map(Into::into)
1035 .map(PathResolution::Def),
1036 None => Some(res),
1037 }
1038 };
1039
1040 let body_owner = resolver.body_owner();
1041 let values = || {
1042 resolver.resolve_path_in_value_ns_fully(db.upcast(), path).and_then(|val| {
1043 let res = match val {
1044 ValueNs::LocalBinding(binding_id) => {
1045 let var = Local { parent: body_owner?, binding_id };
1046 PathResolution::Local(var)
1047 }
1048 ValueNs::FunctionId(it) => PathResolution::Def(Function::from(it).into()),
1049 ValueNs::ConstId(it) => PathResolution::Def(Const::from(it).into()),
1050 ValueNs::StaticId(it) => PathResolution::Def(Static::from(it).into()),
1051 ValueNs::StructId(it) => PathResolution::Def(Struct::from(it).into()),
1052 ValueNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
1053 ValueNs::ImplSelf(impl_id) => PathResolution::SelfType(impl_id.into()),
1054 ValueNs::GenericParam(id) => PathResolution::ConstParam(id.into()),
1055 };
1056 Some(res)
1057 })
1058 };
1059
1060 let items = || {
1061 resolver
1062 .resolve_module_path_in_items(db.upcast(), path.mod_path()?)
1063 .take_types()
1064 .map(|it| PathResolution::Def(it.into()))
1065 };
1066
1067 let macros = || {
1068 resolver
1069 .resolve_path_as_macro(db.upcast(), path.mod_path()?, None)
1070 .map(|def| PathResolution::Def(ModuleDef::Macro(def.into())))
1071 };
1072
1073 if prefer_value_ns { values().or_else(types) } else { types().or_else(values) }
1074 .or_else(items)
1075 .or_else(macros)
1076 }
1077
1078 /// Resolves a path where we know it is a qualifier of another path.
1079 ///
1080 /// For example, if we have:
1081 /// ```
1082 /// mod my {
1083 /// pub mod foo {
1084 /// struct Bar;
1085 /// }
1086 ///
1087 /// pub fn foo() {}
1088 /// }
1089 /// ```
1090 /// then we know that `foo` in `my::foo::Bar` refers to the module, not the function.
resolve_hir_path_qualifier( db: &dyn HirDatabase, resolver: &Resolver, path: &Path, ) -> Option<PathResolution>1091 fn resolve_hir_path_qualifier(
1092 db: &dyn HirDatabase,
1093 resolver: &Resolver,
1094 path: &Path,
1095 ) -> Option<PathResolution> {
1096 resolver
1097 .resolve_path_in_type_ns_fully(db.upcast(), &path)
1098 .map(|ty| match ty {
1099 TypeNs::SelfType(it) => PathResolution::SelfType(it.into()),
1100 TypeNs::GenericParam(id) => PathResolution::TypeParam(id.into()),
1101 TypeNs::AdtSelfType(it) | TypeNs::AdtId(it) => {
1102 PathResolution::Def(Adt::from(it).into())
1103 }
1104 TypeNs::EnumVariantId(it) => PathResolution::Def(Variant::from(it).into()),
1105 TypeNs::TypeAliasId(it) => PathResolution::Def(TypeAlias::from(it).into()),
1106 TypeNs::BuiltinType(it) => PathResolution::Def(BuiltinType::from(it).into()),
1107 TypeNs::TraitId(it) => PathResolution::Def(Trait::from(it).into()),
1108 TypeNs::TraitAliasId(it) => PathResolution::Def(TraitAlias::from(it).into()),
1109 })
1110 .or_else(|| {
1111 resolver
1112 .resolve_module_path_in_items(db.upcast(), path.mod_path()?)
1113 .take_types()
1114 .map(|it| PathResolution::Def(it.into()))
1115 })
1116 }
1117