diff options
Diffstat (limited to 'crates/hir')
-rw-r--r-- | crates/hir/Cargo.toml | 1 | ||||
-rw-r--r-- | crates/hir/src/display.rs | 441 | ||||
-rw-r--r-- | crates/hir/src/lib.rs | 90 | ||||
-rw-r--r-- | crates/hir/src/semantics.rs | 38 | ||||
-rw-r--r-- | crates/hir/src/semantics/source_to_def.rs | 22 |
5 files changed, 552 insertions, 40 deletions
diff --git a/crates/hir/Cargo.toml b/crates/hir/Cargo.toml index d4ea7327e..55e9c3f0c 100644 --- a/crates/hir/Cargo.toml +++ b/crates/hir/Cargo.toml | |||
@@ -15,6 +15,7 @@ rustc-hash = "1.1.0" | |||
15 | either = "1.5.3" | 15 | either = "1.5.3" |
16 | arrayvec = "0.5.1" | 16 | arrayvec = "0.5.1" |
17 | itertools = "0.10.0" | 17 | itertools = "0.10.0" |
18 | smallvec = "1.4.0" | ||
18 | 19 | ||
19 | stdx = { path = "../stdx", version = "0.0.0" } | 20 | stdx = { path = "../stdx", version = "0.0.0" } |
20 | syntax = { path = "../syntax", version = "0.0.0" } | 21 | syntax = { path = "../syntax", version = "0.0.0" } |
diff --git a/crates/hir/src/display.rs b/crates/hir/src/display.rs new file mode 100644 index 000000000..44cdcc296 --- /dev/null +++ b/crates/hir/src/display.rs | |||
@@ -0,0 +1,441 @@ | |||
1 | //! HirDisplay implementations for various hir types. | ||
2 | use hir_def::{ | ||
3 | adt::VariantData, | ||
4 | generics::{TypeParamProvenance, WherePredicate, WherePredicateTypeTarget}, | ||
5 | type_ref::{TypeBound, TypeRef}, | ||
6 | AdtId, GenericDefId, | ||
7 | }; | ||
8 | use hir_ty::display::{ | ||
9 | write_bounds_like_dyn_trait_with_prefix, write_visibility, HirDisplay, HirDisplayError, | ||
10 | HirFormatter, | ||
11 | }; | ||
12 | use syntax::ast::{self, NameOwner}; | ||
13 | |||
14 | use crate::{ | ||
15 | Const, ConstParam, Enum, Field, Function, HasVisibility, Module, Static, Struct, Substs, Trait, | ||
16 | Type, TypeAlias, TypeParam, Union, Variant, | ||
17 | }; | ||
18 | |||
19 | impl HirDisplay for Function { | ||
20 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
21 | let data = f.db.function_data(self.id); | ||
22 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
23 | let qual = &data.qualifier; | ||
24 | if qual.is_default { | ||
25 | write!(f, "default ")?; | ||
26 | } | ||
27 | if qual.is_const { | ||
28 | write!(f, "const ")?; | ||
29 | } | ||
30 | if qual.is_async { | ||
31 | write!(f, "async ")?; | ||
32 | } | ||
33 | if qual.is_unsafe { | ||
34 | write!(f, "unsafe ")?; | ||
35 | } | ||
36 | if let Some(abi) = &qual.abi { | ||
37 | // FIXME: String escape? | ||
38 | write!(f, "extern \"{}\" ", abi)?; | ||
39 | } | ||
40 | write!(f, "fn {}", data.name)?; | ||
41 | |||
42 | write_generic_params(GenericDefId::FunctionId(self.id), f)?; | ||
43 | |||
44 | write!(f, "(")?; | ||
45 | |||
46 | let write_self_param = |ty: &TypeRef, f: &mut HirFormatter| match ty { | ||
47 | TypeRef::Path(p) if p.is_self_type() => write!(f, "self"), | ||
48 | TypeRef::Reference(inner, lifetime, mut_) if matches!(&**inner,TypeRef::Path(p) if p.is_self_type()) => | ||
49 | { | ||
50 | write!(f, "&")?; | ||
51 | if let Some(lifetime) = lifetime { | ||
52 | write!(f, "{} ", lifetime.name)?; | ||
53 | } | ||
54 | if let hir_def::type_ref::Mutability::Mut = mut_ { | ||
55 | write!(f, "mut ")?; | ||
56 | } | ||
57 | write!(f, "self") | ||
58 | } | ||
59 | _ => { | ||
60 | write!(f, "self: ")?; | ||
61 | ty.hir_fmt(f) | ||
62 | } | ||
63 | }; | ||
64 | |||
65 | let mut first = true; | ||
66 | for (param, type_ref) in self.assoc_fn_params(f.db).into_iter().zip(&data.params) { | ||
67 | if !first { | ||
68 | write!(f, ", ")?; | ||
69 | } else { | ||
70 | first = false; | ||
71 | if data.has_self_param { | ||
72 | write_self_param(type_ref, f)?; | ||
73 | continue; | ||
74 | } | ||
75 | } | ||
76 | match param.pattern_source(f.db) { | ||
77 | Some(ast::Pat::IdentPat(p)) if p.name().is_some() => { | ||
78 | write!(f, "{}: ", p.name().unwrap())? | ||
79 | } | ||
80 | _ => write!(f, "_: ")?, | ||
81 | } | ||
82 | // FIXME: Use resolved `param.ty` or raw `type_ref`? | ||
83 | // The former will ignore lifetime arguments currently. | ||
84 | type_ref.hir_fmt(f)?; | ||
85 | } | ||
86 | write!(f, ")")?; | ||
87 | |||
88 | // `FunctionData::ret_type` will be `::core::future::Future<Output = ...>` for async fns. | ||
89 | // Use ugly pattern match to strip the Future trait. | ||
90 | // Better way? | ||
91 | let ret_type = if !qual.is_async { | ||
92 | &data.ret_type | ||
93 | } else { | ||
94 | match &data.ret_type { | ||
95 | TypeRef::ImplTrait(bounds) => match &bounds[0] { | ||
96 | TypeBound::Path(path) => { | ||
97 | path.segments().iter().last().unwrap().args_and_bindings.unwrap().bindings | ||
98 | [0] | ||
99 | .type_ref | ||
100 | .as_ref() | ||
101 | .unwrap() | ||
102 | } | ||
103 | _ => panic!("Async fn ret_type should be impl Future"), | ||
104 | }, | ||
105 | _ => panic!("Async fn ret_type should be impl Future"), | ||
106 | } | ||
107 | }; | ||
108 | |||
109 | match ret_type { | ||
110 | TypeRef::Tuple(tup) if tup.is_empty() => {} | ||
111 | ty => { | ||
112 | write!(f, " -> ")?; | ||
113 | ty.hir_fmt(f)?; | ||
114 | } | ||
115 | } | ||
116 | |||
117 | write_where_clause(GenericDefId::FunctionId(self.id), f)?; | ||
118 | |||
119 | Ok(()) | ||
120 | } | ||
121 | } | ||
122 | |||
123 | impl HirDisplay for Struct { | ||
124 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
125 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
126 | write!(f, "struct ")?; | ||
127 | write!(f, "{}", self.name(f.db))?; | ||
128 | let def_id = GenericDefId::AdtId(AdtId::StructId(self.id)); | ||
129 | write_generic_params(def_id, f)?; | ||
130 | write_where_clause(def_id, f)?; | ||
131 | Ok(()) | ||
132 | } | ||
133 | } | ||
134 | |||
135 | impl HirDisplay for Enum { | ||
136 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
137 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
138 | write!(f, "enum ")?; | ||
139 | write!(f, "{}", self.name(f.db))?; | ||
140 | let def_id = GenericDefId::AdtId(AdtId::EnumId(self.id)); | ||
141 | write_generic_params(def_id, f)?; | ||
142 | write_where_clause(def_id, f)?; | ||
143 | Ok(()) | ||
144 | } | ||
145 | } | ||
146 | |||
147 | impl HirDisplay for Union { | ||
148 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
149 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
150 | write!(f, "union ")?; | ||
151 | write!(f, "{}", self.name(f.db))?; | ||
152 | let def_id = GenericDefId::AdtId(AdtId::UnionId(self.id)); | ||
153 | write_generic_params(def_id, f)?; | ||
154 | write_where_clause(def_id, f)?; | ||
155 | Ok(()) | ||
156 | } | ||
157 | } | ||
158 | |||
159 | impl HirDisplay for Field { | ||
160 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
161 | write_visibility(self.parent.module(f.db).id, self.visibility(f.db), f)?; | ||
162 | write!(f, "{}: ", self.name(f.db))?; | ||
163 | self.signature_ty(f.db).hir_fmt(f) | ||
164 | } | ||
165 | } | ||
166 | |||
167 | impl HirDisplay for Variant { | ||
168 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
169 | write!(f, "{}", self.name(f.db))?; | ||
170 | let data = self.variant_data(f.db); | ||
171 | match &*data { | ||
172 | VariantData::Unit => {} | ||
173 | VariantData::Tuple(fields) => { | ||
174 | write!(f, "(")?; | ||
175 | let mut first = true; | ||
176 | for (_, field) in fields.iter() { | ||
177 | if first { | ||
178 | first = false; | ||
179 | } else { | ||
180 | write!(f, ", ")?; | ||
181 | } | ||
182 | // Enum variant fields must be pub. | ||
183 | field.type_ref.hir_fmt(f)?; | ||
184 | } | ||
185 | write!(f, ")")?; | ||
186 | } | ||
187 | VariantData::Record(fields) => { | ||
188 | write!(f, " {{")?; | ||
189 | let mut first = true; | ||
190 | for (_, field) in fields.iter() { | ||
191 | if first { | ||
192 | first = false; | ||
193 | write!(f, " ")?; | ||
194 | } else { | ||
195 | write!(f, ", ")?; | ||
196 | } | ||
197 | // Enum variant fields must be pub. | ||
198 | write!(f, "{}: ", field.name)?; | ||
199 | field.type_ref.hir_fmt(f)?; | ||
200 | } | ||
201 | write!(f, " }}")?; | ||
202 | } | ||
203 | } | ||
204 | Ok(()) | ||
205 | } | ||
206 | } | ||
207 | |||
208 | impl HirDisplay for Type { | ||
209 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
210 | self.ty.value.hir_fmt(f) | ||
211 | } | ||
212 | } | ||
213 | |||
214 | impl HirDisplay for TypeParam { | ||
215 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
216 | write!(f, "{}", self.name(f.db))?; | ||
217 | let bounds = f.db.generic_predicates_for_param(self.id); | ||
218 | let substs = Substs::type_params(f.db, self.id.parent); | ||
219 | let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>(); | ||
220 | if !(predicates.is_empty() || f.omit_verbose_types()) { | ||
221 | write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?; | ||
222 | } | ||
223 | Ok(()) | ||
224 | } | ||
225 | } | ||
226 | |||
227 | impl HirDisplay for ConstParam { | ||
228 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
229 | write!(f, "const {}: ", self.name(f.db))?; | ||
230 | self.ty(f.db).hir_fmt(f) | ||
231 | } | ||
232 | } | ||
233 | |||
234 | fn write_generic_params(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
235 | let params = f.db.generic_params(def); | ||
236 | if params.lifetimes.is_empty() | ||
237 | && params.consts.is_empty() | ||
238 | && params | ||
239 | .types | ||
240 | .iter() | ||
241 | .all(|(_, param)| !matches!(param.provenance, TypeParamProvenance::TypeParamList)) | ||
242 | { | ||
243 | return Ok(()); | ||
244 | } | ||
245 | write!(f, "<")?; | ||
246 | |||
247 | let mut first = true; | ||
248 | let mut delim = |f: &mut HirFormatter| { | ||
249 | if first { | ||
250 | first = false; | ||
251 | Ok(()) | ||
252 | } else { | ||
253 | write!(f, ", ") | ||
254 | } | ||
255 | }; | ||
256 | for (_, lifetime) in params.lifetimes.iter() { | ||
257 | delim(f)?; | ||
258 | write!(f, "{}", lifetime.name)?; | ||
259 | } | ||
260 | for (_, ty) in params.types.iter() { | ||
261 | if ty.provenance != TypeParamProvenance::TypeParamList { | ||
262 | continue; | ||
263 | } | ||
264 | if let Some(name) = &ty.name { | ||
265 | delim(f)?; | ||
266 | write!(f, "{}", name)?; | ||
267 | if let Some(default) = &ty.default { | ||
268 | write!(f, " = ")?; | ||
269 | default.hir_fmt(f)?; | ||
270 | } | ||
271 | } | ||
272 | } | ||
273 | for (_, konst) in params.consts.iter() { | ||
274 | delim(f)?; | ||
275 | write!(f, "const {}: ", konst.name)?; | ||
276 | konst.ty.hir_fmt(f)?; | ||
277 | } | ||
278 | |||
279 | write!(f, ">")?; | ||
280 | Ok(()) | ||
281 | } | ||
282 | |||
283 | fn write_where_clause(def: GenericDefId, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
284 | let params = f.db.generic_params(def); | ||
285 | if params.where_predicates.is_empty() { | ||
286 | return Ok(()); | ||
287 | } | ||
288 | |||
289 | let write_target = |target: &WherePredicateTypeTarget, f: &mut HirFormatter| match target { | ||
290 | WherePredicateTypeTarget::TypeRef(ty) => ty.hir_fmt(f), | ||
291 | WherePredicateTypeTarget::TypeParam(id) => match ¶ms.types[*id].name { | ||
292 | Some(name) => write!(f, "{}", name), | ||
293 | None => write!(f, "{{unnamed}}"), | ||
294 | }, | ||
295 | }; | ||
296 | |||
297 | write!(f, "\nwhere")?; | ||
298 | |||
299 | for (pred_idx, pred) in params.where_predicates.iter().enumerate() { | ||
300 | let prev_pred = | ||
301 | if pred_idx == 0 { None } else { Some(¶ms.where_predicates[pred_idx - 1]) }; | ||
302 | |||
303 | let new_predicate = |f: &mut HirFormatter| { | ||
304 | write!(f, "{}", if pred_idx == 0 { "\n " } else { ",\n " }) | ||
305 | }; | ||
306 | |||
307 | match pred { | ||
308 | WherePredicate::TypeBound { target, bound } => { | ||
309 | if matches!(prev_pred, Some(WherePredicate::TypeBound { target: target_, .. }) if target_ == target) | ||
310 | { | ||
311 | write!(f, " + ")?; | ||
312 | } else { | ||
313 | new_predicate(f)?; | ||
314 | write_target(target, f)?; | ||
315 | write!(f, ": ")?; | ||
316 | } | ||
317 | bound.hir_fmt(f)?; | ||
318 | } | ||
319 | WherePredicate::Lifetime { target, bound } => { | ||
320 | if matches!(prev_pred, Some(WherePredicate::Lifetime { target: target_, .. }) if target_ == target) | ||
321 | { | ||
322 | write!(f, " + {}", bound.name)?; | ||
323 | } else { | ||
324 | new_predicate(f)?; | ||
325 | write!(f, "{}: {}", target.name, bound.name)?; | ||
326 | } | ||
327 | } | ||
328 | WherePredicate::ForLifetime { lifetimes, target, bound } => { | ||
329 | if matches!( | ||
330 | prev_pred, | ||
331 | Some(WherePredicate::ForLifetime { lifetimes: lifetimes_, target: target_, .. }) | ||
332 | if lifetimes_ == lifetimes && target_ == target, | ||
333 | ) { | ||
334 | write!(f, " + ")?; | ||
335 | } else { | ||
336 | new_predicate(f)?; | ||
337 | write!(f, "for<")?; | ||
338 | for (idx, lifetime) in lifetimes.iter().enumerate() { | ||
339 | if idx != 0 { | ||
340 | write!(f, ", ")?; | ||
341 | } | ||
342 | write!(f, "{}", lifetime)?; | ||
343 | } | ||
344 | write!(f, "> ")?; | ||
345 | write_target(target, f)?; | ||
346 | write!(f, ": ")?; | ||
347 | } | ||
348 | bound.hir_fmt(f)?; | ||
349 | } | ||
350 | } | ||
351 | } | ||
352 | |||
353 | // End of final predicate. There must be at least one predicate here. | ||
354 | write!(f, ",")?; | ||
355 | |||
356 | Ok(()) | ||
357 | } | ||
358 | |||
359 | impl HirDisplay for Const { | ||
360 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
361 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
362 | let data = f.db.const_data(self.id); | ||
363 | write!(f, "const ")?; | ||
364 | match &data.name { | ||
365 | Some(name) => write!(f, "{}: ", name)?, | ||
366 | None => write!(f, "_: ")?, | ||
367 | } | ||
368 | data.type_ref.hir_fmt(f)?; | ||
369 | Ok(()) | ||
370 | } | ||
371 | } | ||
372 | |||
373 | impl HirDisplay for Static { | ||
374 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
375 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
376 | let data = f.db.static_data(self.id); | ||
377 | write!(f, "static ")?; | ||
378 | if data.mutable { | ||
379 | write!(f, "mut ")?; | ||
380 | } | ||
381 | match &data.name { | ||
382 | Some(name) => write!(f, "{}: ", name)?, | ||
383 | None => write!(f, "_: ")?, | ||
384 | } | ||
385 | data.type_ref.hir_fmt(f)?; | ||
386 | Ok(()) | ||
387 | } | ||
388 | } | ||
389 | |||
390 | impl HirDisplay for Trait { | ||
391 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
392 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
393 | let data = f.db.trait_data(self.id); | ||
394 | if data.is_unsafe { | ||
395 | write!(f, "unsafe ")?; | ||
396 | } | ||
397 | if data.is_auto { | ||
398 | write!(f, "auto ")?; | ||
399 | } | ||
400 | write!(f, "trait {}", data.name)?; | ||
401 | let def_id = GenericDefId::TraitId(self.id); | ||
402 | write_generic_params(def_id, f)?; | ||
403 | if !data.bounds.is_empty() { | ||
404 | write!(f, ": ")?; | ||
405 | f.write_joined(&*data.bounds, " + ")?; | ||
406 | } | ||
407 | write_where_clause(def_id, f)?; | ||
408 | Ok(()) | ||
409 | } | ||
410 | } | ||
411 | |||
412 | impl HirDisplay for TypeAlias { | ||
413 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
414 | write_visibility(self.module(f.db).id, self.visibility(f.db), f)?; | ||
415 | let data = f.db.type_alias_data(self.id); | ||
416 | write!(f, "type {}", data.name)?; | ||
417 | if !data.bounds.is_empty() { | ||
418 | write!(f, ": ")?; | ||
419 | f.write_joined(&data.bounds, " + ")?; | ||
420 | } | ||
421 | if let Some(ty) = &data.type_ref { | ||
422 | write!(f, " = ")?; | ||
423 | ty.hir_fmt(f)?; | ||
424 | } | ||
425 | Ok(()) | ||
426 | } | ||
427 | } | ||
428 | |||
429 | impl HirDisplay for Module { | ||
430 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
431 | // FIXME: Module doesn't have visibility saved in data. | ||
432 | match self.name(f.db) { | ||
433 | Some(name) => write!(f, "mod {}", name), | ||
434 | None if self.crate_root(f.db) == *self => match self.krate().display_name(f.db) { | ||
435 | Some(name) => write!(f, "extern crate {}", name), | ||
436 | None => write!(f, "extern crate {{unknown}}"), | ||
437 | }, | ||
438 | None => write!(f, "mod {{unnamed}}"), | ||
439 | } | ||
440 | } | ||
441 | } | ||
diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs index 079a5f7b8..ad79a79f8 100644 --- a/crates/hir/src/lib.rs +++ b/crates/hir/src/lib.rs | |||
@@ -29,6 +29,8 @@ mod has_source; | |||
29 | pub mod diagnostics; | 29 | pub mod diagnostics; |
30 | pub mod db; | 30 | pub mod db; |
31 | 31 | ||
32 | mod display; | ||
33 | |||
32 | use std::{iter, sync::Arc}; | 34 | use std::{iter, sync::Arc}; |
33 | 35 | ||
34 | use arrayvec::ArrayVec; | 36 | use arrayvec::ArrayVec; |
@@ -50,8 +52,8 @@ use hir_def::{ | |||
50 | use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind}; | 52 | use hir_expand::{diagnostics::DiagnosticSink, name::name, MacroDefKind}; |
51 | use hir_ty::{ | 53 | use hir_ty::{ |
52 | autoderef, | 54 | autoderef, |
53 | display::{write_bounds_like_dyn_trait_with_prefix, HirDisplayError, HirFormatter}, | ||
54 | method_resolution::{self, TyFingerprint}, | 55 | method_resolution::{self, TyFingerprint}, |
56 | primitive::UintTy, | ||
55 | to_assoc_type_id, | 57 | to_assoc_type_id, |
56 | traits::{FnTrait, Solution, SolutionVariables}, | 58 | traits::{FnTrait, Solution, SolutionVariables}, |
57 | AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate, | 59 | AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, DebruijnIndex, GenericPredicate, |
@@ -579,6 +581,12 @@ impl Struct { | |||
579 | } | 581 | } |
580 | } | 582 | } |
581 | 583 | ||
584 | impl HasVisibility for Struct { | ||
585 | fn visibility(&self, db: &dyn HirDatabase) -> Visibility { | ||
586 | db.struct_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast())) | ||
587 | } | ||
588 | } | ||
589 | |||
582 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 590 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
583 | pub struct Union { | 591 | pub struct Union { |
584 | pub(crate) id: UnionId, | 592 | pub(crate) id: UnionId, |
@@ -611,6 +619,12 @@ impl Union { | |||
611 | } | 619 | } |
612 | } | 620 | } |
613 | 621 | ||
622 | impl HasVisibility for Union { | ||
623 | fn visibility(&self, db: &dyn HirDatabase) -> Visibility { | ||
624 | db.union_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast())) | ||
625 | } | ||
626 | } | ||
627 | |||
614 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 628 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
615 | pub struct Enum { | 629 | pub struct Enum { |
616 | pub(crate) id: EnumId, | 630 | pub(crate) id: EnumId, |
@@ -638,6 +652,12 @@ impl Enum { | |||
638 | } | 652 | } |
639 | } | 653 | } |
640 | 654 | ||
655 | impl HasVisibility for Enum { | ||
656 | fn visibility(&self, db: &dyn HirDatabase) -> Visibility { | ||
657 | db.enum_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast())) | ||
658 | } | ||
659 | } | ||
660 | |||
641 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 661 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
642 | pub struct Variant { | 662 | pub struct Variant { |
643 | pub(crate) parent: Enum, | 663 | pub(crate) parent: Enum, |
@@ -829,7 +849,8 @@ impl Function { | |||
829 | db.function_data(self.id) | 849 | db.function_data(self.id) |
830 | .params | 850 | .params |
831 | .iter() | 851 | .iter() |
832 | .map(|type_ref| { | 852 | .enumerate() |
853 | .map(|(idx, type_ref)| { | ||
833 | let ty = Type { | 854 | let ty = Type { |
834 | krate, | 855 | krate, |
835 | ty: InEnvironment { | 856 | ty: InEnvironment { |
@@ -837,7 +858,7 @@ impl Function { | |||
837 | environment: environment.clone(), | 858 | environment: environment.clone(), |
838 | }, | 859 | }, |
839 | }; | 860 | }; |
840 | Param { ty } | 861 | Param { func: self, ty, idx } |
841 | }) | 862 | }) |
842 | .collect() | 863 | .collect() |
843 | } | 864 | } |
@@ -851,7 +872,7 @@ impl Function { | |||
851 | } | 872 | } |
852 | 873 | ||
853 | pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool { | 874 | pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool { |
854 | db.function_data(self.id).is_unsafe | 875 | db.function_data(self.id).qualifier.is_unsafe |
855 | } | 876 | } |
856 | 877 | ||
857 | pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) { | 878 | pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) { |
@@ -900,6 +921,9 @@ impl From<hir_ty::Mutability> for Access { | |||
900 | 921 | ||
901 | #[derive(Debug)] | 922 | #[derive(Debug)] |
902 | pub struct Param { | 923 | pub struct Param { |
924 | func: Function, | ||
925 | /// The index in parameter list, including self parameter. | ||
926 | idx: usize, | ||
903 | ty: Type, | 927 | ty: Type, |
904 | } | 928 | } |
905 | 929 | ||
@@ -907,6 +931,15 @@ impl Param { | |||
907 | pub fn ty(&self) -> &Type { | 931 | pub fn ty(&self) -> &Type { |
908 | &self.ty | 932 | &self.ty |
909 | } | 933 | } |
934 | |||
935 | pub fn pattern_source(&self, db: &dyn HirDatabase) -> Option<ast::Pat> { | ||
936 | let params = self.func.source(db)?.value.param_list()?; | ||
937 | if params.self_param().is_some() { | ||
938 | params.params().nth(self.idx.checked_sub(1)?)?.pat() | ||
939 | } else { | ||
940 | params.params().nth(self.idx)?.pat() | ||
941 | } | ||
942 | } | ||
910 | } | 943 | } |
911 | 944 | ||
912 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 945 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
@@ -929,6 +962,14 @@ impl SelfParam { | |||
929 | }) | 962 | }) |
930 | .unwrap_or(Access::Owned) | 963 | .unwrap_or(Access::Owned) |
931 | } | 964 | } |
965 | |||
966 | pub fn display(self, db: &dyn HirDatabase) -> &'static str { | ||
967 | match self.access(db) { | ||
968 | Access::Shared => "&self", | ||
969 | Access::Exclusive => "&mut self", | ||
970 | Access::Owned => "self", | ||
971 | } | ||
972 | } | ||
932 | } | 973 | } |
933 | 974 | ||
934 | impl HasVisibility for Function { | 975 | impl HasVisibility for Function { |
@@ -956,6 +997,10 @@ impl Const { | |||
956 | pub fn name(self, db: &dyn HirDatabase) -> Option<Name> { | 997 | pub fn name(self, db: &dyn HirDatabase) -> Option<Name> { |
957 | db.const_data(self.id).name.clone() | 998 | db.const_data(self.id).name.clone() |
958 | } | 999 | } |
1000 | |||
1001 | pub fn type_ref(self, db: &dyn HirDatabase) -> TypeRef { | ||
1002 | db.const_data(self.id).type_ref.clone() | ||
1003 | } | ||
959 | } | 1004 | } |
960 | 1005 | ||
961 | impl HasVisibility for Const { | 1006 | impl HasVisibility for Const { |
@@ -989,6 +1034,12 @@ impl Static { | |||
989 | } | 1034 | } |
990 | } | 1035 | } |
991 | 1036 | ||
1037 | impl HasVisibility for Static { | ||
1038 | fn visibility(&self, db: &dyn HirDatabase) -> Visibility { | ||
1039 | db.static_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast())) | ||
1040 | } | ||
1041 | } | ||
1042 | |||
992 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 1043 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
993 | pub struct Trait { | 1044 | pub struct Trait { |
994 | pub(crate) id: TraitId, | 1045 | pub(crate) id: TraitId, |
@@ -1008,7 +1059,13 @@ impl Trait { | |||
1008 | } | 1059 | } |
1009 | 1060 | ||
1010 | pub fn is_auto(self, db: &dyn HirDatabase) -> bool { | 1061 | pub fn is_auto(self, db: &dyn HirDatabase) -> bool { |
1011 | db.trait_data(self.id).auto | 1062 | db.trait_data(self.id).is_auto |
1063 | } | ||
1064 | } | ||
1065 | |||
1066 | impl HasVisibility for Trait { | ||
1067 | fn visibility(&self, db: &dyn HirDatabase) -> Visibility { | ||
1068 | db.trait_data(self.id).visibility.resolve(db.upcast(), &self.id.resolver(db.upcast())) | ||
1012 | } | 1069 | } |
1013 | } | 1070 | } |
1014 | 1071 | ||
@@ -1420,19 +1477,6 @@ impl TypeParam { | |||
1420 | } | 1477 | } |
1421 | } | 1478 | } |
1422 | 1479 | ||
1423 | impl HirDisplay for TypeParam { | ||
1424 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
1425 | write!(f, "{}", self.name(f.db))?; | ||
1426 | let bounds = f.db.generic_predicates_for_param(self.id); | ||
1427 | let substs = Substs::type_params(f.db, self.id.parent); | ||
1428 | let predicates = bounds.iter().cloned().map(|b| b.subst(&substs)).collect::<Vec<_>>(); | ||
1429 | if !(predicates.is_empty() || f.omit_verbose_types()) { | ||
1430 | write_bounds_like_dyn_trait_with_prefix(":", &predicates, f)?; | ||
1431 | } | ||
1432 | Ok(()) | ||
1433 | } | ||
1434 | } | ||
1435 | |||
1436 | #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] | 1480 | #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] |
1437 | pub struct LifetimeParam { | 1481 | pub struct LifetimeParam { |
1438 | pub(crate) id: LifetimeParamId, | 1482 | pub(crate) id: LifetimeParamId, |
@@ -1646,6 +1690,10 @@ impl Type { | |||
1646 | matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..)) | 1690 | matches!(self.ty.value.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..)) |
1647 | } | 1691 | } |
1648 | 1692 | ||
1693 | pub fn is_usize(&self) -> bool { | ||
1694 | matches!(self.ty.value.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize))) | ||
1695 | } | ||
1696 | |||
1649 | pub fn remove_ref(&self) -> Option<Type> { | 1697 | pub fn remove_ref(&self) -> Option<Type> { |
1650 | match &self.ty.value.interned(&Interner) { | 1698 | match &self.ty.value.interned(&Interner) { |
1651 | TyKind::Ref(.., ty) => Some(self.derived(ty.clone())), | 1699 | TyKind::Ref(.., ty) => Some(self.derived(ty.clone())), |
@@ -2069,12 +2117,6 @@ impl Type { | |||
2069 | } | 2117 | } |
2070 | } | 2118 | } |
2071 | 2119 | ||
2072 | impl HirDisplay for Type { | ||
2073 | fn hir_fmt(&self, f: &mut HirFormatter) -> Result<(), HirDisplayError> { | ||
2074 | self.ty.value.hir_fmt(f) | ||
2075 | } | ||
2076 | } | ||
2077 | |||
2078 | // FIXME: closures | 2120 | // FIXME: closures |
2079 | #[derive(Debug)] | 2121 | #[derive(Debug)] |
2080 | pub struct Callable { | 2122 | pub struct Callable { |
diff --git a/crates/hir/src/semantics.rs b/crates/hir/src/semantics.rs index 945638cc5..03c9371b5 100644 --- a/crates/hir/src/semantics.rs +++ b/crates/hir/src/semantics.rs | |||
@@ -143,6 +143,12 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { | |||
143 | self.imp.diagnostics_display_range(diagnostics) | 143 | self.imp.diagnostics_display_range(diagnostics) |
144 | } | 144 | } |
145 | 145 | ||
146 | pub fn token_ancestors_with_macros( | ||
147 | &self, | ||
148 | token: SyntaxToken, | ||
149 | ) -> impl Iterator<Item = SyntaxNode> + '_ { | ||
150 | token.parent().into_iter().flat_map(move |it| self.ancestors_with_macros(it)) | ||
151 | } | ||
146 | pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ { | 152 | pub fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ { |
147 | self.imp.ancestors_with_macros(node) | 153 | self.imp.ancestors_with_macros(node) |
148 | } | 154 | } |
@@ -259,6 +265,10 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { | |||
259 | } | 265 | } |
260 | 266 | ||
261 | pub fn to_module_def(&self, file: FileId) -> Option<Module> { | 267 | pub fn to_module_def(&self, file: FileId) -> Option<Module> { |
268 | self.imp.to_module_def(file).next() | ||
269 | } | ||
270 | |||
271 | pub fn to_module_defs(&self, file: FileId) -> impl Iterator<Item = Module> { | ||
262 | self.imp.to_module_def(file) | 272 | self.imp.to_module_def(file) |
263 | } | 273 | } |
264 | 274 | ||
@@ -266,8 +276,8 @@ impl<'db, DB: HirDatabase> Semantics<'db, DB> { | |||
266 | self.imp.scope(node) | 276 | self.imp.scope(node) |
267 | } | 277 | } |
268 | 278 | ||
269 | pub fn scope_at_offset(&self, node: &SyntaxNode, offset: TextSize) -> SemanticsScope<'db> { | 279 | pub fn scope_at_offset(&self, token: &SyntaxToken, offset: TextSize) -> SemanticsScope<'db> { |
270 | self.imp.scope_at_offset(node, offset) | 280 | self.imp.scope_at_offset(&token.parent().unwrap(), offset) |
271 | } | 281 | } |
272 | 282 | ||
273 | pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> { | 283 | pub fn scope_for_def(&self, def: Trait) -> SemanticsScope<'db> { |
@@ -337,7 +347,10 @@ impl<'db> SemanticsImpl<'db> { | |||
337 | 347 | ||
338 | fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken { | 348 | fn descend_into_macros(&self, token: SyntaxToken) -> SyntaxToken { |
339 | let _p = profile::span("descend_into_macros"); | 349 | let _p = profile::span("descend_into_macros"); |
340 | let parent = token.parent(); | 350 | let parent = match token.parent() { |
351 | Some(it) => it, | ||
352 | None => return token, | ||
353 | }; | ||
341 | let sa = self.analyze(&parent); | 354 | let sa = self.analyze(&parent); |
342 | 355 | ||
343 | let token = successors(Some(InFile::new(sa.file_id, token)), |token| { | 356 | let token = successors(Some(InFile::new(sa.file_id, token)), |token| { |
@@ -356,7 +369,9 @@ impl<'db> SemanticsImpl<'db> { | |||
356 | .as_ref()? | 369 | .as_ref()? |
357 | .map_token_down(token.as_ref())?; | 370 | .map_token_down(token.as_ref())?; |
358 | 371 | ||
359 | self.cache(find_root(&token.value.parent()), token.file_id); | 372 | if let Some(parent) = token.value.parent() { |
373 | self.cache(find_root(&parent), token.file_id); | ||
374 | } | ||
360 | 375 | ||
361 | Some(token) | 376 | Some(token) |
362 | }) | 377 | }) |
@@ -374,7 +389,7 @@ impl<'db> SemanticsImpl<'db> { | |||
374 | // Handle macro token cases | 389 | // Handle macro token cases |
375 | node.token_at_offset(offset) | 390 | node.token_at_offset(offset) |
376 | .map(|token| self.descend_into_macros(token)) | 391 | .map(|token| self.descend_into_macros(token)) |
377 | .map(|it| self.ancestors_with_macros(it.parent())) | 392 | .map(|it| self.token_ancestors_with_macros(it)) |
378 | .flatten() | 393 | .flatten() |
379 | } | 394 | } |
380 | 395 | ||
@@ -390,6 +405,13 @@ impl<'db> SemanticsImpl<'db> { | |||
390 | src.with_value(&node).original_file_range(self.db.upcast()) | 405 | src.with_value(&node).original_file_range(self.db.upcast()) |
391 | } | 406 | } |
392 | 407 | ||
408 | fn token_ancestors_with_macros( | ||
409 | &self, | ||
410 | token: SyntaxToken, | ||
411 | ) -> impl Iterator<Item = SyntaxNode> + '_ { | ||
412 | token.parent().into_iter().flat_map(move |parent| self.ancestors_with_macros(parent)) | ||
413 | } | ||
414 | |||
393 | fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ { | 415 | fn ancestors_with_macros(&self, node: SyntaxNode) -> impl Iterator<Item = SyntaxNode> + '_ { |
394 | let node = self.find_file(node); | 416 | let node = self.find_file(node); |
395 | node.ancestors_with_macros(self.db.upcast()).map(|it| it.value) | 417 | node.ancestors_with_macros(self.db.upcast()).map(|it| it.value) |
@@ -401,7 +423,7 @@ impl<'db> SemanticsImpl<'db> { | |||
401 | offset: TextSize, | 423 | offset: TextSize, |
402 | ) -> impl Iterator<Item = SyntaxNode> + '_ { | 424 | ) -> impl Iterator<Item = SyntaxNode> + '_ { |
403 | node.token_at_offset(offset) | 425 | node.token_at_offset(offset) |
404 | .map(|token| self.ancestors_with_macros(token.parent())) | 426 | .map(|token| self.token_ancestors_with_macros(token)) |
405 | .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len()) | 427 | .kmerge_by(|node1, node2| node1.text_range().len() < node2.text_range().len()) |
406 | } | 428 | } |
407 | 429 | ||
@@ -537,8 +559,8 @@ impl<'db> SemanticsImpl<'db> { | |||
537 | f(&mut ctx) | 559 | f(&mut ctx) |
538 | } | 560 | } |
539 | 561 | ||
540 | fn to_module_def(&self, file: FileId) -> Option<Module> { | 562 | fn to_module_def(&self, file: FileId) -> impl Iterator<Item = Module> { |
541 | self.with_ctx(|ctx| ctx.file_to_def(file)).map(Module::from) | 563 | self.with_ctx(|ctx| ctx.file_to_def(file)).into_iter().map(Module::from) |
542 | } | 564 | } |
543 | 565 | ||
544 | fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> { | 566 | fn scope(&self, node: &SyntaxNode) -> SemanticsScope<'db> { |
diff --git a/crates/hir/src/semantics/source_to_def.rs b/crates/hir/src/semantics/source_to_def.rs index 6c612ee86..e9d820140 100644 --- a/crates/hir/src/semantics/source_to_def.rs +++ b/crates/hir/src/semantics/source_to_def.rs | |||
@@ -12,6 +12,7 @@ use hir_def::{ | |||
12 | }; | 12 | }; |
13 | use hir_expand::{name::AsName, AstId, MacroDefKind}; | 13 | use hir_expand::{name::AsName, AstId, MacroDefKind}; |
14 | use rustc_hash::FxHashMap; | 14 | use rustc_hash::FxHashMap; |
15 | use smallvec::SmallVec; | ||
15 | use stdx::impl_from; | 16 | use stdx::impl_from; |
16 | use syntax::{ | 17 | use syntax::{ |
17 | ast::{self, NameOwner}, | 18 | ast::{self, NameOwner}, |
@@ -28,14 +29,19 @@ pub(super) struct SourceToDefCtx<'a, 'b> { | |||
28 | } | 29 | } |
29 | 30 | ||
30 | impl SourceToDefCtx<'_, '_> { | 31 | impl SourceToDefCtx<'_, '_> { |
31 | pub(super) fn file_to_def(&mut self, file: FileId) -> Option<ModuleId> { | 32 | pub(super) fn file_to_def(&mut self, file: FileId) -> SmallVec<[ModuleId; 1]> { |
32 | let _p = profile::span("SourceBinder::to_module_def"); | 33 | let _p = profile::span("SourceBinder::to_module_def"); |
33 | self.db.relevant_crates(file).iter().find_map(|&crate_id| { | 34 | let mut mods = SmallVec::new(); |
35 | for &crate_id in self.db.relevant_crates(file).iter() { | ||
34 | // FIXME: inner items | 36 | // FIXME: inner items |
35 | let crate_def_map = self.db.crate_def_map(crate_id); | 37 | let crate_def_map = self.db.crate_def_map(crate_id); |
36 | let local_id = crate_def_map.modules_for_file(file).next()?; | 38 | mods.extend( |
37 | Some(crate_def_map.module_id(local_id)) | 39 | crate_def_map |
38 | }) | 40 | .modules_for_file(file) |
41 | .map(|local_id| crate_def_map.module_id(local_id)), | ||
42 | ) | ||
43 | } | ||
44 | mods | ||
39 | } | 45 | } |
40 | 46 | ||
41 | pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> { | 47 | pub(super) fn module_to_def(&mut self, src: InFile<ast::Module>) -> Option<ModuleId> { |
@@ -55,7 +61,7 @@ impl SourceToDefCtx<'_, '_> { | |||
55 | Some(parent_declaration) => self.module_to_def(parent_declaration), | 61 | Some(parent_declaration) => self.module_to_def(parent_declaration), |
56 | None => { | 62 | None => { |
57 | let file_id = src.file_id.original_file(self.db.upcast()); | 63 | let file_id = src.file_id.original_file(self.db.upcast()); |
58 | self.file_to_def(file_id) | 64 | self.file_to_def(file_id).get(0).copied() |
59 | } | 65 | } |
60 | }?; | 66 | }?; |
61 | 67 | ||
@@ -185,7 +191,7 @@ impl SourceToDefCtx<'_, '_> { | |||
185 | ) -> Option<MacroDefId> { | 191 | ) -> Option<MacroDefId> { |
186 | let kind = MacroDefKind::Declarative; | 192 | let kind = MacroDefKind::Declarative; |
187 | let file_id = src.file_id.original_file(self.db.upcast()); | 193 | let file_id = src.file_id.original_file(self.db.upcast()); |
188 | let krate = self.file_to_def(file_id)?.krate(); | 194 | let krate = self.file_to_def(file_id).get(0).copied()?.krate(); |
189 | let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value); | 195 | let file_ast_id = self.db.ast_id_map(src.file_id).ast_id(&src.value); |
190 | let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast())); | 196 | let ast_id = Some(AstId::new(src.file_id, file_ast_id.upcast())); |
191 | Some(MacroDefId { krate, ast_id, kind, local_inner: false }) | 197 | Some(MacroDefId { krate, ast_id, kind, local_inner: false }) |
@@ -245,7 +251,7 @@ impl SourceToDefCtx<'_, '_> { | |||
245 | return Some(res); | 251 | return Some(res); |
246 | } | 252 | } |
247 | 253 | ||
248 | let def = self.file_to_def(src.file_id.original_file(self.db.upcast()))?; | 254 | let def = self.file_to_def(src.file_id.original_file(self.db.upcast())).get(0).copied()?; |
249 | Some(def.into()) | 255 | Some(def.into()) |
250 | } | 256 | } |
251 | 257 | ||