--- /dev/null
+//! Various extensions traits for Chalk types.
+
+use crate::{Interner, Ty, TyKind};
+
+pub trait TyExt {
+ fn is_unit(&self) -> bool;
+}
+
+impl TyExt for Ty {
+ fn is_unit(&self) -> bool {
+ matches!(self.kind(&Interner), TyKind::Tuple(0, _))
+ }
+}
MissingPatFields, RemoveThisSemicolon,
},
utils::variant_data,
- AdtId, InferenceResult, Interner, Ty, TyKind,
+ AdtId, InferenceResult, Interner, TyExt, TyKind,
};
pub(crate) use hir_def::{
None => return,
};
- if mismatch.actual != Ty::unit() || mismatch.expected != *possible_tail_ty {
+ if !mismatch.actual.is_unit() || mismatch.expected != *possible_tail_ty {
return;
}
db::HirDatabase, from_assoc_type_id, from_foreign_def_id, from_placeholder_idx, primitive,
to_assoc_type_id, traits::chalk::from_chalk, utils::generics, AdtId, AliasEq, AliasTy,
CallableDefId, CallableSig, DomainGoal, GenericArg, ImplTraitId, Interner, Lifetime, OpaqueTy,
- ProjectionTy, QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TyKind, WhereClause,
+ ProjectionTy, QuantifiedWhereClause, Scalar, Substitution, TraitRef, Ty, TyExt, TyKind,
+ WhereClause,
};
pub struct HirFormatter<'a> {
f.write_joined(sig.params(), ", ")?;
write!(f, ")")?;
let ret = sig.ret();
- if *ret != Ty::unit() {
+ if !ret.is_unit() {
let ret_display = ret.into_displayable(
f.db,
f.max_size,
}
write!(f, ")")?;
let ret = self.ret();
- if *ret != Ty::unit() {
+ if !ret.is_unit() {
let ret_display =
ret.into_displayable(f.db, f.max_size, f.omit_verbose_types, f.display_target);
write!(f, " -> {}", ret_display)?;
traits::{chalk::from_chalk, FnTrait, InEnvironment},
utils::{generics, variant_data, Generics},
AdtId, Binders, CallableDefId, DomainGoal, FnPointer, FnSig, Interner, Rawness, Scalar,
- Substitution, TraitRef, Ty, TyKind,
+ Substitution, TraitRef, Ty, TyBuilder, TyKind,
};
use super::{
both_arms_diverge &= mem::replace(&mut self.diverges, Diverges::Maybe);
let else_ty = match else_branch {
Some(else_branch) => self.infer_expr_inner(*else_branch, &expected),
- None => Ty::unit(),
+ None => TyBuilder::unit(),
};
both_arms_diverge &= self.diverges;
break_ty: self.table.new_type_var(),
label: label.map(|label| self.body[label].name.clone()),
});
- self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+ self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit()));
let ctxt = self.breakables.pop().expect("breakable stack broken");
if ctxt.may_break {
*condition,
&Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(&Interner)),
);
- self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+ self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit()));
let _ctxt = self.breakables.pop().expect("breakable stack broken");
// the body may not run, so it diverging doesn't mean we diverge
self.diverges = Diverges::Maybe;
- Ty::unit()
+ TyBuilder::unit()
}
Expr::For { iterable, body, pat, label } => {
let iterable_ty = self.infer_expr(*iterable, &Expectation::none());
self.infer_pat(*pat, &pat_ty, BindingMode::default());
- self.infer_expr(*body, &Expectation::has_type(Ty::unit()));
+ self.infer_expr(*body, &Expectation::has_type(TyBuilder::unit()));
let _ctxt = self.breakables.pop().expect("breakable stack broken");
// the body may not run, so it diverging doesn't mean we diverge
self.diverges = Diverges::Maybe;
- Ty::unit()
+ TyBuilder::unit()
}
Expr::Lambda { body, args, ret_type, arg_types } => {
assert_eq!(args.len(), arg_types.len());
let val_ty = if let Some(expr) = expr {
self.infer_expr(*expr, &Expectation::none())
} else {
- Ty::unit()
+ TyBuilder::unit()
};
let last_ty =
if let Some(expr) = expr {
self.infer_expr_coerce(*expr, &Expectation::has_type(self.return_ty.clone()));
} else {
- let unit = Ty::unit();
+ let unit = TyBuilder::unit();
self.coerce(&unit, &self.return_ty.clone());
}
TyKind::Never.intern(&Interner)
// we don't even make an attempt at coercion
self.table.new_maybe_never_var()
} else {
- self.coerce(&Ty::unit(), &expected.coercion_target());
- Ty::unit()
+ self.coerce(&TyBuilder::unit(), &expected.coercion_target());
+ TyBuilder::unit()
}
};
ty
mod tests;
#[cfg(test)]
mod test_db;
+mod chalk_ext;
use std::{iter, mem, sync::Arc};
};
pub use autoderef::autoderef;
+pub use chalk_ext::TyExt;
pub use infer::{could_unify, InferenceResult, InferenceVar};
pub use lower::{
associated_type_shorthand_candidates, callable_item_sig, CallableDefId, ImplTraitLoweringMode,
struct TyBuilder {}
impl TyBuilder {
-
-}
-
-impl Ty {
- pub fn unit() -> Self {
+ pub fn unit() -> Ty {
TyKind::Tuple(0, Substitution::empty(&Interner)).intern(&Interner)
}
+}
+impl Ty {
pub fn adt_ty(adt: hir_def::AdtId, substs: Substitution) -> Ty {
TyKind::Adt(AdtId(adt), substs).intern(&Interner)
}
use chalk_ir::TyVariableKind;
use hir_def::expr::{ArithOp, BinaryOp, CmpOp};
-use crate::{Interner, Scalar, Ty, TyKind};
+use crate::{Interner, Scalar, Ty, TyBuilder, TyKind};
pub(super) fn binary_op_return_ty(op: BinaryOp, lhs_ty: Ty, rhs_ty: Ty) -> Ty {
match op {
BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => TyKind::Scalar(Scalar::Bool).intern(&Interner),
- BinaryOp::Assignment { .. } => Ty::unit(),
+ BinaryOp::Assignment { .. } => TyBuilder::unit(),
BinaryOp::ArithOp(ArithOp::Shl) | BinaryOp::ArithOp(ArithOp::Shr) => {
match lhs_ty.kind(&Interner) {
TyKind::Scalar(Scalar::Int(_))
to_assoc_type_id, to_chalk_trait_id,
utils::generics,
AliasEq, AliasTy, BoundVar, CallableDefId, DebruijnIndex, FnDefId, ProjectionTy, Substitution,
- TraitRef, Ty, TyKind, WhereClause,
+ TraitRef, Ty, TyBuilder, TyKind, WhereClause,
};
use mapping::{
convert_where_clauses, generic_predicate_to_inline_bound, make_binders, TypeAliasAsValue,
_closure_id: chalk_ir::ClosureId<Interner>,
_substs: &chalk_ir::Substitution<Interner>,
) -> chalk_ir::Binders<chalk_ir::Ty<Interner>> {
- let ty = Ty::unit().to_chalk(self.db);
+ let ty = TyBuilder::unit().to_chalk(self.db);
make_binders(ty, 0)
}
fn closure_fn_substitution(