aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_hir/src/ty/infer.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_hir/src/ty/infer.rs')
-rw-r--r--crates/ra_hir/src/ty/infer.rs1079
1 files changed, 1079 insertions, 0 deletions
diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
new file mode 100644
index 000000000..6ee9080d3
--- /dev/null
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -0,0 +1,1079 @@
1//! Type inference, i.e. the process of walking through the code and determining
2//! the type of each expression and pattern.
3//!
4//! For type inference, compare the implementations in rustc (the various
5//! check_* methods in librustc_typeck/check/mod.rs are a good entry point) and
6//! IntelliJ-Rust (org.rust.lang.core.types.infer). Our entry point for
7//! inference here is the `infer` function, which infers the types of all
8//! expressions in a given function.
9//!
10//! During inference, types (i.e. the `Ty` struct) can contain type 'variables'
11//! which represent currently unknown types; as we walk through the expressions,
12//! we might determine that certain variables need to be equal to each other, or
13//! to certain types. To record this, we use the union-find implementation from
14//! the `ena` crate, which is extracted from rustc.
15
16use std::borrow::Cow;
17use std::iter::repeat;
18use std::ops::Index;
19use std::sync::Arc;
20use std::mem;
21
22use ena::unify::{InPlaceUnificationTable, UnifyKey, UnifyValue, NoError};
23use ra_arena::map::ArenaMap;
24use rustc_hash::FxHashMap;
25
26use test_utils::tested_by;
27
28use crate::{
29 Function, StructField, Path, Name,
30 FnSignature, AdtDef,
31 HirDatabase,
32 type_ref::{TypeRef, Mutability},
33 expr::{Body, Expr, BindingAnnotation, Literal, ExprId, Pat, PatId, UnaryOp, BinaryOp, Statement, FieldPat, self},
34 generics::GenericParams,
35 path::{GenericArgs, GenericArg},
36 adt::VariantDef,
37 resolve::{Resolver, Resolution},
38 nameres::Namespace
39};
40use super::{Ty, TypableDef, Substs, primitive, op};
41
42/// The entry point of type inference.
43pub fn infer(db: &impl HirDatabase, func: Function) -> Arc<InferenceResult> {
44 db.check_canceled();
45 let body = func.body(db);
46 let resolver = func.resolver(db);
47 let mut ctx = InferenceContext::new(db, body, resolver);
48
49 let signature = func.signature(db);
50 ctx.collect_fn_signature(&signature);
51
52 ctx.infer_body();
53
54 Arc::new(ctx.resolve_all())
55}
56
57/// The result of type inference: A mapping from expressions and patterns to types.
58#[derive(Clone, PartialEq, Eq, Debug)]
59pub struct InferenceResult {
60 /// For each method call expr, records the function it resolves to.
61 method_resolutions: FxHashMap<ExprId, Function>,
62 /// For each field access expr, records the field it resolves to.
63 field_resolutions: FxHashMap<ExprId, StructField>,
64 pub(super) type_of_expr: ArenaMap<ExprId, Ty>,
65 pub(super) type_of_pat: ArenaMap<PatId, Ty>,
66}
67
68impl InferenceResult {
69 pub fn method_resolution(&self, expr: ExprId) -> Option<Function> {
70 self.method_resolutions.get(&expr).map(|it| *it)
71 }
72 pub fn field_resolution(&self, expr: ExprId) -> Option<StructField> {
73 self.field_resolutions.get(&expr).map(|it| *it)
74 }
75}
76
77impl Index<ExprId> for InferenceResult {
78 type Output = Ty;
79
80 fn index(&self, expr: ExprId) -> &Ty {
81 self.type_of_expr.get(expr).unwrap_or(&Ty::Unknown)
82 }
83}
84
85impl Index<PatId> for InferenceResult {
86 type Output = Ty;
87
88 fn index(&self, pat: PatId) -> &Ty {
89 self.type_of_pat.get(pat).unwrap_or(&Ty::Unknown)
90 }
91}
92
93/// The inference context contains all information needed during type inference.
94#[derive(Clone, Debug)]
95struct InferenceContext<'a, D: HirDatabase> {
96 db: &'a D,
97 body: Arc<Body>,
98 resolver: Resolver,
99 var_unification_table: InPlaceUnificationTable<TypeVarId>,
100 method_resolutions: FxHashMap<ExprId, Function>,
101 field_resolutions: FxHashMap<ExprId, StructField>,
102 type_of_expr: ArenaMap<ExprId, Ty>,
103 type_of_pat: ArenaMap<PatId, Ty>,
104 /// The return type of the function being inferred.
105 return_ty: Ty,
106}
107
108impl<'a, D: HirDatabase> InferenceContext<'a, D> {
109 fn new(db: &'a D, body: Arc<Body>, resolver: Resolver) -> Self {
110 InferenceContext {
111 method_resolutions: FxHashMap::default(),
112 field_resolutions: FxHashMap::default(),
113 type_of_expr: ArenaMap::default(),
114 type_of_pat: ArenaMap::default(),
115 var_unification_table: InPlaceUnificationTable::new(),
116 return_ty: Ty::Unknown, // set in collect_fn_signature
117 db,
118 body,
119 resolver,
120 }
121 }
122
123 fn resolve_all(mut self) -> InferenceResult {
124 let mut tv_stack = Vec::new();
125 let mut expr_types = mem::replace(&mut self.type_of_expr, ArenaMap::default());
126 for ty in expr_types.values_mut() {
127 let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
128 *ty = resolved;
129 }
130 let mut pat_types = mem::replace(&mut self.type_of_pat, ArenaMap::default());
131 for ty in pat_types.values_mut() {
132 let resolved = self.resolve_ty_completely(&mut tv_stack, mem::replace(ty, Ty::Unknown));
133 *ty = resolved;
134 }
135 InferenceResult {
136 method_resolutions: self.method_resolutions,
137 field_resolutions: self.field_resolutions,
138 type_of_expr: expr_types,
139 type_of_pat: pat_types,
140 }
141 }
142
143 fn write_expr_ty(&mut self, expr: ExprId, ty: Ty) {
144 self.type_of_expr.insert(expr, ty);
145 }
146
147 fn write_method_resolution(&mut self, expr: ExprId, func: Function) {
148 self.method_resolutions.insert(expr, func);
149 }
150
151 fn write_field_resolution(&mut self, expr: ExprId, field: StructField) {
152 self.field_resolutions.insert(expr, field);
153 }
154
155 fn write_pat_ty(&mut self, pat: PatId, ty: Ty) {
156 self.type_of_pat.insert(pat, ty);
157 }
158
159 fn make_ty(&mut self, type_ref: &TypeRef) -> Ty {
160 let ty = Ty::from_hir(
161 self.db,
162 // TODO use right resolver for block
163 &self.resolver,
164 type_ref,
165 );
166 let ty = self.insert_type_vars(ty);
167 ty
168 }
169
170 fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool {
171 substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
172 }
173
174 fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
175 self.unify_inner(ty1, ty2, 0)
176 }
177
178 fn unify_inner(&mut self, ty1: &Ty, ty2: &Ty, depth: usize) -> bool {
179 if depth > 1000 {
180 // prevent stackoverflows
181 panic!("infinite recursion in unification");
182 }
183 if ty1 == ty2 {
184 return true;
185 }
186 // try to resolve type vars first
187 let ty1 = self.resolve_ty_shallow(ty1);
188 let ty2 = self.resolve_ty_shallow(ty2);
189 match (&*ty1, &*ty2) {
190 (Ty::Unknown, ..) => true,
191 (.., Ty::Unknown) => true,
192 (Ty::Int(t1), Ty::Int(t2)) => match (t1, t2) {
193 (primitive::UncertainIntTy::Unknown, _)
194 | (_, primitive::UncertainIntTy::Unknown) => true,
195 _ => t1 == t2,
196 },
197 (Ty::Float(t1), Ty::Float(t2)) => match (t1, t2) {
198 (primitive::UncertainFloatTy::Unknown, _)
199 | (_, primitive::UncertainFloatTy::Unknown) => true,
200 _ => t1 == t2,
201 },
202 (Ty::Bool, _) | (Ty::Str, _) | (Ty::Never, _) | (Ty::Char, _) => ty1 == ty2,
203 (
204 Ty::Adt { def_id: def_id1, substs: substs1, .. },
205 Ty::Adt { def_id: def_id2, substs: substs2, .. },
206 ) if def_id1 == def_id2 => self.unify_substs(substs1, substs2, depth + 1),
207 (Ty::Slice(t1), Ty::Slice(t2)) => self.unify_inner(t1, t2, depth + 1),
208 (Ty::RawPtr(t1, m1), Ty::RawPtr(t2, m2)) if m1 == m2 => {
209 self.unify_inner(t1, t2, depth + 1)
210 }
211 (Ty::Ref(t1, m1), Ty::Ref(t2, m2)) if m1 == m2 => self.unify_inner(t1, t2, depth + 1),
212 (Ty::FnPtr(sig1), Ty::FnPtr(sig2)) if sig1 == sig2 => true,
213 (Ty::Tuple(ts1), Ty::Tuple(ts2)) if ts1.len() == ts2.len() => {
214 ts1.iter().zip(ts2.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth + 1))
215 }
216 (Ty::Infer(InferTy::TypeVar(tv1)), Ty::Infer(InferTy::TypeVar(tv2)))
217 | (Ty::Infer(InferTy::IntVar(tv1)), Ty::Infer(InferTy::IntVar(tv2)))
218 | (Ty::Infer(InferTy::FloatVar(tv1)), Ty::Infer(InferTy::FloatVar(tv2))) => {
219 // both type vars are unknown since we tried to resolve them
220 self.var_unification_table.union(*tv1, *tv2);
221 true
222 }
223 (Ty::Infer(InferTy::TypeVar(tv)), other)
224 | (other, Ty::Infer(InferTy::TypeVar(tv)))
225 | (Ty::Infer(InferTy::IntVar(tv)), other)
226 | (other, Ty::Infer(InferTy::IntVar(tv)))
227 | (Ty::Infer(InferTy::FloatVar(tv)), other)
228 | (other, Ty::Infer(InferTy::FloatVar(tv))) => {
229 // the type var is unknown since we tried to resolve it
230 self.var_unification_table.union_value(*tv, TypeVarValue::Known(other.clone()));
231 true
232 }
233 _ => false,
234 }
235 }
236
237 fn new_type_var(&mut self) -> Ty {
238 Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
239 }
240
241 fn new_integer_var(&mut self) -> Ty {
242 Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
243 }
244
245 fn new_float_var(&mut self) -> Ty {
246 Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
247 }
248
249 /// Replaces Ty::Unknown by a new type var, so we can maybe still infer it.
250 fn insert_type_vars_shallow(&mut self, ty: Ty) -> Ty {
251 match ty {
252 Ty::Unknown => self.new_type_var(),
253 Ty::Int(primitive::UncertainIntTy::Unknown) => self.new_integer_var(),
254 Ty::Float(primitive::UncertainFloatTy::Unknown) => self.new_float_var(),
255 _ => ty,
256 }
257 }
258
259 fn insert_type_vars(&mut self, ty: Ty) -> Ty {
260 ty.fold(&mut |ty| self.insert_type_vars_shallow(ty))
261 }
262
263 /// Resolves the type as far as currently possible, replacing type variables
264 /// by their known types. All types returned by the infer_* functions should
265 /// be resolved as far as possible, i.e. contain no type variables with
266 /// known type.
267 fn resolve_ty_as_possible(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
268 ty.fold(&mut |ty| match ty {
269 Ty::Infer(tv) => {
270 let inner = tv.to_inner();
271 if tv_stack.contains(&inner) {
272 tested_by!(type_var_cycles_resolve_as_possible);
273 // recursive type
274 return tv.fallback_value();
275 }
276 if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
277 // known_ty may contain other variables that are known by now
278 tv_stack.push(inner);
279 let result = self.resolve_ty_as_possible(tv_stack, known_ty.clone());
280 tv_stack.pop();
281 result
282 } else {
283 ty
284 }
285 }
286 _ => ty,
287 })
288 }
289
290 /// If `ty` is a type variable with known type, returns that type;
291 /// otherwise, return ty.
292 fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
293 let mut ty = Cow::Borrowed(ty);
294 // The type variable could resolve to a int/float variable. Hence try
295 // resolving up to three times; each type of variable shouldn't occur
296 // more than once
297 for i in 0..3 {
298 if i > 0 {
299 tested_by!(type_var_resolves_to_int_var);
300 }
301 match &*ty {
302 Ty::Infer(tv) => {
303 let inner = tv.to_inner();
304 match self.var_unification_table.probe_value(inner).known() {
305 Some(known_ty) => {
306 // The known_ty can't be a type var itself
307 ty = Cow::Owned(known_ty.clone());
308 }
309 _ => return ty,
310 }
311 }
312 _ => return ty,
313 }
314 }
315 log::error!("Inference variable still not resolved: {:?}", ty);
316 ty
317 }
318
319 /// Resolves the type completely; type variables without known type are
320 /// replaced by Ty::Unknown.
321 fn resolve_ty_completely(&mut self, tv_stack: &mut Vec<TypeVarId>, ty: Ty) -> Ty {
322 ty.fold(&mut |ty| match ty {
323 Ty::Infer(tv) => {
324 let inner = tv.to_inner();
325 if tv_stack.contains(&inner) {
326 tested_by!(type_var_cycles_resolve_completely);
327 // recursive type
328 return tv.fallback_value();
329 }
330 if let Some(known_ty) = self.var_unification_table.probe_value(inner).known() {
331 // known_ty may contain other variables that are known by now
332 tv_stack.push(inner);
333 let result = self.resolve_ty_completely(tv_stack, known_ty.clone());
334 tv_stack.pop();
335 result
336 } else {
337 tv.fallback_value()
338 }
339 }
340 _ => ty,
341 })
342 }
343
344 fn infer_path_expr(&mut self, resolver: &Resolver, path: &Path) -> Option<Ty> {
345 let resolved = resolver.resolve_path_segments(self.db, &path);
346
347 let (def, remaining_index) = resolved.into_inner();
348
349 log::debug!(
350 "path {:?} resolved to {:?} with remaining index {:?}",
351 path,
352 def,
353 remaining_index
354 );
355
356 // if the remaining_index is None, we expect the path
357 // to be fully resolved, in this case we continue with
358 // the default by attempting to `take_values´ from the resolution.
359 // Otherwise the path was partially resolved, which means
360 // we might have resolved into a type for which
361 // we may find some associated item starting at the
362 // path.segment pointed to by `remaining_index´
363 let resolved =
364 if remaining_index.is_none() { def.take_values()? } else { def.take_types()? };
365
366 match resolved {
367 Resolution::Def(def) => {
368 let typable: Option<TypableDef> = def.into();
369 let typable = typable?;
370
371 if let Some(remaining_index) = remaining_index {
372 let ty = self.db.type_for_def(typable, Namespace::Types);
373 // TODO: Keep resolving the segments
374 // if we have more segments to process
375 let segment = &path.segments[remaining_index];
376
377 log::debug!("looking for path segment: {:?}", segment);
378
379 // Attempt to find an impl_item for the type which has a name matching
380 // the current segment
381 let ty = ty.iterate_impl_items(self.db, |item| match item {
382 crate::ImplItem::Method(func) => {
383 let sig = func.signature(self.db);
384 if segment.name == *sig.name() {
385 return Some(func.ty(self.db));
386 }
387 None
388 }
389
390 // TODO: Resolve associated const
391 crate::ImplItem::Const(_) => None,
392
393 // TODO: Resolve associated types
394 crate::ImplItem::Type(_) => None,
395 });
396 ty
397 } else {
398 let substs = Ty::substs_from_path(self.db, &self.resolver, path, typable);
399 let ty = self.db.type_for_def(typable, Namespace::Values).apply_substs(substs);
400 let ty = self.insert_type_vars(ty);
401 Some(ty)
402 }
403 }
404 Resolution::LocalBinding(pat) => {
405 let ty = self.type_of_pat.get(pat)?;
406 let ty = self.resolve_ty_as_possible(&mut vec![], ty.clone());
407 Some(ty)
408 }
409 Resolution::GenericParam(..) => {
410 // generic params can't refer to values... yet
411 None
412 }
413 Resolution::SelfType(_) => {
414 log::error!("path expr {:?} resolved to Self type in values ns", path);
415 None
416 }
417 }
418 }
419
420 fn resolve_variant(&mut self, path: Option<&Path>) -> (Ty, Option<VariantDef>) {
421 let path = match path {
422 Some(path) => path,
423 None => return (Ty::Unknown, None),
424 };
425 let resolver = &self.resolver;
426 let typable: Option<TypableDef> = match resolver.resolve_path(self.db, &path).take_types() {
427 Some(Resolution::Def(def)) => def.into(),
428 Some(Resolution::LocalBinding(..)) => {
429 // this cannot happen
430 log::error!("path resolved to local binding in type ns");
431 return (Ty::Unknown, None);
432 }
433 Some(Resolution::GenericParam(..)) => {
434 // generic params can't be used in struct literals
435 return (Ty::Unknown, None);
436 }
437 Some(Resolution::SelfType(..)) => {
438 // TODO this is allowed in an impl for a struct, handle this
439 return (Ty::Unknown, None);
440 }
441 None => return (Ty::Unknown, None),
442 };
443 let def = match typable {
444 None => return (Ty::Unknown, None),
445 Some(it) => it,
446 };
447 // TODO remove the duplication between here and `Ty::from_path`?
448 let substs = Ty::substs_from_path(self.db, resolver, path, def);
449 match def {
450 TypableDef::Struct(s) => {
451 let ty = s.ty(self.db);
452 let ty = self.insert_type_vars(ty.apply_substs(substs));
453 (ty, Some(s.into()))
454 }
455 TypableDef::EnumVariant(var) => {
456 let ty = var.parent_enum(self.db).ty(self.db);
457 let ty = self.insert_type_vars(ty.apply_substs(substs));
458 (ty, Some(var.into()))
459 }
460 TypableDef::Function(_) | TypableDef::Enum(_) => (Ty::Unknown, None),
461 }
462 }
463
464 fn infer_tuple_struct_pat(
465 &mut self,
466 path: Option<&Path>,
467 subpats: &[PatId],
468 expected: &Ty,
469 ) -> Ty {
470 let (ty, def) = self.resolve_variant(path);
471
472 self.unify(&ty, expected);
473
474 let substs = ty.substs().unwrap_or_else(Substs::empty);
475
476 for (i, &subpat) in subpats.iter().enumerate() {
477 let expected_ty = def
478 .and_then(|d| d.field(self.db, &Name::tuple_field_name(i)))
479 .map_or(Ty::Unknown, |field| field.ty(self.db))
480 .subst(&substs);
481 self.infer_pat(subpat, &expected_ty);
482 }
483
484 ty
485 }
486
487 fn infer_struct_pat(&mut self, path: Option<&Path>, subpats: &[FieldPat], expected: &Ty) -> Ty {
488 let (ty, def) = self.resolve_variant(path);
489
490 self.unify(&ty, expected);
491
492 let substs = ty.substs().unwrap_or_else(Substs::empty);
493
494 for subpat in subpats {
495 let matching_field = def.and_then(|it| it.field(self.db, &subpat.name));
496 let expected_ty =
497 matching_field.map_or(Ty::Unknown, |field| field.ty(self.db)).subst(&substs);
498 self.infer_pat(subpat.pat, &expected_ty);
499 }
500
501 ty
502 }
503
504 fn infer_pat(&mut self, pat: PatId, expected: &Ty) -> Ty {
505 let body = Arc::clone(&self.body); // avoid borrow checker problem
506
507 let ty = match &body[pat] {
508 Pat::Tuple(ref args) => {
509 let expectations = match *expected {
510 Ty::Tuple(ref tuple_args) => &**tuple_args,
511 _ => &[],
512 };
513 let expectations_iter = expectations.iter().chain(repeat(&Ty::Unknown));
514
515 let inner_tys = args
516 .iter()
517 .zip(expectations_iter)
518 .map(|(&pat, ty)| self.infer_pat(pat, ty))
519 .collect::<Vec<_>>()
520 .into();
521
522 Ty::Tuple(inner_tys)
523 }
524 Pat::Ref { pat, mutability } => {
525 let expectation = match *expected {
526 Ty::Ref(ref sub_ty, exp_mut) => {
527 if *mutability != exp_mut {
528 // TODO: emit type error?
529 }
530 &**sub_ty
531 }
532 _ => &Ty::Unknown,
533 };
534 let subty = self.infer_pat(*pat, expectation);
535 Ty::Ref(subty.into(), *mutability)
536 }
537 Pat::TupleStruct { path: ref p, args: ref subpats } => {
538 self.infer_tuple_struct_pat(p.as_ref(), subpats, expected)
539 }
540 Pat::Struct { path: ref p, args: ref fields } => {
541 self.infer_struct_pat(p.as_ref(), fields, expected)
542 }
543 Pat::Path(path) => {
544 // TODO use correct resolver for the surrounding expression
545 let resolver = self.resolver.clone();
546 self.infer_path_expr(&resolver, &path).unwrap_or(Ty::Unknown)
547 }
548 Pat::Bind { mode, name: _name, subpat } => {
549 let inner_ty = if let Some(subpat) = subpat {
550 self.infer_pat(*subpat, expected)
551 } else {
552 expected.clone()
553 };
554 let inner_ty = self.insert_type_vars_shallow(inner_ty);
555
556 let bound_ty = match mode {
557 BindingAnnotation::Ref => Ty::Ref(inner_ty.clone().into(), Mutability::Shared),
558 BindingAnnotation::RefMut => Ty::Ref(inner_ty.clone().into(), Mutability::Mut),
559 BindingAnnotation::Mutable | BindingAnnotation::Unannotated => inner_ty.clone(),
560 };
561 let bound_ty = self.resolve_ty_as_possible(&mut vec![], bound_ty);
562 self.write_pat_ty(pat, bound_ty);
563 return inner_ty;
564 }
565 _ => Ty::Unknown,
566 };
567 // use a new type variable if we got Ty::Unknown here
568 let ty = self.insert_type_vars_shallow(ty);
569 self.unify(&ty, expected);
570 let ty = self.resolve_ty_as_possible(&mut vec![], ty);
571 self.write_pat_ty(pat, ty.clone());
572 ty
573 }
574
575 fn substs_for_method_call(
576 &mut self,
577 def_generics: Option<Arc<GenericParams>>,
578 generic_args: &Option<GenericArgs>,
579 ) -> Substs {
580 let (parent_param_count, param_count) =
581 def_generics.map_or((0, 0), |g| (g.count_parent_params(), g.params.len()));
582 let mut substs = Vec::with_capacity(parent_param_count + param_count);
583 for _ in 0..parent_param_count {
584 substs.push(Ty::Unknown);
585 }
586 // handle provided type arguments
587 if let Some(generic_args) = generic_args {
588 // if args are provided, it should be all of them, but we can't rely on that
589 for arg in generic_args.args.iter().take(param_count) {
590 match arg {
591 GenericArg::Type(type_ref) => {
592 let ty = self.make_ty(type_ref);
593 substs.push(ty);
594 }
595 }
596 }
597 };
598 let supplied_params = substs.len();
599 for _ in supplied_params..parent_param_count + param_count {
600 substs.push(Ty::Unknown);
601 }
602 assert_eq!(substs.len(), parent_param_count + param_count);
603 Substs(substs.into())
604 }
605
606 fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
607 let body = Arc::clone(&self.body); // avoid borrow checker problem
608 let ty = match &body[tgt_expr] {
609 Expr::Missing => Ty::Unknown,
610 Expr::If { condition, then_branch, else_branch } => {
611 // if let is desugared to match, so this is always simple if
612 self.infer_expr(*condition, &Expectation::has_type(Ty::Bool));
613 let then_ty = self.infer_expr(*then_branch, expected);
614 match else_branch {
615 Some(else_branch) => {
616 self.infer_expr(*else_branch, expected);
617 }
618 None => {
619 // no else branch -> unit
620 self.unify(&then_ty, &Ty::unit()); // actually coerce
621 }
622 };
623 then_ty
624 }
625 Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
626 Expr::Loop { body } => {
627 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
628 // TODO handle break with value
629 Ty::Never
630 }
631 Expr::While { condition, body } => {
632 // while let is desugared to a match loop, so this is always simple while
633 self.infer_expr(*condition, &Expectation::has_type(Ty::Bool));
634 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
635 Ty::unit()
636 }
637 Expr::For { iterable, body, pat } => {
638 let _iterable_ty = self.infer_expr(*iterable, &Expectation::none());
639 self.infer_pat(*pat, &Ty::Unknown);
640 self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
641 Ty::unit()
642 }
643 Expr::Lambda { body, args, arg_types } => {
644 assert_eq!(args.len(), arg_types.len());
645
646 for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) {
647 let expected = if let Some(type_ref) = arg_type {
648 let ty = self.make_ty(type_ref);
649 ty
650 } else {
651 Ty::Unknown
652 };
653 self.infer_pat(*arg_pat, &expected);
654 }
655
656 // TODO: infer lambda type etc.
657 let _body_ty = self.infer_expr(*body, &Expectation::none());
658 Ty::Unknown
659 }
660 Expr::Call { callee, args } => {
661 let callee_ty = self.infer_expr(*callee, &Expectation::none());
662 let (param_tys, ret_ty) = match &callee_ty {
663 Ty::FnPtr(sig) => (sig.input.clone(), sig.output.clone()),
664 Ty::FnDef { substs, sig, .. } => {
665 let ret_ty = sig.output.clone().subst(&substs);
666 let param_tys =
667 sig.input.iter().map(|ty| ty.clone().subst(&substs)).collect();
668 (param_tys, ret_ty)
669 }
670 _ => {
671 // not callable
672 // TODO report an error?
673 (Vec::new(), Ty::Unknown)
674 }
675 };
676 let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
677 for (arg, param) in args.iter().zip(param_iter) {
678 self.infer_expr(*arg, &Expectation::has_type(param));
679 }
680 ret_ty
681 }
682 Expr::MethodCall { receiver, args, method_name, generic_args } => {
683 let receiver_ty = self.infer_expr(*receiver, &Expectation::none());
684 let resolved = receiver_ty.clone().lookup_method(self.db, method_name);
685 let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
686 Some((ty, func)) => {
687 self.write_method_resolution(tgt_expr, func);
688 (
689 ty,
690 self.db.type_for_def(func.into(), Namespace::Values),
691 Some(func.generic_params(self.db)),
692 )
693 }
694 None => (Ty::Unknown, receiver_ty, None),
695 };
696 let substs = self.substs_for_method_call(def_generics, generic_args);
697 let method_ty = method_ty.apply_substs(substs);
698 let method_ty = self.insert_type_vars(method_ty);
699 let (expected_receiver_ty, param_tys, ret_ty) = match &method_ty {
700 Ty::FnPtr(sig) => {
701 if !sig.input.is_empty() {
702 (sig.input[0].clone(), sig.input[1..].to_vec(), sig.output.clone())
703 } else {
704 (Ty::Unknown, Vec::new(), sig.output.clone())
705 }
706 }
707 Ty::FnDef { substs, sig, .. } => {
708 let ret_ty = sig.output.clone().subst(&substs);
709
710 if !sig.input.is_empty() {
711 let mut arg_iter = sig.input.iter().map(|ty| ty.clone().subst(&substs));
712 let receiver_ty = arg_iter.next().unwrap();
713 (receiver_ty, arg_iter.collect(), ret_ty)
714 } else {
715 (Ty::Unknown, Vec::new(), ret_ty)
716 }
717 }
718 _ => (Ty::Unknown, Vec::new(), Ty::Unknown),
719 };
720 // Apply autoref so the below unification works correctly
721 let actual_receiver_ty = match expected_receiver_ty {
722 Ty::Ref(_, mutability) => Ty::Ref(Arc::new(derefed_receiver_ty), mutability),
723 _ => derefed_receiver_ty,
724 };
725 self.unify(&expected_receiver_ty, &actual_receiver_ty);
726
727 let param_iter = param_tys.into_iter().chain(repeat(Ty::Unknown));
728 for (arg, param) in args.iter().zip(param_iter) {
729 self.infer_expr(*arg, &Expectation::has_type(param));
730 }
731 ret_ty
732 }
733 Expr::Match { expr, arms } => {
734 let expected = if expected.ty == Ty::Unknown {
735 Expectation::has_type(self.new_type_var())
736 } else {
737 expected.clone()
738 };
739 let input_ty = self.infer_expr(*expr, &Expectation::none());
740
741 for arm in arms {
742 for &pat in &arm.pats {
743 let _pat_ty = self.infer_pat(pat, &input_ty);
744 }
745 if let Some(guard_expr) = arm.guard {
746 self.infer_expr(guard_expr, &Expectation::has_type(Ty::Bool));
747 }
748 self.infer_expr(arm.expr, &expected);
749 }
750
751 expected.ty
752 }
753 Expr::Path(p) => {
754 // TODO this could be more efficient...
755 let resolver = expr::resolver_for_expr(self.body.clone(), self.db, tgt_expr);
756 self.infer_path_expr(&resolver, p).unwrap_or(Ty::Unknown)
757 }
758 Expr::Continue => Ty::Never,
759 Expr::Break { expr } => {
760 if let Some(expr) = expr {
761 // TODO handle break with value
762 self.infer_expr(*expr, &Expectation::none());
763 }
764 Ty::Never
765 }
766 Expr::Return { expr } => {
767 if let Some(expr) = expr {
768 self.infer_expr(*expr, &Expectation::has_type(self.return_ty.clone()));
769 }
770 Ty::Never
771 }
772 Expr::StructLit { path, fields, spread } => {
773 let (ty, def_id) = self.resolve_variant(path.as_ref());
774 let substs = ty.substs().unwrap_or_else(Substs::empty);
775 for field in fields {
776 let field_ty = def_id
777 .and_then(|it| it.field(self.db, &field.name))
778 .map_or(Ty::Unknown, |field| field.ty(self.db))
779 .subst(&substs);
780 self.infer_expr(field.expr, &Expectation::has_type(field_ty));
781 }
782 if let Some(expr) = spread {
783 self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
784 }
785 ty
786 }
787 Expr::Field { expr, name } => {
788 let receiver_ty = self.infer_expr(*expr, &Expectation::none());
789 let ty = receiver_ty
790 .autoderef(self.db)
791 .find_map(|derefed_ty| match derefed_ty {
792 Ty::Tuple(fields) => {
793 let i = name.to_string().parse::<usize>().ok();
794 i.and_then(|i| fields.get(i).cloned())
795 }
796 Ty::Adt { def_id: AdtDef::Struct(s), ref substs, .. } => {
797 s.field(self.db, name).map(|field| {
798 self.write_field_resolution(tgt_expr, field);
799 field.ty(self.db).subst(substs)
800 })
801 }
802 _ => None,
803 })
804 .unwrap_or(Ty::Unknown);
805 self.insert_type_vars(ty)
806 }
807 Expr::Try { expr } => {
808 let _inner_ty = self.infer_expr(*expr, &Expectation::none());
809 Ty::Unknown
810 }
811 Expr::Cast { expr, type_ref } => {
812 let _inner_ty = self.infer_expr(*expr, &Expectation::none());
813 let cast_ty = self.make_ty(type_ref);
814 // TODO check the cast...
815 cast_ty
816 }
817 Expr::Ref { expr, mutability } => {
818 let expectation = if let Ty::Ref(ref subty, expected_mutability) = expected.ty {
819 if expected_mutability == Mutability::Mut && *mutability == Mutability::Shared {
820 // TODO: throw type error - expected mut reference but found shared ref,
821 // which cannot be coerced
822 }
823 Expectation::has_type((**subty).clone())
824 } else {
825 Expectation::none()
826 };
827 // TODO reference coercions etc.
828 let inner_ty = self.infer_expr(*expr, &expectation);
829 Ty::Ref(Arc::new(inner_ty), *mutability)
830 }
831 Expr::UnaryOp { expr, op } => {
832 let inner_ty = self.infer_expr(*expr, &Expectation::none());
833 match op {
834 UnaryOp::Deref => {
835 if let Some(derefed_ty) = inner_ty.builtin_deref() {
836 derefed_ty
837 } else {
838 // TODO Deref::deref
839 Ty::Unknown
840 }
841 }
842 UnaryOp::Neg => {
843 match inner_ty {
844 Ty::Int(primitive::UncertainIntTy::Unknown)
845 | Ty::Int(primitive::UncertainIntTy::Signed(..))
846 | Ty::Infer(InferTy::IntVar(..))
847 | Ty::Infer(InferTy::FloatVar(..))
848 | Ty::Float(..) => inner_ty,
849 // TODO: resolve ops::Neg trait
850 _ => Ty::Unknown,
851 }
852 }
853 UnaryOp::Not => {
854 match inner_ty {
855 Ty::Bool | Ty::Int(_) | Ty::Infer(InferTy::IntVar(..)) => inner_ty,
856 // TODO: resolve ops::Not trait for inner_ty
857 _ => Ty::Unknown,
858 }
859 }
860 }
861 }
862 Expr::BinaryOp { lhs, rhs, op } => match op {
863 Some(op) => {
864 let lhs_expectation = match op {
865 BinaryOp::BooleanAnd | BinaryOp::BooleanOr => {
866 Expectation::has_type(Ty::Bool)
867 }
868 _ => Expectation::none(),
869 };
870 let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
871 // TODO: find implementation of trait corresponding to operation
872 // symbol and resolve associated `Output` type
873 let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty);
874 let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
875
876 // TODO: similar as above, return ty is often associated trait type
877 op::binary_op_return_ty(*op, rhs_ty)
878 }
879 _ => Ty::Unknown,
880 },
881 Expr::Tuple { exprs } => {
882 let mut ty_vec = Vec::with_capacity(exprs.len());
883 for arg in exprs.iter() {
884 ty_vec.push(self.infer_expr(*arg, &Expectation::none()));
885 }
886
887 Ty::Tuple(Arc::from(ty_vec))
888 }
889 Expr::Array { exprs } => {
890 let elem_ty = match &expected.ty {
891 Ty::Slice(inner) | Ty::Array(inner) => Ty::clone(&inner),
892 _ => self.new_type_var(),
893 };
894
895 for expr in exprs.iter() {
896 self.infer_expr(*expr, &Expectation::has_type(elem_ty.clone()));
897 }
898
899 Ty::Array(Arc::new(elem_ty))
900 }
901 Expr::Literal(lit) => match lit {
902 Literal::Bool(..) => Ty::Bool,
903 Literal::String(..) => Ty::Ref(Arc::new(Ty::Str), Mutability::Shared),
904 Literal::ByteString(..) => {
905 let byte_type = Arc::new(Ty::Int(primitive::UncertainIntTy::Unsigned(
906 primitive::UintTy::U8,
907 )));
908 let slice_type = Arc::new(Ty::Slice(byte_type));
909 Ty::Ref(slice_type, Mutability::Shared)
910 }
911 Literal::Char(..) => Ty::Char,
912 Literal::Int(_v, ty) => Ty::Int(*ty),
913 Literal::Float(_v, ty) => Ty::Float(*ty),
914 },
915 };
916 // use a new type variable if we got Ty::Unknown here
917 let ty = self.insert_type_vars_shallow(ty);
918 self.unify(&ty, &expected.ty);
919 let ty = self.resolve_ty_as_possible(&mut vec![], ty);
920 self.write_expr_ty(tgt_expr, ty.clone());
921 ty
922 }
923
924 fn infer_block(
925 &mut self,
926 statements: &[Statement],
927 tail: Option<ExprId>,
928 expected: &Expectation,
929 ) -> Ty {
930 for stmt in statements {
931 match stmt {
932 Statement::Let { pat, type_ref, initializer } => {
933 let decl_ty =
934 type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
935 let decl_ty = self.insert_type_vars(decl_ty);
936 let ty = if let Some(expr) = initializer {
937 let expr_ty = self.infer_expr(*expr, &Expectation::has_type(decl_ty));
938 expr_ty
939 } else {
940 decl_ty
941 };
942
943 self.infer_pat(*pat, &ty);
944 }
945 Statement::Expr(expr) => {
946 self.infer_expr(*expr, &Expectation::none());
947 }
948 }
949 }
950 let ty = if let Some(expr) = tail { self.infer_expr(expr, expected) } else { Ty::unit() };
951 ty
952 }
953
954 fn collect_fn_signature(&mut self, signature: &FnSignature) {
955 let body = Arc::clone(&self.body); // avoid borrow checker problem
956 for (type_ref, pat) in signature.params().iter().zip(body.params()) {
957 let ty = self.make_ty(type_ref);
958
959 self.infer_pat(*pat, &ty);
960 }
961 self.return_ty = self.make_ty(signature.ret_type());
962 }
963
964 fn infer_body(&mut self) {
965 self.infer_expr(self.body.body_expr(), &Expectation::has_type(self.return_ty.clone()));
966 }
967}
968
969/// The ID of a type variable.
970#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
971pub struct TypeVarId(u32);
972
973impl UnifyKey for TypeVarId {
974 type Value = TypeVarValue;
975
976 fn index(&self) -> u32 {
977 self.0
978 }
979
980 fn from_index(i: u32) -> Self {
981 TypeVarId(i)
982 }
983
984 fn tag() -> &'static str {
985 "TypeVarId"
986 }
987}
988
989/// The value of a type variable: either we already know the type, or we don't
990/// know it yet.
991#[derive(Clone, PartialEq, Eq, Debug)]
992pub enum TypeVarValue {
993 Known(Ty),
994 Unknown,
995}
996
997impl TypeVarValue {
998 fn known(&self) -> Option<&Ty> {
999 match self {
1000 TypeVarValue::Known(ty) => Some(ty),
1001 TypeVarValue::Unknown => None,
1002 }
1003 }
1004}
1005
1006impl UnifyValue for TypeVarValue {
1007 type Error = NoError;
1008
1009 fn unify_values(value1: &Self, value2: &Self) -> Result<Self, NoError> {
1010 match (value1, value2) {
1011 // We should never equate two type variables, both of which have
1012 // known types. Instead, we recursively equate those types.
1013 (TypeVarValue::Known(t1), TypeVarValue::Known(t2)) => panic!(
1014 "equating two type variables, both of which have known types: {:?} and {:?}",
1015 t1, t2
1016 ),
1017
1018 // If one side is known, prefer that one.
1019 (TypeVarValue::Known(..), TypeVarValue::Unknown) => Ok(value1.clone()),
1020 (TypeVarValue::Unknown, TypeVarValue::Known(..)) => Ok(value2.clone()),
1021
1022 (TypeVarValue::Unknown, TypeVarValue::Unknown) => Ok(TypeVarValue::Unknown),
1023 }
1024 }
1025}
1026
1027/// The kinds of placeholders we need during type inference. There's separate
1028/// values for general types, and for integer and float variables. The latter
1029/// two are used for inference of literal values (e.g. `100` could be one of
1030/// several integer types).
1031#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1032pub enum InferTy {
1033 TypeVar(TypeVarId),
1034 IntVar(TypeVarId),
1035 FloatVar(TypeVarId),
1036}
1037
1038impl InferTy {
1039 fn to_inner(self) -> TypeVarId {
1040 match self {
1041 InferTy::TypeVar(ty) | InferTy::IntVar(ty) | InferTy::FloatVar(ty) => ty,
1042 }
1043 }
1044
1045 fn fallback_value(self) -> Ty {
1046 match self {
1047 InferTy::TypeVar(..) => Ty::Unknown,
1048 InferTy::IntVar(..) => {
1049 Ty::Int(primitive::UncertainIntTy::Signed(primitive::IntTy::I32))
1050 }
1051 InferTy::FloatVar(..) => {
1052 Ty::Float(primitive::UncertainFloatTy::Known(primitive::FloatTy::F64))
1053 }
1054 }
1055 }
1056}
1057
1058/// When inferring an expression, we propagate downward whatever type hint we
1059/// are able in the form of an `Expectation`.
1060#[derive(Clone, PartialEq, Eq, Debug)]
1061struct Expectation {
1062 ty: Ty,
1063 // TODO: In some cases, we need to be aware whether the expectation is that
1064 // the type match exactly what we passed, or whether it just needs to be
1065 // coercible to the expected type. See Expectation::rvalue_hint in rustc.
1066}
1067
1068impl Expectation {
1069 /// The expectation that the type of the expression needs to equal the given
1070 /// type.
1071 fn has_type(ty: Ty) -> Self {
1072 Expectation { ty }
1073 }
1074
1075 /// This expresses no expectation on the type.
1076 fn none() -> Self {
1077 Expectation { ty: Ty::Unknown }
1078 }
1079}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-02 18:08:07 +0000