mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor expectation handling

Browse Source 
So as to not use `TyKind::Error` as "no expectation".
This commit is contained in:
Florian Diebold 2021-05-21 17:41:20 +02:00
parent 99c73537fa
commit 556c9cebdb
3 changed files with 88 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
crates/hir_ty/src/infer.rs
View File

@ -370,10 +370,6 @@ fn push_obligation(&mut self, o: DomainGoal) {
}
fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
// TODO handle expectations properly
if ty2.is_unknown() {
return true;
}
self.table.unify(ty1, ty2)
}
@ -679,17 +675,23 @@ fn resolve_ops_index_output(&self) -> Option<TypeAliasId> {
/// When inferring an expression, we propagate downward whatever type hint we
/// are able in the form of an `Expectation`.
#[derive(Clone, PartialEq, Eq, Debug)]
struct Expectation {
ty: Ty,
/// See the `rvalue_hint` method.
rvalue_hint: bool,
enum Expectation {
None,
HasType(Ty),
// Castable(Ty), // rustc has this, we currently just don't propagate an expectation for casts
RValueLikeUnsized(Ty),
}
impl Expectation {
/// The expectation that the type of the expression needs to equal the given
/// type.
fn has_type(ty: Ty) -> Self {
Expectation { ty, rvalue_hint: false }
if ty.is_unknown() {
// FIXME: get rid of this?
Expectation::None
} else {
Expectation::HasType(ty)
}
}
/// The following explanation is copied straight from rustc:
@ -713,24 +715,41 @@ fn has_type(ty: Ty) -> Self {
/// See the test case `test/ui/coerce-expect-unsized.rs` and #20169
/// for examples of where this comes up,.
fn rvalue_hint(ty: Ty) -> Self {
Expectation { ty, rvalue_hint: true }
match ty.strip_references().kind(&Interner) {
TyKind::Slice(_) | TyKind::Str | TyKind::Dyn(_) => Expectation::RValueLikeUnsized(ty),
_ => Expectation::has_type(ty),
}
}
/// This expresses no expectation on the type.
fn none() -> Self {
Expectation {
// FIXME
ty: TyKind::Error.intern(&Interner),
rvalue_hint: false,
Expectation::None
}
fn resolve(&self, table: &mut unify::InferenceTable) -> Expectation {
match self {
Expectation::None => Expectation::None,
Expectation::HasType(t) => Expectation::HasType(table.resolve_ty_shallow(t)),
Expectation::RValueLikeUnsized(t) => {
Expectation::RValueLikeUnsized(table.resolve_ty_shallow(t))
}
}
}
fn coercion_target(&self) -> Ty {
if self.rvalue_hint {
// FIXME
TyKind::Error.intern(&Interner)
} else {
self.ty.clone()
fn to_option(&self, table: &mut unify::InferenceTable) -> Option<Ty> {
match self.resolve(table) {
Expectation::None => None,
Expectation::HasType(t) |
// Expectation::Castable(t) |
Expectation::RValueLikeUnsized(t) => Some(t),
}
}
fn only_has_type(&self, table: &mut unify::InferenceTable) -> Option<Ty> {
match self {
Expectation::HasType(t) => Some(table.resolve_ty_shallow(t)),
// Expectation::Castable(_) |
Expectation::RValueLikeUnsized(_) | Expectation::None => None,
}
}
}

4
crates/hir_ty/src/infer/coerce.rs
View File

@ -21,10 +21,6 @@ impl<'a> InferenceContext<'a> {
pub(super) fn coerce(&mut self, from_ty: &Ty, to_ty: &Ty) -> bool {
let from_ty = self.resolve_ty_shallow(from_ty);
let to_ty = self.resolve_ty_shallow(to_ty);
// TODO handle expectations properly
if to_ty.is_unknown() {
return true;
}
match self.coerce_inner(from_ty, &to_ty) {
Ok(result) => {
self.table.register_infer_ok(result);

79
crates/hir_ty/src/infer/expr.rs
View File

@ -39,12 +39,14 @@ pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) ->
// Any expression that produces a value of type `!` must have diverged
self.diverges = Diverges::Always;
}
let could_unify = self.unify(&ty, &expected.ty);
if !could_unify {
self.result.type_mismatches.insert(
tgt_expr.into(),
TypeMismatch { expected: expected.ty.clone(), actual: ty.clone() },
);
if let Some(expected_ty) = expected.only_has_type(&mut self.table) {
let could_unify = self.unify(&ty, &expected_ty);
if !could_unify {
self.result.type_mismatches.insert(
tgt_expr.into(),
TypeMismatch { expected: expected_ty.clone(), actual: ty.clone() },
);
}
}
ty
}
@ -53,18 +55,20 @@ pub(super) fn infer_expr(&mut self, tgt_expr: ExprId, expected: &Expectation) ->
/// Return the type after possible coercion.
pub(super) 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.coercion_target()) {
self.result.type_mismatches.insert(
expr.into(),
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.coercion_target().is_unknown() {
ty
let ty = if let Some(target) = expected.only_has_type(&mut self.table) {
if !self.coerce(&ty, &target) {
self.result.type_mismatches.insert(
expr.into(),
TypeMismatch { expected: target.clone(), actual: ty.clone() },
);
// Return actual type when type mismatch.
// This is needed for diagnostic when return type mismatch.
ty
} else {
target.clone()
}
} else {
expected.ty.clone()
ty
};
ty
@ -280,7 +284,9 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
// 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);
if let Some(t) = expected.only_has_type(&mut self.table) {
self.coerce(&closure_ty, &t);
}
// Now go through the argument patterns
for (arg_pat, arg_ty) in args.iter().zip(sig_tys) {
@ -413,7 +419,9 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
self.write_variant_resolution(tgt_expr.into(), variant);
}
self.unify(&ty, &expected.ty);
if let Some(t) = expected.only_has_type(&mut self.table) {
self.unify(&ty, &t);
}
let substs = ty
.as_adt()
@ -516,6 +524,7 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
self.resolve_associated_type(inner_ty, self.resolve_ops_try_ok())
}
Expr::Cast { expr, type_ref } => {
// FIXME: propagate the "castable to" expectation (and find a test case that shows this is necessary)
let _inner_ty = self.infer_expr_inner(*expr, &Expectation::none());
let cast_ty = self.make_ty(type_ref);
// FIXME check the cast...
@ -523,14 +532,16 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
}
Expr::Ref { expr, rawness, mutability } => {
let mutability = lower_to_chalk_mutability(*mutability);
let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) =
&self.resolve_ty_shallow(&expected.ty).as_reference_or_ptr()
let expectation = if let Some((exp_inner, exp_rawness, exp_mutability)) = expected
.only_has_type(&mut self.table)
.as_ref()
.and_then(|t| t.as_reference_or_ptr())
{
if *exp_mutability == Mutability::Mut && mutability == Mutability::Not {
if exp_mutability == Mutability::Mut && mutability == Mutability::Not {
// FIXME: record type error - expected mut reference but found shared ref,
// which cannot be coerced
}
if *exp_rawness == Rawness::Ref && *rawness == Rawness::RawPtr {
if exp_rawness == Rawness::Ref && *rawness == Rawness::RawPtr {
// FIXME: record type error - expected reference but found ptr,
// which cannot be coerced
}
@ -701,8 +712,12 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
}
}
Expr::Tuple { exprs } => {
let mut tys = match self.resolve_ty_shallow(&expected.ty).kind(&Interner) {
TyKind::Tuple(_, substs) => substs
let mut tys = match expected
.only_has_type(&mut self.table)
.as_ref()
.map(|t| t.kind(&Interner))
{
Some(TyKind::Tuple(_, substs)) => substs
.iter(&Interner)
.map(|a| a.assert_ty_ref(&Interner).clone())
.chain(repeat_with(|| self.table.new_type_var()))
@ -718,14 +733,16 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
TyKind::Tuple(tys.len(), Substitution::from_iter(&Interner, tys)).intern(&Interner)
}
Expr::Array(array) => {
let elem_ty = match self.resolve_ty_shallow(&expected.ty).kind(&Interner) {
TyKind::Array(st, _) | TyKind::Slice(st) => st.clone(),
_ => self.table.new_type_var(),
};
let elem_ty =
match expected.to_option(&mut self.table).as_ref().map(|t| t.kind(&Interner)) {
Some(TyKind::Array(st, _)) | Some(TyKind::Slice(st)) => st.clone(),
_ => self.table.new_type_var(),
};
let len = match array {
Array::ElementList(items) => {
for expr in items.iter() {
// FIXME: use CoerceMany (coerce_merge_branch)
self.infer_expr_coerce(*expr, &Expectation::has_type(elem_ty.clone()));
}
Some(items.len() as u64)
@ -839,7 +856,9 @@ fn infer_block(
// we don't even make an attempt at coercion
self.table.new_maybe_never_var()
} else {
self.coerce(&TyBuilder::unit(), &expected.coercion_target());
if let Some(t) = expected.only_has_type(&mut self.table) {
self.coerce(&TyBuilder::unit(), &t);
}
TyBuilder::unit()
}
};