language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-28 04:44:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Separate Ty and TyKind like in Chalk

Browse source 
Currently `Ty` just wraps `TyKind`, but this allows us to change most
places to already use `intern` / `interned`.
This commit is contained in:
Florian Diebold 2021-03-13 14:44:51 +01:00
parent 7accf6bc37
commit 6c32bbf3ca
20 changed files with 756 additions and 620 deletions
Download patch file Download diff file Expand all files Collapse all files

237
crates/hir_ty/src/infer/expr.rs
View file

@ -20,8 +20,8 @@ use crate::{
primitive::{self, UintTy},
traits::{FnTrait, InEnvironment},
utils::{generics, variant_data, Generics},
AdtId, Binders, CallableDefId, FnPointer, FnSig, Obligation, OpaqueTyId, Rawness, Scalar,
Substs, TraitRef, Ty,
AdtId, Binders, CallableDefId, FnPointer, FnSig, Interner, Obligation, OpaqueTyId, Rawness,
Scalar, Substs, TraitRef, Ty, TyKind,
};
use super::{
@ -57,7 +57,7 @@ impl<'a> InferenceContext<'a> {
// Return actual type when type mismatch.
// This is needed for diagnostic when return type mismatch.
ty
} else if expected.coercion_target() == &Ty::Unknown {
} else if expected.coercion_target().is_unknown() {
ty
} else {
expected.ty.clone()
@ -84,7 +84,7 @@ impl<'a> InferenceContext<'a> {
arg_tys.push(arg);
}
let parameters = param_builder.build();
let arg_ty = Ty::Tuple(num_args, parameters);
let arg_ty = TyKind::Tuple(num_args, parameters).intern(&Interner);
let substs =
Substs::build_for_generics(&generic_params).push(ty.clone()).push(arg_ty).build();
@ -116,10 +116,13 @@ impl<'a> InferenceContext<'a> {
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::Missing => self.err_ty(),
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::Scalar(Scalar::Bool)));
self.infer_expr(
*condition,
&Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
);
let condition_diverges = mem::replace(&mut self.diverges, Diverges::Maybe);
let mut both_arms_diverge = Diverges::Always;
@ -167,14 +170,14 @@ impl<'a> InferenceContext<'a> {
Expr::TryBlock { body } => {
let _inner = self.infer_expr(*body, expected);
// FIXME should be std::result::Result<{inner}, _>
Ty::Unknown
self.err_ty()
}
Expr::Async { body } => {
// Use the first type parameter as the output type of future.
// existenail type AsyncBlockImplTrait<InnerType>: Future<Output = InnerType>
let inner_ty = self.infer_expr(*body, &Expectation::none());
let opaque_ty_id = OpaqueTyId::AsyncBlockTypeImplTrait(self.owner, *body);
Ty::OpaqueType(opaque_ty_id, Substs::single(inner_ty))
TyKind::OpaqueType(opaque_ty_id, Substs::single(inner_ty)).intern(&Interner)
}
Expr::Loop { body, label } => {
self.breakables.push(BreakableContext {
@ -192,17 +195,20 @@ impl<'a> InferenceContext<'a> {
if ctxt.may_break {
ctxt.break_ty
} else {
Ty::Never
TyKind::Never.intern(&Interner)
}
}
Expr::While { condition, body, label } => {
self.breakables.push(BreakableContext {
may_break: false,
break_ty: Ty::Unknown,
break_ty: self.err_ty(),
label: label.map(|label| self.body[label].name.clone()),
});
// while let is desugared to a match loop, so this is always simple while
self.infer_expr(*condition, &Expectation::has_type(Ty::Scalar(Scalar::Bool)));
self.infer_expr(
*condition,
&Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
);
self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
let _ctxt = self.breakables.pop().expect("breakable stack broken");
// the body may not run, so it diverging doesn't mean we diverge
@ -214,7 +220,7 @@ impl<'a> InferenceContext<'a> {
self.breakables.push(BreakableContext {
may_break: false,
break_ty: Ty::Unknown,
break_ty: self.err_ty(),
label: label.map(|label| self.body[label].name.clone()),
});
let pat_ty =
@ -249,12 +255,14 @@ impl<'a> InferenceContext<'a> {
None => self.table.new_type_var(),
};
sig_tys.push(ret_ty.clone());
let sig_ty = Ty::Function(FnPointer {
let sig_ty = TyKind::Function(FnPointer {
num_args: sig_tys.len() - 1,
sig: FnSig { variadic: false },
substs: Substs(sig_tys.clone().into()),
});
let closure_ty = Ty::Closure(self.owner, tgt_expr, Substs::single(sig_ty));
})
.intern(&Interner);
let closure_ty =
TyKind::Closure(self.owner, tgt_expr, Substs::single(sig_ty)).intern(&Interner);
// Eagerly try to relate the closure type with the expected
// type, otherwise we often won't have enough information to
@ -295,7 +303,7 @@ impl<'a> InferenceContext<'a> {
args.len(),
)
})
.unwrap_or((Vec::new(), Ty::Unknown));
.unwrap_or((Vec::new(), self.err_ty()));
self.register_obligations_for_call(&callee_ty);
self.check_call_arguments(args, &param_tys);
self.normalize_associated_types_in(ret_ty)
@ -305,8 +313,11 @@ impl<'a> InferenceContext<'a> {
Expr::Match { expr, arms } => {
let input_ty = self.infer_expr(*expr, &Expectation::none());
let mut result_ty =
if arms.is_empty() { Ty::Never } else { self.table.new_type_var() };
let mut result_ty = if arms.is_empty() {
TyKind::Never.intern(&Interner)
} else {
self.table.new_type_var()
};
let matchee_diverges = self.diverges;
let mut all_arms_diverge = Diverges::Always;
@ -317,7 +328,7 @@ impl<'a> InferenceContext<'a> {
if let Some(guard_expr) = arm.guard {
self.infer_expr(
guard_expr,
&Expectation::has_type(Ty::Scalar(Scalar::Bool)),
&Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
);
}
@ -333,9 +344,9 @@ impl<'a> InferenceContext<'a> {
Expr::Path(p) => {
// FIXME this could be more efficient...
let resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(Ty::Unknown)
self.infer_path(&resolver, p, tgt_expr.into()).unwrap_or(self.err_ty())
}
Expr::Continue { .. } => Ty::Never,
Expr::Continue { .. } => TyKind::Never.intern(&Interner),
Expr::Break { expr, label } => {
let val_ty = if let Some(expr) = expr {
self.infer_expr(*expr, &Expectation::none())
@ -347,7 +358,7 @@ impl<'a> InferenceContext<'a> {
if let Some(ctxt) = find_breakable(&mut self.breakables, label.as_ref()) {
ctxt.break_ty.clone()
} else {
Ty::Unknown
self.err_ty()
};
let merged_type = self.coerce_merge_branch(&last_ty, &val_ty);
@ -360,7 +371,7 @@ impl<'a> InferenceContext<'a> {
expr: tgt_expr,
});
}
Ty::Never
TyKind::Never.intern(&Interner)
}
Expr::Return { expr } => {
if let Some(expr) = expr {
@ -369,14 +380,14 @@ impl<'a> InferenceContext<'a> {
let unit = Ty::unit();
self.coerce(&unit, &self.return_ty.clone());
}
Ty::Never
TyKind::Never.intern(&Interner)
}
Expr::Yield { expr } => {
// FIXME: track yield type for coercion
if let Some(expr) = expr {
self.infer_expr(*expr, &Expectation::none());
}
Ty::Never
TyKind::Never.intern(&Interner)
}
Expr::RecordLit { path, fields, spread } => {
let (ty, def_id) = self.resolve_variant(path.as_ref());
@ -404,8 +415,9 @@ impl<'a> InferenceContext<'a> {
if let Some(field_def) = field_def {
self.result.record_field_resolutions.insert(field.expr, field_def);
}
let field_ty = field_def
.map_or(Ty::Unknown, |it| field_types[it.local_id].clone().subst(&substs));
let field_ty = field_def.map_or(self.err_ty(), |it| {
field_types[it.local_id].clone().subst(&substs)
});
self.infer_expr_coerce(field.expr, &Expectation::has_type(field_ty));
}
if let Some(expr) = spread {
@ -424,27 +436,33 @@ impl<'a> InferenceContext<'a> {
environment: self.trait_env.clone(),
},
)
.find_map(|derefed_ty| match canonicalized.decanonicalize_ty(derefed_ty.value) {
Ty::Tuple(_, substs) => {
name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
.find_map(|derefed_ty| {
match canonicalized.decanonicalize_ty(derefed_ty.value).interned(&Interner) {
TyKind::Tuple(_, substs) => {
name.as_tuple_index().and_then(|idx| substs.0.get(idx).cloned())
}
TyKind::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
self.db.struct_data(*s).variant_data.field(name).map(|local_id| {
let field = FieldId { parent: (*s).into(), local_id };
self.write_field_resolution(tgt_expr, field);
self.db.field_types((*s).into())[field.local_id]
.clone()
.subst(&parameters)
})
}
TyKind::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
self.db.union_data(*u).variant_data.field(name).map(|local_id| {
let field = FieldId { parent: (*u).into(), local_id };
self.write_field_resolution(tgt_expr, field);
self.db.field_types((*u).into())[field.local_id]
.clone()
.subst(&parameters)
})
}
_ => None,
}
Ty::Adt(AdtId(hir_def::AdtId::StructId(s)), parameters) => {
self.db.struct_data(s).variant_data.field(name).map(|local_id| {
let field = FieldId { parent: s.into(), local_id };
self.write_field_resolution(tgt_expr, field);
self.db.field_types(s.into())[field.local_id].clone().subst(&parameters)
})
}
Ty::Adt(AdtId(hir_def::AdtId::UnionId(u)), parameters) => {
self.db.union_data(u).variant_data.field(name).map(|local_id| {
let field = FieldId { parent: u.into(), local_id };
self.write_field_resolution(tgt_expr, field);
self.db.field_types(u.into())[field.local_id].clone().subst(&parameters)
})
}
_ => None,
})
.unwrap_or(Ty::Unknown);
.unwrap_or(self.err_ty());
let ty = self.insert_type_vars(ty);
self.normalize_associated_types_in(ty)
}
@ -481,9 +499,10 @@ impl<'a> InferenceContext<'a> {
};
let inner_ty = self.infer_expr_inner(*expr, &expectation);
match rawness {
Rawness::RawPtr => Ty::Raw(mutability, Substs::single(inner_ty)),
Rawness::Ref => Ty::Ref(mutability, Substs::single(inner_ty)),
Rawness::RawPtr => TyKind::Raw(mutability, Substs::single(inner_ty)),
Rawness::Ref => TyKind::Ref(mutability, Substs::single(inner_ty)),
}
.intern(&Interner)
}
Expr::Box { expr } => {
let inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
@ -499,7 +518,7 @@ impl<'a> InferenceContext<'a> {
sb = sb.fill(repeat_with(|| self.table.new_type_var()));
Ty::adt_ty(box_, sb.build())
} else {
Ty::Unknown
self.err_ty()
}
}
Expr::UnaryOp { expr, op } => {
@ -519,31 +538,31 @@ impl<'a> InferenceContext<'a> {
Some(derefed_ty) => {
canonicalized.decanonicalize_ty(derefed_ty.value)
}
None => Ty::Unknown,
None => self.err_ty(),
}
}
None => Ty::Unknown,
None => self.err_ty(),
},
UnaryOp::Neg => {
match &inner_ty {
match inner_ty.interned(&Interner) {
// Fast path for builtins
Ty::Scalar(Scalar::Int(_))
| Ty::Scalar(Scalar::Uint(_))
| Ty::Scalar(Scalar::Float(_))
| Ty::InferenceVar(_, TyVariableKind::Integer)
| Ty::InferenceVar(_, TyVariableKind::Float) => inner_ty,
TyKind::Scalar(Scalar::Int(_))
| TyKind::Scalar(Scalar::Uint(_))
| TyKind::Scalar(Scalar::Float(_))
| TyKind::InferenceVar(_, TyVariableKind::Integer)
| TyKind::InferenceVar(_, TyVariableKind::Float) => inner_ty,
// Otherwise we resolve via the std::ops::Neg trait
_ => self
.resolve_associated_type(inner_ty, self.resolve_ops_neg_output()),
}
}
UnaryOp::Not => {
match &inner_ty {
match inner_ty.interned(&Interner) {
// Fast path for builtins
Ty::Scalar(Scalar::Bool)
| Ty::Scalar(Scalar::Int(_))
| Ty::Scalar(Scalar::Uint(_))
| Ty::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
TyKind::Scalar(Scalar::Bool)
| TyKind::Scalar(Scalar::Int(_))
| TyKind::Scalar(Scalar::Uint(_))
| TyKind::InferenceVar(_, TyVariableKind::Integer) => inner_ty,
// Otherwise we resolve via the std::ops::Not trait
_ => self
.resolve_associated_type(inner_ty, self.resolve_ops_not_output()),
@ -554,7 +573,9 @@ impl<'a> InferenceContext<'a> {
Expr::BinaryOp { lhs, rhs, op } => match op {
Some(op) => {
let lhs_expectation = match op {
BinaryOp::LogicOp(..) => Expectation::has_type(Ty::Scalar(Scalar::Bool)),
BinaryOp::LogicOp(..) => {
Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner))
}
_ => Expectation::none(),
};
let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
@ -563,7 +584,7 @@ impl<'a> InferenceContext<'a> {
let ret = op::binary_op_return_ty(*op, lhs_ty.clone(), rhs_ty.clone());
if ret == Ty::Unknown {
if ret.is_unknown() {
cov_mark::hit!(infer_expr_inner_binary_operator_overload);
self.resolve_associated_type_with_params(
@ -575,7 +596,7 @@ impl<'a> InferenceContext<'a> {
ret
}
}
_ => Ty::Unknown,
_ => self.err_ty(),
},
Expr::Range { lhs, rhs, range_type } => {
let lhs_ty = lhs.map(|e| self.infer_expr_inner(e, &Expectation::none()));
@ -586,33 +607,33 @@ impl<'a> InferenceContext<'a> {
match (range_type, lhs_ty, rhs_ty) {
(RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
Some(adt) => Ty::adt_ty(adt, Substs::empty()),
None => Ty::Unknown,
None => self.err_ty(),
},
(RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
None => Ty::Unknown,
None => self.err_ty(),
},
(RangeOp::Inclusive, None, Some(ty)) => {
match self.resolve_range_to_inclusive() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
None => Ty::Unknown,
None => self.err_ty(),
}
}
(RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
None => Ty::Unknown,
None => self.err_ty(),
},
(RangeOp::Inclusive, Some(_), Some(ty)) => {
match self.resolve_range_inclusive() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
None => Ty::Unknown,
None => self.err_ty(),
}
}
(RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
Some(adt) => Ty::adt_ty(adt, Substs::single(ty)),
None => Ty::Unknown,
None => self.err_ty(),
},
(RangeOp::Inclusive, _, None) => Ty::Unknown,
(RangeOp::Inclusive, _, None) => self.err_ty(),
}
}
Expr::Index { base, index } => {
@ -631,19 +652,19 @@ impl<'a> InferenceContext<'a> {
index_trait,
);
let self_ty =
self_ty.map_or(Ty::Unknown, |t| canonicalized.decanonicalize_ty(t.value));
self_ty.map_or(self.err_ty(), |t| canonicalized.decanonicalize_ty(t.value));
self.resolve_associated_type_with_params(
self_ty,
self.resolve_ops_index_output(),
&[index_ty],
)
} else {
Ty::Unknown
self.err_ty()
}
}
Expr::Tuple { exprs } => {
let mut tys = match &expected.ty {
Ty::Tuple(_, substs) => substs
let mut tys = match expected.ty.interned(&Interner) {
TyKind::Tuple(_, substs) => substs
.iter()
.cloned()
.chain(repeat_with(|| self.table.new_type_var()))
@ -656,11 +677,11 @@ impl<'a> InferenceContext<'a> {
self.infer_expr_coerce(*expr, &Expectation::has_type(ty.clone()));
}
Ty::Tuple(tys.len(), Substs(tys.into()))
TyKind::Tuple(tys.len(), Substs(tys.into())).intern(&Interner)
}
Expr::Array(array) => {
let elem_ty = match &expected.ty {
Ty::Array(st) | Ty::Slice(st) => st.as_single().clone(),
let elem_ty = match expected.ty.interned(&Interner) {
TyKind::Array(st) | TyKind::Slice(st) => st.as_single().clone(),
_ => self.table.new_type_var(),
};
@ -677,43 +698,51 @@ impl<'a> InferenceContext<'a> {
);
self.infer_expr(
*repeat,
&Expectation::has_type(Ty::Scalar(Scalar::Uint(UintTy::Usize))),
&Expectation::has_type(
TyKind::Scalar(Scalar::Uint(UintTy::Usize)).intern(&Interner),
),
);
}
}
Ty::Array(Substs::single(elem_ty))
TyKind::Array(Substs::single(elem_ty)).intern(&Interner)
}
Expr::Literal(lit) => match lit {
Literal::Bool(..) => Ty::Scalar(Scalar::Bool),
Literal::String(..) => Ty::Ref(Mutability::Not, Substs::single(Ty::Str)),
Literal::ByteString(..) => {
let byte_type = Ty::Scalar(Scalar::Uint(UintTy::U8));
let array_type = Ty::Array(Substs::single(byte_type));
Ty::Ref(Mutability::Not, Substs::single(array_type))
Literal::Bool(..) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
Literal::String(..) => {
TyKind::Ref(Mutability::Not, Substs::single(TyKind::Str.intern(&Interner)))
.intern(&Interner)
}
Literal::Char(..) => Ty::Scalar(Scalar::Char),
Literal::ByteString(..) => {
let byte_type = TyKind::Scalar(Scalar::Uint(UintTy::U8)).intern(&Interner);
let array_type = TyKind::Array(Substs::single(byte_type)).intern(&Interner);
TyKind::Ref(Mutability::Not, Substs::single(array_type)).intern(&Interner)
}
Literal::Char(..) => TyKind::Scalar(Scalar::Char).intern(&Interner),
Literal::Int(_v, ty) => match ty {
Some(int_ty) => {
Ty::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty)))
TyKind::Scalar(Scalar::Int(primitive::int_ty_from_builtin(*int_ty)))
.intern(&Interner)
}
None => self.table.new_integer_var(),
},
Literal::Uint(_v, ty) => match ty {
Some(int_ty) => {
Ty::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty)))
TyKind::Scalar(Scalar::Uint(primitive::uint_ty_from_builtin(*int_ty)))
.intern(&Interner)
}
None => self.table.new_integer_var(),
},
Literal::Float(_v, ty) => match ty {
Some(float_ty) => {
Ty::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty)))
TyKind::Scalar(Scalar::Float(primitive::float_ty_from_builtin(*float_ty)))
.intern(&Interner)
}
None => self.table.new_float_var(),
},
},
};
// use a new type variable if we got Ty::Unknown here
// use a new type variable if we got unknown here
let ty = self.insert_type_vars_shallow(ty);
let ty = self.resolve_ty_as_possible(ty);
self.write_expr_ty(tgt_expr, ty.clone());
@ -730,7 +759,7 @@ impl<'a> InferenceContext<'a> {
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);
type_ref.as_ref().map(|tr| self.make_ty(tr)).unwrap_or(self.err_ty());
// Always use the declared type when specified
let mut ty = decl_ty.clone();
@ -738,7 +767,7 @@ impl<'a> InferenceContext<'a> {
if let Some(expr) = initializer {
let actual_ty =
self.infer_expr_coerce(*expr, &Expectation::has_type(decl_ty.clone()));
if decl_ty == Ty::Unknown {
if decl_ty.is_unknown() {
ty = actual_ty;
}
}
@ -802,7 +831,7 @@ impl<'a> InferenceContext<'a> {
self.write_method_resolution(tgt_expr, func);
(ty, self.db.value_ty(func.into()), Some(generics(self.db.upcast(), func.into())))
}
None => (receiver_ty, Binders::new(0, Ty::Unknown), None),
None => (receiver_ty, Binders::new(0, self.err_ty()), None),
};
let substs = self.substs_for_method_call(def_generics, generic_args, &derefed_receiver_ty);
let method_ty = method_ty.subst(&substs);
@ -813,15 +842,17 @@ impl<'a> InferenceContext<'a> {
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())
(self.err_ty(), Vec::new(), sig.ret().clone())
}
}
None => (Ty::Unknown, Vec::new(), Ty::Unknown),
None => (self.err_ty(), Vec::new(), self.err_ty()),
};
// 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::Ref(mutability, Substs::single(derefed_receiver_ty)),
Some((_, mutability)) => {
TyKind::Ref(mutability, Substs::single(derefed_receiver_ty)).intern(&Interner)
}
_ => derefed_receiver_ty,
};
self.unify(&expected_receiver_ty, &actual_receiver_ty);
@ -837,7 +868,7 @@ impl<'a> InferenceContext<'a> {
// 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));
let param_iter = param_tys.iter().cloned().chain(repeat(self.err_ty()));
for (&arg, param_ty) in args.iter().zip(param_iter) {
let is_closure = matches!(&self.body[arg], Expr::Lambda { .. });
if is_closure != check_closures {
@ -867,7 +898,7 @@ impl<'a> InferenceContext<'a> {
if param.provenance == hir_def::generics::TypeParamProvenance::TraitSelf {
substs.push(receiver_ty.clone());
} else {
substs.push(Ty::Unknown);
substs.push(self.err_ty());
}
}
}
@ -891,15 +922,15 @@ impl<'a> InferenceContext<'a> {
};
let supplied_params = substs.len();
for _ in supplied_params..total_len {
substs.push(Ty::Unknown);
substs.push(self.err_ty());
}
assert_eq!(substs.len(), total_len);
Substs(substs.into())
}
fn register_obligations_for_call(&mut self, callable_ty: &Ty) {
if let &Ty::FnDef(def, ref parameters) = callable_ty {
let generic_predicates = self.db.generic_predicates(def.into());
if let TyKind::FnDef(def, parameters) = callable_ty.interned(&Interner) {
let generic_predicates = self.db.generic_predicates((*def).into());
for predicate in generic_predicates.iter() {
let predicate = predicate.clone().subst(parameters);
if let Some(obligation) = Obligation::from_predicate(predicate) {