+ TraitEnvironment, TyDefId, TyLoweringDiagnostic, ValueTyDefId, all_super_traits, autoderef,

+ check_orphan_rules,

+ consteval::try_const_usize,

+ db::InternedClosureId,

+ direct_super_traits, known_const_to_ast,

+ AliasTy, Canonical, ClauseKind, ConstKind, DbInterner, ErrorGuaranteed, GenericArg,

+ GenericArgs, PolyFnSig, Region, SolverDefId, Ty, TyKind, TypingMode,

+ traits::{self, FnTrait, structurally_normalize_ty},

+use rustc_type_ir::{

+ AliasTyKind, TypeSuperVisitable, TypeVisitable, TypeVisitor,

+ inherent::{AdtDef, IntoKind, SliceLike, Term as _, Ty as _},

+};

+use stdx::{format_to, impl_from, never};

+ // FIXME: Properly encapsulate mir

+ hir_ty::mir,

+ let interner = DbInterner::new_with(db, Some(self.id.krate()), self.id.containing_block());

+ let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

+

+ let self_ty = db.impl_self_ty(impl_def.id).instantiate_identity();

+ let self_ty = structurally_normalize_ty(

+ &infcx,

+ self_ty,

+ db.trait_environment(impl_def.id.into()),

+ );

+ self_ty.kind(),

+ TyKind::Dynamic(..) | TyKind::Slice(..) | TyKind::Str

+ .as_slice()

+ .copied()

+ .unwrap_or_else(|| Ty::new_error(interner, ErrorGuaranteed));

+ Type { env: db.trait_environment_for_body(self.owner), ty }

+ let interner = DbInterner::new_with(db, None, None);

+ let args = generic_args_from_tys(interner, def_id.into(), generics.map(|ty| ty.ty));

+ let ty = db.field_types_ns(var_id)[self.id].instantiate(interner, args);

+ pub fn ty_params(self, db: &dyn HirDatabase) -> Type<'_> {

+ Type::from_def_params(db, self.id)

+ pub fn ty_params(self, db: &dyn HirDatabase) -> Type<'_> {

+ Type::from_def_params(db, self.id)

+ pub fn ty_params<'db>(self, db: &'db dyn HirDatabase) -> Type<'db> {

+ Type::from_def_params(db, self.id)

+ let interner = DbInterner::new_with(db, None, None);

+ match db.enum_signature(self.id).variant_body_type() {

+ true => Ty::new_int(interner, rustc_type_ir::IntTy::Isize),

+ false => Ty::new_uint(interner, rustc_type_ir::UintTy::Usize),

+ true => Ty::new_int(

+ interner,

+ match i {

+ layout::Integer::I8 => rustc_type_ir::IntTy::I8,

+ layout::Integer::I16 => rustc_type_ir::IntTy::I16,

+ layout::Integer::I32 => rustc_type_ir::IntTy::I32,

+ layout::Integer::I64 => rustc_type_ir::IntTy::I64,

+ layout::Integer::I128 => rustc_type_ir::IntTy::I128,

+ },

+ ),

+ false => Ty::new_uint(

+ interner,

+ match i {

+ layout::Integer::I8 => rustc_type_ir::UintTy::U8,

+ layout::Integer::I16 => rustc_type_ir::UintTy::U16,

+ layout::Integer::I32 => rustc_type_ir::UintTy::U32,

+ layout::Integer::I64 => rustc_type_ir::UintTy::U64,

+ layout::Integer::I128 => rustc_type_ir::UintTy::U128,

+ },

+ ),

+ },

+ has_non_default_type_params(db, self.into())

+ let adt_id = AdtId::from(self);

+ let args = GenericArgs::for_item_with_defaults(interner, adt_id.into(), |_, _, id, _| {

+ GenericArg::error_from_id(interner, id)

+ });

+ db.layout_of_adt(adt_id, args, env)

+ .map(|layout| Layout(layout, db.target_data_layout(self.krate(db).id).unwrap()))

+ let interner = DbInterner::new_with(db, None, None);

+ let ty = Ty::new_adt(

+ interner,

+ id,

+ generic_args_from_tys(interner, id.into(), args.into_iter().map(|ty| ty.ty)),

+ );

+ expected: Type::new(db, DefWithBodyId::from(self), mismatch.expected),

