autoderef, could_unify,
method_resolution::{self, TyFingerprint},
primitive::UintTy,
- to_assoc_type_id,
- traits::{FnTrait, Solution, SolutionVariables},
+ traits::FnTrait,
AliasEq, AliasTy, BoundVar, CallableDefId, CallableSig, Canonical, CanonicalVarKinds, Cast,
- DebruijnIndex, InEnvironment, Interner, ProjectionTy, QuantifiedWhereClause, Scalar,
- Substitution, TraitEnvironment, Ty, TyDefId, TyKind, TyVariableKind, WhereClause,
+ DebruijnIndex, InEnvironment, Interner, QuantifiedWhereClause, Scalar, Solution,
+ SolutionVariables, Substitution, TraitEnvironment, Ty, TyBuilder, TyDefId, TyKind,
+ TyVariableKind, WhereClause,
};
use itertools::Itertools;
use rustc_hash::FxHashSet;
VariantDef::Union(it) => it.id.into(),
VariantDef::Variant(it) => it.parent.id.into(),
};
- let substs = Substitution::type_params(db, generic_def_id);
+ let substs = TyBuilder::type_params_subst(db, generic_def_id);
let ty = db.field_types(var_id)[self.id].clone().subst(&substs);
Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
}
}
pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
- if !db.function_data(self.id).has_self_param {
+ if !db.function_data(self.id).has_self_param() {
return None;
}
Some(SelfParam { func: self.id })
}
pub fn is_unsafe(self, db: &dyn HirDatabase) -> bool {
- db.function_data(self.id).qualifier.is_unsafe
+ db.function_data(self.id).is_unsafe()
}
pub fn diagnostics(self, db: &dyn HirDatabase, sink: &mut DiagnosticSink) {
///
/// This is false in the case of required (not provided) trait methods.
pub fn has_body(self, db: &dyn HirDatabase) -> bool {
- db.function_data(self.id).has_body
+ db.function_data(self.id).has_body()
}
/// A textual representation of the HIR of this function for debugging purposes.
func_data
.params
.first()
- .map(|param| match *param {
+ .map(|param| match &**param {
TypeRef::Reference(.., mutability) => match mutability {
hir_def::type_ref::Mutability::Shared => Access::Shared,
hir_def::type_ref::Mutability::Mut => Access::Exclusive,
}
pub fn type_ref(self, db: &dyn HirDatabase) -> TypeRef {
- db.const_data(self.id).type_ref.clone()
+ db.const_data(self.id).type_ref.as_ref().clone()
}
}
}
pub fn type_ref(self, db: &dyn HirDatabase) -> Option<TypeRef> {
- db.type_alias_data(self.id).type_ref.clone()
+ db.type_alias_data(self.id).type_ref.as_deref().cloned()
}
pub fn ty(self, db: &dyn HirDatabase) -> Type {
impl BuiltinType {
pub fn ty(self, db: &dyn HirDatabase, module: Module) -> Type {
let resolver = module.id.resolver(db.upcast());
- Type::new_with_resolver(db, &resolver, Ty::builtin(self.inner))
+ Type::new_with_resolver(db, &resolver, TyBuilder::builtin(self.inner))
.expect("crate not present in resolver")
}
let resolver = self.id.parent.resolver(db.upcast());
let krate = self.id.parent.module(db.upcast()).krate();
let ty = params.get(local_idx)?.clone();
- let subst = Substitution::type_params(db, self.id.parent);
+ let subst = TyBuilder::type_params_subst(db, self.id.parent);
let ty = ty.subst(&subst.prefix(local_idx));
Some(Type::new_with_resolver_inner(db, krate, &resolver, ty))
}
// FIXME: the return type is wrong. This should be a hir version of
// `TraitRef` (ie, resolved `TypeRef`).
pub fn trait_(self, db: &dyn HirDatabase) -> Option<TraitRef> {
- db.impl_data(self.id).target_trait.clone()
+ db.impl_data(self.id).target_trait.as_deref().cloned()
}
pub fn self_ty(self, db: &dyn HirDatabase) -> Type {
fn from_def(
db: &dyn HirDatabase,
krate: CrateId,
- def: impl HasResolver + Into<TyDefId> + Into<GenericDefId>,
+ def: impl HasResolver + Into<TyDefId>,
) -> Type {
- let substs = Substitution::build_for_def(db, def).fill_with_unknown().build();
- let ty = db.ty(def.into()).subst(&substs);
+ let ty = TyBuilder::def_ty(db, def.into()).fill_with_unknown().build();
Type::new(db, krate, def, ty)
}
pub fn is_unit(&self) -> bool {
- matches!(self.ty.interned(&Interner), TyKind::Tuple(0, ..))
+ matches!(self.ty.kind(&Interner), TyKind::Tuple(0, ..))
}
pub fn is_bool(&self) -> bool {
- matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Bool))
+ matches!(self.ty.kind(&Interner), TyKind::Scalar(Scalar::Bool))
}
pub fn is_mutable_reference(&self) -> bool {
- matches!(self.ty.interned(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
+ matches!(self.ty.kind(&Interner), TyKind::Ref(hir_ty::Mutability::Mut, ..))
}
pub fn is_usize(&self) -> bool {
- matches!(self.ty.interned(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
+ matches!(self.ty.kind(&Interner), TyKind::Scalar(Scalar::Uint(UintTy::Usize)))
}
pub fn remove_ref(&self) -> Option<Type> {
- match &self.ty.interned(&Interner) {
+ match &self.ty.kind(&Interner) {
TyKind::Ref(.., ty) => Some(self.derived(ty.clone())),
_ => None,
}
}
pub fn impls_trait(&self, db: &dyn HirDatabase, trait_: Trait, args: &[Type]) -> bool {
- let trait_ref = hir_ty::TraitRef {
- trait_id: hir_ty::to_chalk_trait_id(trait_.id),
- substitution: Substitution::build_for_def(db, trait_.id)
- .push(self.ty.clone())
- .fill(args.iter().map(|t| t.ty.clone()))
- .build(),
- };
+ let trait_ref = TyBuilder::trait_ref(db, trait_.id)
+ .push(self.ty.clone())
+ .fill(args.iter().map(|t| t.ty.clone()))
+ .build();
let goal = Canonical {
value: hir_ty::InEnvironment::new(self.env.env.clone(), trait_ref.cast(&Interner)),
pub fn normalize_trait_assoc_type(
&self,
db: &dyn HirDatabase,
- trait_: Trait,
args: &[Type],
alias: TypeAlias,
) -> Option<Type> {
- let subst = Substitution::build_for_def(db, trait_.id)
+ let projection = TyBuilder::assoc_type_projection(db, alias.id)
.push(self.ty.clone())
.fill(args.iter().map(|t| t.ty.clone()))
.build();
InEnvironment::new(
self.env.env.clone(),
AliasEq {
- alias: AliasTy::Projection(ProjectionTy {
- associated_ty_id: to_assoc_type_id(alias.id),
- substitution: subst,
- }),
+ alias: AliasTy::Projection(projection),
ty: TyKind::BoundVar(BoundVar::new(DebruijnIndex::INNERMOST, 0))
.intern(&Interner),
}
);
match db.trait_solve(self.krate, goal)? {
- Solution::Unique(SolutionVariables(subst)) => {
- subst.value.first().map(|ty| self.derived(ty.clone()))
- }
+ Solution::Unique(SolutionVariables(subst)) => subst
+ .value
+ .interned()
+ .first()
+ .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone())),
Solution::Ambig(_) => None,
}
}
}
pub fn is_closure(&self) -> bool {
- matches!(&self.ty.interned(&Interner), TyKind::Closure { .. })
+ matches!(&self.ty.kind(&Interner), TyKind::Closure { .. })
}
pub fn is_fn(&self) -> bool {
- matches!(&self.ty.interned(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
+ matches!(&self.ty.kind(&Interner), TyKind::FnDef(..) | TyKind::Function { .. })
}
pub fn is_packed(&self, db: &dyn HirDatabase) -> bool {
- let adt_id = match self.ty.interned(&Interner) {
+ let adt_id = match self.ty.kind(&Interner) {
&TyKind::Adt(hir_ty::AdtId(adt_id), ..) => adt_id,
_ => return false,
};
}
pub fn is_raw_ptr(&self) -> bool {
- matches!(&self.ty.interned(&Interner), TyKind::Raw(..))
+ matches!(&self.ty.kind(&Interner), TyKind::Raw(..))
}
pub fn contains_unknown(&self) -> bool {
return go(&self.ty);
fn go(ty: &Ty) -> bool {
- match ty.interned(&Interner) {
- TyKind::Unknown => true,
+ match ty.kind(&Interner) {
+ TyKind::Error => true,
TyKind::Adt(_, substs)
| TyKind::AssociatedType(_, substs)
| TyKind::Tuple(_, substs)
| TyKind::OpaqueType(_, substs)
| TyKind::FnDef(_, substs)
- | TyKind::Closure(_, substs) => substs.iter().any(go),
+ | TyKind::Closure(_, substs) => {
+ substs.iter(&Interner).filter_map(|a| a.ty(&Interner)).any(go)
+ }
TyKind::Array(ty) | TyKind::Slice(ty) | TyKind::Raw(_, ty) | TyKind::Ref(_, ty) => {
go(ty)
| TyKind::Dyn(_)
| TyKind::Function(_)
| TyKind::Alias(_)
- | TyKind::ForeignType(_) => false,
+ | TyKind::Foreign(_) => false,
}
}
}
pub fn fields(&self, db: &dyn HirDatabase) -> Vec<(Field, Type)> {
- let (variant_id, substs) = match self.ty.interned(&Interner) {
+ let (variant_id, substs) = match self.ty.kind(&Interner) {
&TyKind::Adt(hir_ty::AdtId(AdtId::StructId(s)), ref substs) => (s.into(), substs),
&TyKind::Adt(hir_ty::AdtId(AdtId::UnionId(u)), ref substs) => (u.into(), substs),
_ => return Vec::new(),
}
pub fn tuple_fields(&self, _db: &dyn HirDatabase) -> Vec<Type> {
- if let TyKind::Tuple(_, substs) = &self.ty.interned(&Interner) {
- substs.iter().map(|ty| self.derived(ty.clone())).collect()
+ if let TyKind::Tuple(_, substs) = &self.ty.kind(&Interner) {
+ substs
+ .iter(&Interner)
+ .map(|ty| self.derived(ty.assert_ty_ref(&Interner).clone()))
+ .collect()
} else {
Vec::new()
}
.strip_references()
.substs()
.into_iter()
- .flat_map(|substs| substs.iter())
- .map(move |ty| self.derived(ty.clone()))
+ .flat_map(|substs| substs.iter(&Interner))
+ .filter_map(|arg| arg.ty(&Interner).cloned())
+ .map(move |ty| self.derived(ty))
}
pub fn iterate_method_candidates<T>(
substs: &Substitution,
cb: &mut impl FnMut(Type),
) {
- for ty in substs.iter() {
+ for ty in substs.iter(&Interner).filter_map(|a| a.ty(&Interner)) {
walk_type(db, &type_.derived(ty.clone()), cb);
}
}
WhereClause::Implemented(trait_ref) => {
cb(type_.clone());
// skip the self type. it's likely the type we just got the bounds from
- for ty in trait_ref.substitution.iter().skip(1) {
+ for ty in trait_ref
+ .substitution
+ .iter(&Interner)
+ .skip(1)
+ .filter_map(|a| a.ty(&Interner))
+ {
walk_type(db, &type_.derived(ty.clone()), cb);
}
}
fn walk_type(db: &dyn HirDatabase, type_: &Type, cb: &mut impl FnMut(Type)) {
let ty = type_.ty.strip_references();
- match ty.interned(&Interner) {
+ match ty.kind(&Interner) {
TyKind::Adt(..) => {
cb(type_.derived(ty.clone()));
}
projects / rust.git / blobdiff