Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2025-01-09 19:58:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
rust-analyzer/crates/ra_hir_ty/src/infer/expr.rs

690 lines
31 KiB
Rust
Raw Normal View History

Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
//! Type inference for expressions.
use std::iter::{repeat, repeat_with};
use std::sync::Arc;
Reduce duplication between uncertain floats & ints
2019-11-13 06:56:33 +00:00
use hir_def::{
builtin_type::Signedness,
Cleanup imports
2019-11-27 09:13:07 +00:00
expr::{Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp},
Reduce duplication between uncertain floats & ints
2019-11-13 06:56:33 +00:00
path::{GenericArg, GenericArgs},
Move resolver to hir_def
2019-11-21 12:39:09 +00:00
resolver::resolver_for_expr,
Id-ify Ty::Adt
2019-11-26 11:29:12 +00:00
AdtId, ContainerId, Lookup, StructFieldId,
Reduce duplication between uncertain floats & ints
2019-11-13 06:56:33 +00:00
};
Add macros for known names and paths
2019-12-13 20:43:53 +00:00
use hir_expand::name::{Name, N};
Reduce variants of Expr
2019-11-29 06:49:12 +00:00
use ra_syntax::ast::RangeOp;
remove forward pointer for name
2019-10-30 14:19:30 +00:00
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
use crate::{
Remove idx and parent generics from generics This makes `hir_def::GenericParams` flatter. The logic for re-numbering the params is moved to hir instead.
2019-12-07 10:50:36 +00:00
autoderef,
db::HirDatabase,
method_resolution, op,
traits::InEnvironment,
utils::{generics, variant_data, Generics},
Add helper for resolving associated type of trait in infer
2019-12-13 11:44:07 +00:00
ApplicationTy, CallableDef, InferTy, IntTy, Mutability, Obligation, Substs, TraitRef, Ty,
TypeCtor, TypeWalk, Uncertain,
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
};
Move resolver to hir_def
2019-11-21 12:39:09 +00:00
use super::{BindingMode, Expectation, InferenceContext, InferenceDiagnostic, TypeMismatch};
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
impl<'a, D: HirDatabase> InferenceContext<'a, D> {
pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
let ty = self.infer_expr_inner(tgt_expr, expected);
let could_unify = self.unify(&ty, &expected.ty);
if !could_unify {
self.result.type_mismatches.insert(
tgt_expr,
TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
);
}
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
let ty = self.resolve_ty_as_possible(ty);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
ty
}
/// Infer type of expression with possibly implicit coerce to the expected type.
/// Return the type after possible coercion.
fn infer_expr_coerce(&mut self, expr: ExprId, expected: &Expectation) -> Ty {
let ty = self.infer_expr_inner(expr, &expected);
let ty = if !self.coerce(&ty, &expected.ty) {
self.result
.type_mismatches
.insert(expr, TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() });
// Return actual type when type mismatch.
// This is needed for diagnostic when return type mismatch.
ty
} else if expected.ty == Ty::Unknown {
ty
} else {
expected.ty.clone()
};
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
self.resolve_ty_as_possible(ty)
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
let body = Arc::clone(&self.body); // avoid borrow checker problem
let ty = match &body[tgt_expr] {
Expr::Missing => Ty::Unknown,
Expr::If { condition, then_branch, else_branch } => {
// if let is desugared to match, so this is always simple if
self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
let then_ty = self.infer_expr_inner(*then_branch, &expected);
let else_ty = match else_branch {
Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
None => Ty::unit(),
};
self.coerce_merge_branch(&then_ty, &else_ty)
}
Expr::Block { statements, tail } => self.infer_block(statements, *tail, expected),
Expr::TryBlock { body } => {
let _inner = self.infer_expr(*body, expected);
// FIXME should be std::result::Result<{inner}, _>
Ty::Unknown
}
Expr::Loop { body } => {
self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
// FIXME handle break with value
Ty::simple(TypeCtor::Never)
}
Expr::While { condition, body } => {
// while let is desugared to a match loop, so this is always simple while
self.infer_expr(*condition, &Expectation::has_type(Ty::simple(TypeCtor::Bool)));
self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
Ty::unit()
}
Expr::For { iterable, body, pat } => {
let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
Add helper for resolving associated type of trait in infer
2019-12-13 11:44:07 +00:00
let pat_ty =
self.resolve_associated_type(iterable_ty, self.resolve_into_iter_item());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
self.infer_pat(*pat, &pat_ty, BindingMode::default());
self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
Ty::unit()
}
Expr::Lambda { body, args, arg_types } => {
assert_eq!(args.len(), arg_types.len());
let mut sig_tys = Vec::new();
for (arg_pat, arg_type) in args.iter().zip(arg_types.iter()) {
let expected = if let Some(type_ref) = arg_type {
self.make_ty(type_ref)
} else {
Ty::Unknown
};
let arg_ty = self.infer_pat(*arg_pat, &expected, BindingMode::default());
sig_tys.push(arg_ty);
}
// add return type
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
let ret_ty = self.table.new_type_var();
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
sig_tys.push(ret_ty.clone());
let sig_ty = Ty::apply(
TypeCtor::FnPtr { num_args: sig_tys.len() as u16 - 1 },
Substs(sig_tys.into()),
);
More ids in Ty
2019-11-25 15:31:48 +00:00
let closure_ty = Ty::apply_one(
TypeCtor::Closure { def: self.owner.into(), expr: tgt_expr },
sig_ty,
);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
// Eagerly try to relate the closure type with the expected
// type, otherwise we often won't have enough information to
// infer the body.
self.coerce(&closure_ty, &expected.ty);
self.infer_expr(*body, &Expectation::has_type(ret_ty));
closure_ty
}
Expr::Call { callee, args } => {
let callee_ty = self.infer_expr(*callee, &Expectation::none());
let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
None => {
// Not callable
// FIXME: report an error
(Vec::new(), Ty::Unknown)
}
};
self.register_obligations_for_call(&callee_ty);
self.check_call_arguments(args, &param_tys);
let ret_ty = self.normalize_associated_types_in(ret_ty);
ret_ty
}
Expr::MethodCall { receiver, args, method_name, generic_args } => self
.infer_method_call(tgt_expr, *receiver, &args, &method_name, generic_args.as_ref()),
Expr::Match { expr, arms } => {
let input_ty = self.infer_expr(*expr, &Expectation::none());
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
let mut result_ty = self.table.new_maybe_never_type_var();
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
for arm in arms {
for &pat in &arm.pats {
let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
}
if let Some(guard_expr) = arm.guard {
self.infer_expr(
guard_expr,
&Expectation::has_type(Ty::simple(TypeCtor::Bool)),
);
}
let arm_ty = self.infer_expr_inner(arm.expr, &expected);
result_ty = self.coerce_merge_branch(&result_ty, &arm_ty);
}
result_ty
}
Expr::Path(p) => {
// FIXME this could be more efficient...
Decouple
2019-11-21 10:32:03 +00:00
let resolver = resolver_for_expr(self.db, self.owner.into(), tgt_expr);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
}
Expr::Continue => Ty::simple(TypeCtor::Never),
Expr::Break { expr } => {
if let Some(expr) = expr {
// FIXME handle break with value
self.infer_expr(*expr, &Expectation::none());
}
Ty::simple(TypeCtor::Never)
}
Expr::Return { expr } => {
if let Some(expr) = expr {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
self.infer_expr_coerce(*expr, &Expectation::has_type(self.return_ty.clone()));
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
Ty::simple(TypeCtor::Never)
}
Expr::RecordLit { path, fields, spread } => {
let (ty, def_id) = self.resolve_variant(path.as_ref());
if let Some(variant) = def_id {
self.write_variant_resolution(tgt_expr.into(), variant);
}
self.unify(&ty, &expected.ty);
let substs = ty.substs().unwrap_or_else(Substs::empty);
Switch to variant-granularity field type inference
2019-11-24 20:48:39 +00:00
let field_types =
def_id.map(|it| self.db.field_types(it.into())).unwrap_or_default();
Use Id for variats
2019-11-27 13:25:01 +00:00
let variant_data = def_id.map(|it| variant_data(self.db, it));
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
for (field_idx, field) in fields.iter().enumerate() {
Use Id for variats
2019-11-27 13:25:01 +00:00
let field_def =
variant_data.as_ref().and_then(|it| match it.field(&field.name) {
Some(local_id) => {
Some(StructFieldId { parent: def_id.unwrap(), local_id })
}
None => {
self.push_diagnostic(InferenceDiagnostic::NoSuchField {
expr: tgt_expr,
field: field_idx,
});
None
}
});
Don't redo field resolution in the IDE
2019-11-24 17:06:55 +00:00
if let Some(field_def) = field_def {
Use Id for variats
2019-11-27 13:25:01 +00:00
self.result.record_field_resolutions.insert(field.expr, field_def);
Don't redo field resolution in the IDE
2019-11-24 17:06:55 +00:00
}
Switch to variant-granularity field type inference
2019-11-24 20:48:39 +00:00
let field_ty = field_def
Use Id for variats
2019-11-27 13:25:01 +00:00
.map_or(Ty::Unknown, |it| field_types[it.local_id].clone())
Switch to variant-granularity field type inference
2019-11-24 20:48:39 +00:00
.subst(&substs);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
}
if let Some(expr) = spread {
self.infer_expr(*expr, &Expectation::has_type(ty.clone()));
}
ty
}
Expr::Field { expr, name } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let receiver_ty = self.infer_expr_inner(*expr, &Expectation::none());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
let canonicalized = self.canonicalizer().canonicalize_ty(receiver_ty);
let ty = autoderef::autoderef(
self.db,
Remove Resolver from autoderef Resolver holds onto too much context, including local scopes. Let's try to pass in only what is necessary -- the trait environment.
2019-11-25 10:10:26 +00:00
self.resolver.krate(),
InEnvironment {
value: canonicalized.value.clone(),
environment: self.trait_env.clone(),
},
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
)
.find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
Ty::Apply(a_ty) => match a_ty.ctor {
TypeCtor::Tuple { .. } => name
.as_tuple_index()
.and_then(|idx| a_ty.parameters.0.get(idx).cloned()),
Id-ify Ty::Adt
2019-11-26 11:29:12 +00:00
TypeCtor::Adt(AdtId::StructId(s)) => {
self.db.struct_data(s).variant_data.field(name).map(|local_id| {
let field = StructFieldId { parent: s.into(), local_id }.into();
self.write_field_resolution(tgt_expr, field);
Decouple more
2019-11-27 12:56:20 +00:00
self.db.field_types(s.into())[field.local_id]
Id-ify Ty::Adt
2019-11-26 11:29:12 +00:00
.clone()
.subst(&a_ty.parameters)
})
}
Fixme for union fields
2019-11-25 14:34:15 +00:00
// FIXME:
Id-ify Ty::Adt
2019-11-26 11:29:12 +00:00
TypeCtor::Adt(AdtId::UnionId(_)) => None,
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
_ => None,
},
_ => None,
})
.unwrap_or(Ty::Unknown);
let ty = self.insert_type_vars(ty);
self.normalize_associated_types_in(ty)
}
Expr::Await { expr } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
Add helper for resolving associated type of trait in infer
2019-12-13 11:44:07 +00:00
let ty =
self.resolve_associated_type(inner_ty, self.resolve_future_future_output());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
ty
}
Expr::Try { expr } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
Add helper for resolving associated type of trait in infer
2019-12-13 11:44:07 +00:00
let ty = self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
ty
}
Expr::Cast { expr, type_ref } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let _inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
let cast_ty = self.make_ty(type_ref);
// FIXME check the cast...
cast_ty
}
Expr::Ref { expr, mutability } => {
let expectation =
if let Some((exp_inner, exp_mutability)) = &expected.ty.as_reference() {
if *exp_mutability == Mutability::Mut && *mutability == Mutability::Shared {
// FIXME: throw type error - expected mut reference but found shared ref,
// which cannot be coerced
}
Expectation::has_type(Ty::clone(exp_inner))
} else {
Expectation::none()
};
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let inner_ty = self.infer_expr_inner(*expr, &expectation);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
Ty::apply_one(TypeCtor::Ref(*mutability), inner_ty)
}
Expr::Box { expr } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
if let Some(box_) = self.resolve_boxed_box() {
Ty::apply_one(TypeCtor::Adt(box_), inner_ty)
} else {
Ty::Unknown
}
}
Expr::UnaryOp { expr, op } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
match op {
Remove Resolver from autoderef Resolver holds onto too much context, including local scopes. Let's try to pass in only what is necessary -- the trait environment.
2019-11-25 10:10:26 +00:00
UnaryOp::Deref => match self.resolver.krate() {
Some(krate) => {
let canonicalized = self.canonicalizer().canonicalize_ty(inner_ty);
match autoderef::deref(
self.db,
krate,
InEnvironment {
value: &canonicalized.value,
environment: self.trait_env.clone(),
},
) {
Some(derefed_ty) => {
canonicalized.decanonicalize_ty(derefed_ty.value)
}
None => Ty::Unknown,
}
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
Remove Resolver from autoderef Resolver holds onto too much context, including local scopes. Let's try to pass in only what is necessary -- the trait environment.
2019-11-25 10:10:26 +00:00
None => Ty::Unknown,
},
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
UnaryOp::Neg => {
match &inner_ty {
Correctly infer - and ! using std::ops::{Neg,Not}
2019-12-13 11:44:42 +00:00
// Fast path for builtins
Ty::Apply(ApplicationTy {
ctor:
TypeCtor::Int(Uncertain::Known(IntTy {
signedness: Signedness::Signed,
..
})),
..
})
| Ty::Apply(ApplicationTy {
ctor: TypeCtor::Int(Uncertain::Unknown),
..
})
| Ty::Apply(ApplicationTy { ctor: TypeCtor::Float(_), .. })
| Ty::Infer(InferTy::IntVar(..))
| Ty::Infer(InferTy::FloatVar(..)) => inner_ty,
// Otherwise we resolve via the std::ops::Neg trait
_ => self
.resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
}
UnaryOp::Not => {
match &inner_ty {
Correctly infer - and ! using std::ops::{Neg,Not}
2019-12-13 11:44:42 +00:00
// Fast path for builtins
Ty::Apply(ApplicationTy { ctor: TypeCtor::Bool, .. })
| Ty::Apply(ApplicationTy { ctor: TypeCtor::Int(_), .. })
| Ty::Infer(InferTy::IntVar(..)) => inner_ty,
// Otherwise we resolve via the std::ops::Not trait
_ => self
.resolve_associated_type(inner_ty, self.resolve_ops_not_output()),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
}
}
}
Expr::BinaryOp { lhs, rhs, op } => match op {
Some(op) => {
let lhs_expectation = match op {
BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
_ => Expectation::none(),
};
let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
// FIXME: find implementation of trait corresponding to operation
// symbol and resolve associated `Output` type
let rhs_expectation = op::binary_op_rhs_expectation(*op, lhs_ty);
let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation));
// FIXME: similar as above, return ty is often associated trait type
op::binary_op_return_ty(*op, rhs_ty)
}
_ => Ty::Unknown,
},
Reduce variants of Expr
2019-11-29 06:49:12 +00:00
Expr::Range { lhs, rhs, range_type } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none()));
Reduce variants of Expr
2019-11-29 06:49:12 +00:00
let rhs_expect = lhs_ty
.as_ref()
.map_or_else(Expectation::none, |ty| Expectation::has_type(ty.clone()));
let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect));
match (range_type, lhs_ty, rhs_ty) {
(RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
Some(adt) => Ty::simple(TypeCtor::Adt(adt)),
None => Ty::Unknown,
},
(RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
None => Ty::Unknown,
},
(RangeOp::Inclusive, None, Some(ty)) => {
match self.resolve_range_to_inclusive() {
Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
None => Ty::Unknown,
}
}
(RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
None => Ty::Unknown,
},
(RangeOp::Inclusive, Some(_), Some(ty)) => {
match self.resolve_range_inclusive() {
Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
None => Ty::Unknown,
}
}
(RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
Some(adt) => Ty::apply_one(TypeCtor::Adt(adt), ty),
None => Ty::Unknown,
},
(RangeOp::Inclusive, _, None) => Ty::Unknown,
Infer range types
2019-11-28 19:10:16 +00:00
}
}
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
Expr::Index { base, index } => {
Don't unify within a reference If we are expecting a `&Foo` and get a `&something`, when checking the `something`, we are *expecting* a `Foo`, but we shouldn't try to unify whatever we get with that expectation, because it could actually be a `&Foo`, and `&&Foo` coerces to `&Foo`. So this fixes quite a few false type mismatches.
2019-12-05 22:02:31 +00:00
let _base_ty = self.infer_expr_inner(*base, &Expectation::none());
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
let _index_ty = self.infer_expr(*index, &Expectation::none());
// FIXME: use `std::ops::Index::Output` to figure out the real return type
Ty::Unknown
}
Expr::Tuple { exprs } => {
let mut tys = match &expected.ty {
ty_app!(TypeCtor::Tuple { .. }, st) => st
.iter()
.cloned()
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
.chain(repeat_with(|| self.table.new_type_var()))
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
.take(exprs.len())
.collect::<Vec<_>>(),
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
_ => (0..exprs.len()).map(|_| self.table.new_type_var()).collect(),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
};
for (expr, ty) in exprs.iter().zip(tys.iter_mut()) {
self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
}
Ty::apply(TypeCtor::Tuple { cardinality: tys.len() as u16 }, Substs(tys.into()))
}
Expr::Array(array) => {
let elem_ty = match &expected.ty {
ty_app!(TypeCtor::Array, st) | ty_app!(TypeCtor::Slice, st) => {
st.as_single().clone()
}
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
_ => self.table.new_type_var(),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
};
match array {
Array::ElementList(items) => {
for expr in items.iter() {
self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
}
}
Array::Repeat { initializer, repeat } => {
self.infer_expr_coerce(
*initializer,
&Expectation::has_type(elem_ty.clone()),
);
self.infer_expr(
*repeat,
Reduce duplication between uncertain floats & ints
2019-11-13 06:56:33 +00:00
&Expectation::has_type(Ty::simple(TypeCtor::Int(Uncertain::Known(
IntTy::usize(),
)))),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
);
}
}
Ty::apply_one(TypeCtor::Array, elem_ty)
}
Expr::Literal(lit) => match lit {
Literal::Bool(..) => Ty::simple(TypeCtor::Bool),
Literal::String(..) => {
Ty::apply_one(TypeCtor::Ref(Mutability::Shared), Ty::simple(TypeCtor::Str))
}
Literal::ByteString(..) => {
Reduce duplication between uncertain floats & ints
2019-11-13 06:56:33 +00:00
let byte_type = Ty::simple(TypeCtor::Int(Uncertain::Known(IntTy::u8())));
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
let slice_type = Ty::apply_one(TypeCtor::Slice, byte_type);
Ty::apply_one(TypeCtor::Ref(Mutability::Shared), slice_type)
}
Literal::Char(..) => Ty::simple(TypeCtor::Char),
Move definition of exprs to hir_def
2019-11-12 12:09:25 +00:00
Literal::Int(_v, ty) => Ty::simple(TypeCtor::Int((*ty).into())),
Literal::Float(_v, ty) => Ty::simple(TypeCtor::Float((*ty).into())),
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
},
};
// use a new type variable if we got Ty::Unknown here
let ty = self.insert_type_vars_shallow(ty);
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
let ty = self.resolve_ty_as_possible(ty);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
self.write_expr_ty(tgt_expr, ty.clone());
ty
}
fn infer_block(
&mut self,
statements: &[Statement],
tail: Option<ExprId>,
expected: &Expectation,
) -> Ty {
let mut diverges = false;
for stmt in statements {
match stmt {
Statement::Let { pat, type_ref, initializer } => {
let decl_ty =
type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(Ty::Unknown);
// Always use the declared type when specified
let mut ty = decl_ty.clone();
if let Some(expr) = initializer {
let actual_ty =
self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
if decl_ty == Ty::Unknown {
ty = actual_ty;
}
}
Extract unification code to unify module
2019-12-01 19:30:28 +00:00
let ty = self.resolve_ty_as_possible(ty);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
self.infer_pat(*pat, &ty, BindingMode::default());
}
Statement::Expr(expr) => {
if let ty_app!(TypeCtor::Never) = self.infer_expr(*expr, &Expectation::none()) {
diverges = true;
}
}
}
}
let ty = if let Some(expr) = tail {
self.infer_expr_coerce(expr, expected)
} else {
self.coerce(&Ty::unit(), &expected.ty);
Ty::unit()
};
if diverges {
Ty::simple(TypeCtor::Never)
} else {
ty
}
}
fn infer_method_call(
&mut self,
tgt_expr: ExprId,
receiver: ExprId,
args: &[ExprId],
method_name: &Name,
generic_args: Option<&GenericArgs>,
) -> Ty {
let receiver_ty = self.infer_expr(receiver, &Expectation::none());
let canonicalized_receiver = self.canonicalizer().canonicalize_ty(receiver_ty.clone());
let resolved = method_resolution::lookup_method(
&canonicalized_receiver.value,
self.db,
method_name,
&self.resolver,
);
let (derefed_receiver_ty, method_ty, def_generics) = match resolved {
Some((ty, func)) => {
let ty = canonicalized_receiver.decanonicalize_ty(ty);
self.write_method_resolution(tgt_expr, func);
Remove idx and parent generics from generics This makes `hir_def::GenericParams` flatter. The logic for re-numbering the params is moved to hir instead.
2019-12-07 10:50:36 +00:00
(ty, self.db.value_ty(func.into()), Some(generics(self.db, func.into())))
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
None => (receiver_ty, Ty::Unknown, None),
};
let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
let method_ty = method_ty.apply_substs(substs);
let method_ty = self.insert_type_vars(method_ty);
self.register_obligations_for_call(&method_ty);
let (expected_receiver_ty, param_tys, ret_ty) = match method_ty.callable_sig(self.db) {
Some(sig) => {
if !sig.params().is_empty() {
(sig.params()[0].clone(), sig.params()[1..].to_vec(), sig.ret().clone())
} else {
(Ty::Unknown, Vec::new(), sig.ret().clone())
}
}
None => (Ty::Unknown, Vec::new(), Ty::Unknown),
};
// Apply autoref so the below unification works correctly
// FIXME: return correct autorefs from lookup_method
let actual_receiver_ty = match expected_receiver_ty.as_reference() {
Some((_, mutability)) => Ty::apply_one(TypeCtor::Ref(mutability), derefed_receiver_ty),
_ => derefed_receiver_ty,
};
self.unify(&expected_receiver_ty, &actual_receiver_ty);
self.check_call_arguments(args, &param_tys);
let ret_ty = self.normalize_associated_types_in(ret_ty);
ret_ty
}
fn check_call_arguments(&mut self, args: &[ExprId], param_tys: &[Ty]) {
// Quoting https://github.com/rust-lang/rust/blob/6ef275e6c3cb1384ec78128eceeb4963ff788dca/src/librustc_typeck/check/mod.rs#L3325 --
// We do this in a pretty awful way: first we type-check any arguments
// that are not closures, then we type-check the closures. This is so
// that we have more information about the types of arguments when we
// type-check the functions. This isn't really the right way to do this.
for &check_closures in &[false, true] {
let param_iter = param_tys.iter().cloned().chain(repeat(Ty::Unknown));
for (&arg, param_ty) in args.iter().zip(param_iter) {
let is_closure = match &self.body[arg] {
Expr::Lambda { .. } => true,
_ => false,
};
if is_closure != check_closures {
continue;
}
let param_ty = self.normalize_associated_types_in(param_ty);
self.infer_expr_coerce(arg, &Expectation::has_type(param_ty.clone()));
}
}
}
fn substs_for_method_call(
&mut self,
Remove idx and parent generics from generics This makes `hir_def::GenericParams` flatter. The logic for re-numbering the params is moved to hir instead.
2019-12-07 10:50:36 +00:00
def_generics: Option<Generics>,
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
generic_args: Option<&GenericArgs>,
receiver_ty: &Ty,
) -> Substs {
Refactor parameter count tracking
2019-12-07 12:05:05 +00:00
let (total_len, _parent_len, child_len) =
def_generics.as_ref().map_or((0, 0, 0), |g| g.len_split());
let mut substs = Vec::with_capacity(total_len);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
// Parent arguments are unknown, except for the receiver type
Remove idx and parent generics from generics This makes `hir_def::GenericParams` flatter. The logic for re-numbering the params is moved to hir instead.
2019-12-07 10:50:36 +00:00
if let Some(parent_generics) = def_generics.as_ref().map(|p| p.iter_parent()) {
for (_id, param) in parent_generics {
Add macros for known names and paths
2019-12-13 20:43:53 +00:00
if param.name == N![Self] {
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
substs.push(receiver_ty.clone());
} else {
substs.push(Ty::Unknown);
}
}
}
// handle provided type arguments
if let Some(generic_args) = generic_args {
// if args are provided, it should be all of them, but we can't rely on that
Refactor parameter count tracking
2019-12-07 12:05:05 +00:00
for arg in generic_args.args.iter().take(child_len) {
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
match arg {
GenericArg::Type(type_ref) => {
let ty = self.make_ty(type_ref);
substs.push(ty);
}
}
}
};
let supplied_params = substs.len();
Refactor parameter count tracking
2019-12-07 12:05:05 +00:00
for _ in supplied_params..total_len {
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
substs.push(Ty::Unknown);
}
Refactor parameter count tracking
2019-12-07 12:05:05 +00:00
assert_eq!(substs.len(), total_len);
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
Substs(substs.into())
}
fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
if let Ty::Apply(a_ty) = callable_ty {
if let TypeCtor::FnDef(def) = a_ty.ctor {
let generic_predicates = self.db.generic_predicates(def.into());
for predicate in generic_predicates.iter() {
let predicate = predicate.clone().subst(&a_ty.parameters);
if let Some(obligation) = Obligation::from_predicate(predicate) {
self.obligations.push(obligation);
}
}
// add obligation for trait implementation, if this is a trait method
match def {
Use ids for Callable
2019-11-25 13:26:52 +00:00
CallableDef::FunctionId(f) => {
if let ContainerId::TraitId(trait_) = f.lookup(self.db).container {
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
// construct a TraitDef
Refactor parameter count tracking
2019-12-07 12:05:05 +00:00
let substs =
a_ty.parameters.prefix(generics(self.db, trait_.into()).len());
Use ids for Callable
2019-11-25 13:26:52 +00:00
self.obligations.push(Obligation::Trait(TraitRef {
trait_: trait_.into(),
substs,
}));
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
}
Use ids for Callable
2019-11-25 13:26:52 +00:00
CallableDef::StructId(_) | CallableDef::EnumVariantId(_) => {}
Split up infer.rs further - coercion logic goes to `coerce.rs` - expression inference goes to `expr.rs` - pattern inference goes to `pat.rs`
2019-10-12 15:39:20 +00:00
}
}
}
}
}
Reference in a new issue Copy permalink