+ actual: Type::new(db, DefWithBodyId::from(self), mismatch.actual),

+ acc.push(MovedOutOfRef { ty: Type::new_for_crate(krate, moof.ty), span }.into())

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ let callable_sig = db.callable_item_signature(self.id.into()).instantiate_identity();

+ let ty = Ty::new_fn_ptr(interner, callable_sig);

+ // FIXME: Find a better API to express all combinations here, perhaps we should have `PreInstantiationType`?

+

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ .instantiate_identity()

+ .output();

+ let interner = DbInterner::new_with(db, None, None);

+ let args = generic_args_from_tys(interner, self.id.into(), generics.map(|ty| ty.ty));

+ .output();

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ .instantiate_identity()

+ .output();

+ if let ClauseKind::Projection(projection) = pred.kind().skip_binder()

+ && let Some(output_ty) = projection.term.as_type()

+ {

+ return Type::new_with_resolver_inner(db, &resolver, output_ty).into();

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ let callable_sig =

+ db.callable_item_signature(self.id.into()).instantiate_identity().skip_binder();

+ .inputs()

+ let ty = Type { env: environment.clone(), ty };

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ let callable_sig =

+ db.callable_item_signature(self.id.into()).instantiate_identity().skip_binder();

+ .inputs()

+ let ty = Type { env: environment.clone(), ty };

+ let args = generic_args_from_tys(interner, self.id.into(), generics.map(|ty| ty.ty));

+ let callable_sig =

+ db.callable_item_signature(self.id.into()).instantiate(interner, args).skip_binder();

+ .inputs()

+ let ty = Type { env: environment.clone(), ty };

+impl From<hir_ty::next_solver::Mutability> for Access {

+ fn from(mutability: hir_ty::next_solver::Mutability) -> Access {

+ hir_ty::next_solver::Mutability::Not => Access::Shared,

+ hir_ty::next_solver::Mutability::Mut => Access::Exclusive,

+ func: Callee<'db>,

+ let c = db.lookup_intern_closure(closure);

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ let callable_sig =

+ db.callable_item_signature(self.func.into()).instantiate_identity().skip_binder();

+ let ty = callable_sig.inputs().as_slice()[0];

+ Type { env: environment, ty }

+ let args = generic_args_from_tys(interner, self.func.into(), generics.map(|ty| ty.ty));

+ let callable_sig =

+ db.callable_item_signature(self.func.into()).instantiate(interner, args).skip_binder();

+ let ty = callable_sig.inputs().as_slice()[0];

+ Type { env: environment, ty }

+ pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {

+ let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity();

+ .map(|it| EvaluatedConst { const_: it, def: self.id.into(), ty })

+pub struct EvaluatedConst<'db> {

+ const_: hir_ty::next_solver::Const<'db>,

+ ty: Ty<'db>,

+impl<'db> EvaluatedConst<'db> {

+ pub fn render_debug(&self, db: &'db dyn HirDatabase) -> Result<String, MirEvalError<'db>> {

+ let kind = self.const_.kind();

+ if let ConstKind::Value(c) = kind

+ && let ty = c.ty.kind()

+ && let TyKind::Int(_) | TyKind::Uint(_) = ty

+ let b = &c.value.inner().memory;

+ let value_signed = i128::from_le_bytes(mir::pad16(b, matches!(ty, TyKind::Int(_))));

+ if let TyKind::Int(_) = ty { value_signed.to_string() } else { value.to_string() };

+ mir::render_const_using_debug_impl(db, self.def, self.const_, self.ty)

+ pub fn eval(self, db: &dyn HirDatabase) -> Result<EvaluatedConst<'_>, ConstEvalError<'_>> {

+ let ty = db.value_ty(self.id.into()).unwrap().instantiate_identity();

+ .map(|it| EvaluatedConst { const_: it, def: self.id.into(), ty })

+ has_non_default_type_params(db, self.id.into())

+ pub fn ty_params(self, db: &dyn HirDatabase) -> Type<'_> {

+ Type::from_def_params(db, self.id)

+ let interner = DbInterner::new_with(db, None, None);

+ Type::new_for_crate(core, Ty::from_builtin_type(interner, self.inner))

+ subst: GenericArgs<'db>,

+ fn new(def: GenericDefId, subst: GenericArgs<'db>, env: Arc<TraitEnvironment<'db>>) -> Self {

+ Self { def, subst, env }

+ let parent_len = self.subst.len()

+ let container_params = self.subst.as_slice()[..parent_len]

+ .filter_map(|param| param.ty())

+ let self_params = self.subst.as_slice()[parent_len..]

+ .filter_map(|param| param.ty())

+ Some((name?.symbol().clone(), Type { ty, env: self.env.clone() }))

+ Type::new(db, def, ty)

+ let interner = DbInterner::new_with(db, None, None);

+ let index = hir_ty::param_idx(db, self.id.into()).unwrap();

+ let name = self.name(db).symbol().clone();

+ let ty = Ty::new_param(interner, self.id, index as u32, name);

+ match ty {

+ GenericArg::Ty(it) if !it.is_ty_error() => {

+ Some(Type::new_with_resolver_inner(db, &resolver, it))

+ Type::new(db, self.id.parent(), db.const_param_ty_ns(self.id))

+ known_const_to_ast(arg.konst()?, db, display_target)

+fn generic_arg_from_param(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<GenericArg<'_>> {

+ let defaults = db.generic_defaults_ns(id.parent);

+ let ty = defaults.get(local_idx)?;

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ Some(ty.instantiate_identity())

+ pub fn all_for_type<'db>(db: &'db dyn HirDatabase, Type { ty, env }: Type<'db>) -> Vec<Impl> {

+ let def_crates = match method_resolution::def_crates(db, ty, env.krate) {

+ ty.equals_ctor(rref.as_ref().map_or(self_ty.ty, |it| it.ty))

+ let fp = TyFingerprint::for_inherent_impl(ty);

+ .for_self_ty(ty)

+ if let Some(block) = ty.as_adt().and_then(|(def, _)| def.module(db).containing_block()) {

+ inherent_impls.for_self_ty(ty).iter().cloned().map(Self::from).filter(filter),

+ // FIXME: This shouldn't be `instantiate_identity()`, we shouldn't leak `TyKind::Param`s.

+ let ty = db.impl_self_ty(self.id).instantiate_identity();

+ TraitRef { env, trait_ref }

+ TypeNs { env: self.env.clone(), ty }

+ self.trait_ref

+ .args

+ .as_slice()

+ .get(idx)

+ .and_then(|arg| arg.ty())

+ .map(|ty| TypeNs { env: self.env.clone(), ty })

+pub struct Closure<'db> {

+ id: InternedClosureId,

+ subst: GenericArgs<'db>,

+impl<'db> Closure<'db> {

+ fn as_ty(&self, db: &'db dyn HirDatabase) -> Ty<'db> {

+ let interner = DbInterner::new_with(db, None, None);

+ Ty::new_closure(interner, self.id.into(), self.subst)

+ self.as_ty(db)

+ self.as_ty(db)

+ pub fn captured_items(&self, db: &'db dyn HirDatabase) -> Vec<ClosureCapture<'db>> {

+ let owner = db.lookup_intern_closure(self.id).0;

+ let infer = db.infer(owner);

+ let info = infer.closure_info(self.id);

+ pub fn capture_types(&self, db: &'db dyn HirDatabase) -> Vec<Type<'db>> {

+ let owner = db.lookup_intern_closure(self.id).0;

+ let infer = db.infer(owner);

+ let (captures, _) = infer.closure_info(self.id);

+ let env = db.trait_environment_for_body(owner);

+ .map(|capture| Type { env: env.clone(), ty: capture.ty(db, self.subst) })

+ let owner = db.lookup_intern_closure(self.id).0;

+ let infer = db.infer(owner);

+ let info = infer.closure_info(self.id);

+ closure: InternedClosureId,

+ ty: Ty<'db>,

+ ty: Ty<'db>,

+ ty: Ty<'db>,

+ Type { env: environment, ty }

+ pub(crate) fn new_for_crate(krate: base_db::Crate, ty: Ty<'db>) -> Self {

+ Type { env: TraitEnvironment::empty(krate), ty }

+ fn new(db: &'db dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty<'db>) -> Self {

+ Type { env: environment, ty }

+ let def = match def.into() {

+ TyDefId::AdtId(it) => GenericDefId::AdtId(it),

+ TyDefId::TypeAliasId(it) => GenericDefId::TypeAliasId(it),

+ TyDefId::BuiltinType(_) => {

+ return Type::new(db, def, ty.skip_binder());

+ }

+ };

+ let args = GenericArgs::error_for_item(interner, def.into());

+ Type::new(db, def, ty.instantiate(interner, args))

+ // FIXME: We shouldn't leak `TyKind::Param`s.

+ fn from_def_params(db: &'db dyn HirDatabase, def: impl Into<TyDefId> + HasResolver) -> Self {

+ Type::new(db, def, ty.instantiate_identity())

+ let interner = DbInterner::new_with(db, None, None);

+ return Type::new(db, def, Ty::new_error(interner, ErrorGuaranteed));

+ let def = match def.into() {

+ ValueTyDefId::ConstId(it) => GenericDefId::ConstId(it),

+ ValueTyDefId::FunctionId(it) => GenericDefId::FunctionId(it),

+ ValueTyDefId::StructId(it) => GenericDefId::AdtId(AdtId::StructId(it)),

+ ValueTyDefId::UnionId(it) => GenericDefId::AdtId(AdtId::UnionId(it)),

+ ValueTyDefId::EnumVariantId(it) => {

+ GenericDefId::AdtId(AdtId::EnumId(it.lookup(db).parent))

+ }

+ ValueTyDefId::StaticId(_) => {

+ return Type::new(db, def, ty.skip_binder());

+ }

+ };

+ let args = GenericArgs::error_for_item(interner, def.into());

+ Type::new(db, def, ty.instantiate(interner, args))

+ let interner = DbInterner::conjure();

+ Type { env: ty.env, ty: Ty::new_slice(interner, ty.ty) }

+ let tys = tys.iter().map(|it| it.ty);

+ let interner = DbInterner::conjure();

+ Type { env: TraitEnvironment::empty(krate), ty: Ty::new_tup_from_iter(interner, tys) }

+ self.ty.is_unit()

+ matches!(self.ty.kind(), TyKind::Bool)

+ matches!(self.ty.kind(), TyKind::Str)

+ matches!(self.ty.kind(), TyKind::Never)

+ matches!(self.ty.kind(), TyKind::Ref(.., hir_ty::next_solver::Mutability::Mut))

+ matches!(self.ty.kind(), TyKind::Ref(..))

+ let interner = DbInterner::new_with(db, None, None);

+ return self.ty.visit_with(&mut Visitor { interner }).is_break();

+ AdtId::StructId(s) => {

+ AdtId::UnionId(_) | AdtId::EnumId(_) => false,

+ struct Visitor<'db> {

+ interner: DbInterner<'db>,

+ }

+ impl<'db> TypeVisitor<DbInterner<'db>> for Visitor<'db> {

+ type Result = ControlFlow<()>;

+ fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {

+ match ty.kind() {

+ // Reference itself

+ TyKind::Ref(..) => ControlFlow::Break(()),

+ // For non-phantom_data adts we check variants/fields as well as generic parameters

+ TyKind::Adt(adt_def, args)

+ if !is_phantom_data(self.interner.db(), adt_def.def_id().0) =>

+ {

+ let _variant_id_to_fields = |id: VariantId| {

+ let variant_data = &id.fields(self.interner.db());

+ if variant_data.fields().is_empty() {

+ vec![]

+ } else {

+ let field_types = self.interner.db().field_types_ns(id);

+ variant_data

+ .fields()

+ .iter()

+ .map(|(idx, _)| {

+ field_types[idx].instantiate(self.interner, args)

+ })

+ .filter(|it| !it.references_non_lt_error())

+ .collect()

+ }

+ };

+ let variant_id_to_fields = |_: VariantId| vec![];

+ let variants: Vec<Vec<Ty<'db>>> = match adt_def.def_id().0 {

+ AdtId::StructId(id) => {

+ vec![variant_id_to_fields(id.into())]

+ }

+ AdtId::EnumId(id) => id

+ .enum_variants(self.interner.db())

+ .variants

+ .iter()

+ .map(|&(variant_id, _, _)| variant_id_to_fields(variant_id.into()))

+ .collect(),

+ AdtId::UnionId(id) => {

+ vec![variant_id_to_fields(id.into())]

+ }

+ };

+ variants

+ .into_iter()

+ .flat_map(|variant| variant.into_iter())

+ .try_for_each(|ty| ty.visit_with(self))?;

+ args.visit_with(self)

+ }

+ // And for `PhantomData<T>`, we check `T`.

+ _ => ty.super_visit_with(self),

+ }

+ let TyKind::Ref(_lt, ty, m) = self.ty.kind() else { return None };

+ let m = Mutability::from_mutable(matches!(m, hir_ty::next_solver::Mutability::Mut));

+ Some((self.derived(ty), m))

+ let interner = DbInterner::conjure();

+ Mutability::Shared => hir_ty::next_solver::Mutability::Not,

+ Mutability::Mut => hir_ty::next_solver::Mutability::Mut,

+ self.derived(Ty::new_ref(interner, Region::error(interner), self.ty, ty_mutability))

+ matches!(self.ty.kind(), TyKind::Slice(..))

+ matches!(self.ty.kind(), TyKind::Uint(rustc_type_ir::UintTy::Usize))

+ matches!(self.ty.kind(), TyKind::Float(_))

+ matches!(self.ty.kind(), TyKind::Char)

+ matches!(self.ty.kind(), TyKind::Int(_) | TyKind::Uint(_))

+ matches!(

+ self.ty.kind(),

+ TyKind::Bool | TyKind::Char | TyKind::Int(_) | TyKind::Uint(_) | TyKind::Float(_)

+ )

+ matches!(self.ty.kind(), TyKind::Tuple(..))

+ match self.ty.kind() {

+ TyKind::Ref(_, ty, _) => Some(self.derived(ty)),

+ match self.ty.kind() {

+ TyKind::Slice(ty) => Some(self.derived(ty)),

+ self.derived(self.ty.strip_references())

+ // FIXME: This is the same as `remove_ref()`, remove one of these methods.

+ self.derived(self.ty.strip_reference())

+ self.ty.is_ty_error()

+ if !traits::implements_trait_unique(self.ty, db, self.env.clone(), trait_) {

+ traits::implements_trait_unique(self.ty, db, self.env.clone(), iterator_trait)

+ if !traits::implements_trait_unique(self.ty, db, self.env.clone(), trait_) {

+ traits::implements_trait_unique(self.ty, db, self.env.clone(), fnonce_trait)

+ let interner = DbInterner::new_with(db, None, None);

+ let args = generic_args_from_tys(

+ interner,

+ trait_.id.into(),

+ std::iter::once(self.ty).chain(args.iter().map(|ty| ty.ty)),

+ );

+ traits::implements_trait_unique_with_args(db, self.env.clone(), trait_.id, args)

+ let interner = DbInterner::new_with(db, Some(self.env.krate), self.env.block);

+ let args = generic_args_from_tys(

+ interner,

+ alias.id.into(),

+ std::iter::once(self.ty).chain(args.iter().map(|ty| ty.ty)),

+ );

+ let projection = Ty::new_alias(

+ interner,

+ AliasTyKind::Projection,

+ AliasTy::new(interner, alias.id.into(), args),

+ );

+ // FIXME(next-solver): This needs to be `PostAnalysis`, but this currently causes errors due to our incorrect

+ // handling of opaques. `non_body_analysis()` will also cause errors (from not revealing opaques inside their

+ // defining places), so we choose between two bad options.

+ let infcx = interner.infer_ctxt().build(TypingMode::non_body_analysis());

+ let ty = structurally_normalize_ty(&infcx, projection, self.env.clone());

+ if ty.is_ty_error() { None } else { Some(self.derived(ty)) }

+ let interner = DbInterner::new_with(db, None, None);

+ let callee = match self.ty.kind() {

+ TyKind::Closure(id, subst) => Callee::Closure(id.0, subst),

+ TyKind::FnPtr(..) => Callee::FnPtr,

+ TyKind::FnDef(id, _) => Callee::Def(id.0),

+ let (ty, kind) = if let TyKind::Ref(_, ty, _) = kind {

+ (ty, ty.kind())

+ (self.ty, kind)

+ let sig = subst

+ .split_closure_args_untupled()

+ .closure_sig_as_fn_ptr_ty

+ .callable_sig(interner)?;

+ callee: Callee::Closure(closure.0, subst),

+ let sig = self.ty.callable_sig(interner)?;

+ matches!(self.ty.kind(), TyKind::Closure { .. })

+ pub fn as_closure(&self) -> Option<Closure<'db>> {

+ match self.ty.kind() {

+ TyKind::Closure(id, subst) => Some(Closure { id: id.0, subst }),

+ matches!(self.ty.kind(), TyKind::FnDef(..) | TyKind::FnPtr { .. })

+ matches!(self.ty.kind(), TyKind::Array(..))

+ let adt_id = match self.ty.kind() {

+ TyKind::Adt(adt_def, ..) => adt_def.def_id().0,

+ matches!(self.ty.kind(), TyKind::RawPtr(..))

+ if let TyKind::RawPtr(ty, _) = self.ty.kind() { Some(self.derived(ty)) } else { None }

+ self.ty.references_non_lt_error()

+ let interner = DbInterner::new_with(db, None, None);

+ let (variant_id, substs) = match self.ty.kind() {

+ TyKind::Adt(adt_def, substs) => {

+ let id = match adt_def.def_id().0 {

+ AdtId::StructId(id) => id.into(),

+ AdtId::UnionId(id) => id.into(),

+ AdtId::EnumId(_) => return Vec::new(),

+ };

+ (id, substs)

+ }

+ db.field_types_ns(variant_id)

+ let ty = ty.instantiate(interner, substs);

+ if let TyKind::Tuple(substs) = self.ty.kind() {

+ substs.iter().map(|ty| self.derived(ty)).collect()

+ if let TyKind::Array(ty, len) = self.ty.kind() {

+ try_const_usize(db, len).map(|it| (self.derived(ty), it as usize))

+ TyFingerprint::for_trait_impl(self.ty)

+ pub(crate) fn canonical(&self, db: &'db dyn HirDatabase) -> Canonical<'db, Ty<'db>> {

+ let interner = DbInterner::new_with(db, None, None);

+ hir_ty::replace_errors_with_variables(interner, &self.ty)

+ fn autoderef_(&self, db: &'db dyn HirDatabase) -> impl Iterator<Item = Ty<'db>> {

+ let interner = DbInterner::new_with(db, None, None);

+ let canonical = hir_ty::replace_errors_with_variables(interner, &self.ty);

+ let ty_ns = self.ty;

+ match self.ty.strip_references().kind() {

+ TyKind::Adt(_, substs) => Either::Left(substs.types().map(move |ty| self.derived(ty))),

+ TyKind::Tuple(substs) => {

+ Either::Right(Either::Left(substs.iter().map(move |ty| self.derived(ty))))

+ }

+ _ => Either::Right(Either::Right(std::iter::empty())),

+ }

+ .flat_map(|(_, substs)| substs.iter())

+ .filter_map(move |arg| match arg {

+ GenericArg::Ty(ty) => Some(format_smolstr!("{}", ty.display(db, display_target))),

+ GenericArg::Const(const_) => {

+ Some(format_smolstr!("{}", const_.display(db, display_target)))

+ GenericArg::Lifetime(_) => None,

+ let interner = DbInterner::new_with(db, None, None);

+ let canonical = hir_ty::replace_errors_with_variables(interner, &self.ty);

+ &canonical,

+ let interner = DbInterner::new_with(db, None, None);

+ let canonical = hir_ty::replace_errors_with_variables(interner, &self.ty);

+ &canonical,

+ .filter(|ty| matches!(ty.kind(), TyKind::Param(_)))

+ it.into_iter().filter_map(|pred| match pred.kind().skip_binder() {

+ ClauseKind::Trait(trait_ref) => Some(Trait::from(trait_ref.def_id().0)),

+ let TyKind::Alias(AliasTyKind::Projection, alias) = self.ty.kind() else { return None };

+ match alias.def_id.expect_type_alias().loc(db).container {

+ ItemContainerId::TraitId(id) => Some(Trait { id }),

+ _ => None,

+ }

+ fn derived(&self, ty: Ty<'db>) -> Self {

+ Type { env: self.env.clone(), ty }

+ /// Visits every type, including generic arguments, in this type. `callback` is called with type

+ pub fn walk(&self, db: &'db dyn HirDatabase, callback: impl FnMut(Type<'db>)) {

+ struct Visitor<'db, F> {

+ env: Arc<TraitEnvironment<'db>>,

+ callback: F,

+ visited: FxHashSet<Ty<'db>>,

+ impl<'db, F> TypeVisitor<DbInterner<'db>> for Visitor<'db, F>

+ where

+ F: FnMut(Type<'db>),

+ {

+ type Result = ();

+ fn visit_ty(&mut self, ty: Ty<'db>) -> Self::Result {

+ if !self.visited.insert(ty) {

+ return;

+ (self.callback)(Type { env: self.env.clone(), ty });

+ if let Some(bounds) = ty.impl_trait_bounds(self.db) {

+ bounds.visit_with(self);

+ ty.super_visit_with(self);

+ let mut visitor =

+ Visitor { db, env: self.env.clone(), callback, visited: FxHashSet::default() };

+ self.ty.visit_with(&mut visitor);

+ let interner = DbInterner::new_with(db, None, None);

+ let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, other.ty));

+ let interner = DbInterner::new_with(db, None, None);

+ let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, other.ty));

+ let interner = DbInterner::new_with(db, None, None);

+ let tys = hir_ty::replace_errors_with_variables(interner, &(self.ty, to.ty));

+ pub fn as_type_param(&self, _db: &'db dyn HirDatabase) -> Option<TypeParam> {

+ match self.ty.kind() {

+ TyKind::Param(param) => Some(TypeParam { id: param.id }),

+ hir_ty::collect_params(&self.ty)

+ db.layout_of_ty(self.ty, self.env.clone())

+ hir_ty::drop::has_drop_glue(&infcx, self.ty, self.env.clone())

+ ty: Ty<'db>,

+ fn new(db: &'db dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty<'db>) -> Self {

+ TypeNs { env: environment, ty }

+ pub fn to_type(&self, _db: &'db dyn HirDatabase) -> Type<'db> {

+ Type { env: self.env.clone(), ty: self.ty }

+ sig: PolyFnSig<'db>,

+ callee: Callee<'db>,

+enum Callee<'db> {

+ Closure(InternedClosureId, GenericArgs<'db>),

+pub enum CallableKind<'db> {

+ Closure(Closure<'db>),

+ pub fn kind(&self) -> CallableKind<'db> {

+ Callee::Closure(id, ref subst) => CallableKind::Closure(Closure { id, subst: *subst }),

+ Some((

+ func.self_param(db)?,

+ self.ty.derived(self.sig.skip_binder().inputs_and_output.inputs()[0]),

+ ))

+ self.sig.skip_binder().inputs_and_output.inputs().len()

+ - if self.is_bound_method { 1 } else { 0 }

+ .skip_binder()

+ .inputs_and_output

+ .inputs()

+ .map(|(idx, ty)| (idx, self.ty.derived(*ty)))

+ self.ty.derived(self.sig.skip_binder().output())

+ pub fn sig(&self) -> impl Eq {

+fn generic_args_from_tys<'db>(

+ interner: DbInterner<'db>,

+ def_id: SolverDefId,

+ args: impl IntoIterator<Item = Ty<'db>>,

+) -> GenericArgs<'db> {

+ let mut args = args.into_iter();

+ GenericArgs::for_item(interner, def_id, |_, _, id, _| {

+ if matches!(id, GenericParamId::TypeParamId(_))

+ && let Some(arg) = args.next()

+ {

+ arg.into()

+ } else {

+ next_solver::GenericArg::error_from_id(interner, id)

+ }

+ })

+}

+

+fn has_non_default_type_params(db: &dyn HirDatabase, generic_def: GenericDefId) -> bool {

+ let params = db.generic_params(generic_def);

+ let defaults = db.generic_defaults_ns(generic_def);

+ params

+ .iter_type_or_consts()

+ .filter(|(_, param)| matches!(param, TypeOrConstParamData::TypeParamData(_)))

+ .map(|(local_id, _)| TypeOrConstParamId { parent: generic_def, local_id })

+ .any(|param| {

+ let Some(param) = hir_ty::param_idx(db, param) else {

+ return false;

+ };

+ defaults.get(param).is_none()

+ })

+}

+