+extern crate ra_ap_rustc_type_ir as rustc_type_ir;

+

+ fmt,

+ TupleId, TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

+ nameres::{

+ assoc::TraitItems,

+ diagnostics::{DefDiagnostic, DefDiagnosticKind},

+ },

+ signatures::{ImplFlags, StaticFlags, StructFlags, TraitFlags, VariantFields},

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

+ check_orphan_rules,

+ consteval::try_const_usize,

+ db::{InternedClosureId, InternedCoroutineId},

+ direct_super_traits, known_const_to_ast,

+ next_solver::{

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

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

+ infer::{DbInternerInferExt, InferCtxt},

+ },

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

+use rustc_type_ir::{

+ AliasTyKind, TypeSuperVisitable, TypeVisitable, TypeVisitor,

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

+};

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

+ FindPathConfig,

+ // FIXME: Properly encapsulate mir

+ hir_ty::mir,

+ CastError, FnAbi, PointerCast, attach_db, attach_db_allow_change,

+ drop::DropGlue,

+ next_solver::abi::Safety,

+ next_solver::clear_tls_solver_cache,

+ pub fn base(self) -> base_db::Crate {

+ self.id

+ }

+

+ 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 (impl_signature, source_map) = db.impl_signature_with_source_map(impl_def.id);

+ let mut trait_is_unsafe = trait_.is_some_and(|t| t.is_unsafe(db));

+ let trait_is_unresolved = trait_.is_none() && impl_signature.target_trait.is_some();

+ if trait_is_unresolved {

+ // Ignore trait safety errors when the trait is unresolved, as otherwise we'll treat it as safe,

+ // which may not be correct.

+ trait_is_unsafe = impl_is_unsafe;

+ }

+

+ 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

+ cfg: FindPathConfig,

+ cfg: FindPathConfig,

+ if let hir_expand::db::TokenExpander::DeclarativeMacro(expander) = db.macro_expander(id)

+ && let Some(e) = expander.mac.err()

+ {

+ let Some(ast) = id.ast_id().left() else {

+ never!("declarative expander for non decl-macro: {:?}", e);

+ return;

+ };

+ let krate = HasModule::krate(&m.id, db);

+ let edition = krate.data(db).edition;

+ emit_def_diagnostic_(

+ db,

+ acc,

+ &DefDiagnosticKind::MacroDefError { ast, message: e.to_string() },

+ edition,

+ );

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+pub struct InstantiatedField<'db> {

+ pub(crate) inner: Field,

+ pub(crate) args: GenericArgs<'db>,

+}

+

+impl<'db> InstantiatedField<'db> {

+ /// Returns the type as in the signature of the struct.

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

+ let krate = self.inner.krate(db);

+ let interner = DbInterner::new_with(db, Some(krate.base()), None);

+

+ let var_id = self.inner.parent.into();

+ let field = db.field_types(var_id)[self.inner.id];

+ let ty = field.instantiate(interner, self.args);

+ TypeNs::new(db, var_id, ty)

+ }

+}

+

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

+ .as_slice()

+ .copied()

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

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

+ /// Returns the type as in the signature of the struct. Only use this in the

+ /// context of the field definition.

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

+ let ty = db.field_types(var_id)[self.id].skip_binder();

+ TypeNs::new(db, var_id, 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(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 instantiate_infer<'db>(self, infer_ctxt: &InferCtxt<'db>) -> InstantiatedStruct<'db> {

+ let args = infer_ctxt.fresh_args_for_item(self.id.into());

+ InstantiatedStruct { inner: self, args }

+ }

+pub struct InstantiatedStruct<'db> {

+ pub(crate) inner: Struct,

+ pub(crate) args: GenericArgs<'db>,

+}

+

+impl<'db> InstantiatedStruct<'db> {

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

+ self.inner

+ .id

+ .fields(db)

+ .fields()

+ .iter()

+ .map(|(id, _)| InstantiatedField {

+ inner: Field { parent: self.inner.into(), id },

+ args: self.args,

+ })

+ .collect()

+ }

+

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

+ let krate = self.inner.krate(db);

+ let interner = DbInterner::new_with(db, Some(krate.base()), None);

+

+ let ty = db.ty(self.inner.id.into());

+ TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))

+ }

+}

+

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+ 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,

+ },

+ ),

+ },

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+pub struct InstantiatedEnum<'db> {

+ pub(crate) inner: Enum,

+ pub(crate) args: GenericArgs<'db>,

+}

+

+impl<'db> InstantiatedEnum<'db> {

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

+ let krate = self.inner.krate(db);

+ let interner = DbInterner::new_with(db, Some(krate.base()), None);

+

+ let ty = db.ty(self.inner.id.into());

+ TypeNs::new(db, self.inner.id, ty.instantiate(interner, self.args))

+ }

+}

+

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

+

+ pub fn instantiate_infer<'db>(self, infer_ctxt: &InferCtxt<'db>) -> InstantiatedVariant<'db> {

+ let args =

+ infer_ctxt.fresh_args_for_item(self.parent_enum(infer_ctxt.interner.db()).id.into());

+ InstantiatedVariant { inner: self, args }

+ }

+}

+

+// FIXME: Rename to `EnumVariant`

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+pub struct InstantiatedVariant<'db> {

+ pub(crate) inner: Variant,

+ pub(crate) args: GenericArgs<'db>,

+}

+

+impl<'db> InstantiatedVariant<'db> {

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

+ InstantiatedEnum { inner: self.inner.id.lookup(db).parent.into(), args: self.args }

+ }

+

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

+ self.inner

+ .id

+ .fields(db)

+ .fields()

+ .iter()

+ .map(|(id, _)| InstantiatedField {

+ inner: Field { parent: self.inner.into(), id },

+ args: self.args,

+ })

+ .collect()

+ }

+ has_non_default_type_params(db, self.into())

+ let env = db.trait_environment(self.into());

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

+ 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())

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

+ // 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.

+ let ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate_identity()

+ .skip_binder()

+ .output();

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

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

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

+ let ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate(interner, args)

+ .skip_binder()

+ .output();

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

+ let ret_ty = db

+ .callable_item_signature(self.id.into())

+ .instantiate_identity()

+ .skip_binder()

+ .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 interner = DbInterner::new_with(db, None, None);

+ 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 };

+ let (target_features, target_feature_is_safe_in_target) = caller

+ .map(|caller| {

+ let target_features =

+ hir_ty::TargetFeatures::from_attrs(&db.attrs(caller.id.into()));

+ let target_feature_is_safe_in_target =

+ match &caller.krate(db).id.workspace_data(db).target {

+ Ok(target) => hir_ty::target_feature_is_safe_in_target(target),

+ Err(_) => hir_ty::TargetFeatureIsSafeInTarget::No,

+ };

+ (target_features, target_feature_is_safe_in_target)

+ })

+ .unwrap_or_else(|| {

+ (hir_ty::TargetFeatures::default(), hir_ty::TargetFeatureIsSafeInTarget::No)

+ });

+ hir_ty::is_fn_unsafe_to_call(

+ db,

+ self.id,

+ &target_features,

+ call_edition,

+ target_feature_is_safe_in_target

+ ),

+ ) -> Result<String, ConstEvalError<'_>> {

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

+ GenericArgs::new_from_iter(interner, []),

+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);

+ if let Expr::Closure { args, .. } = &body[c.1]

+ && let Pat::Bind { id, .. } = &body[args[self.idx]]

+ {

+ return Some(Local { parent: c.0, binding_id: *id });

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

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

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

+ Type { env: environment, ty }

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

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

+ 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 interner = DbInterner::new_with(db, None, None);

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

+ db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None)

+ .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 = u128::from_le_bytes(mir::pad16(b, false));

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

+ let mut result =

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

+ if value >= 10 {

+ format_to!(result, " ({value:#X})");

+ return Ok(result);

+ } else {

+ return Ok(result);

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

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

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

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

+ db.const_eval(self.id.into(), GenericArgs::new_from_iter(interner, []), None)

+ .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>,

+ env: Arc<TraitEnvironment<'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() }))

+ let ty = infer[self.binding_id];

+ .map(|idx| BuiltinAttr { idx: idx as u32 })

+ pub fn name(&self) -> Name {

+ Name::new_symbol_root(Symbol::intern(

+ hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].name,

+ ))

+ pub fn template(&self) -> Option<AttributeTemplate> {

+ Some(hir_expand::inert_attr_macro::INERT_ATTRIBUTES[self.idx as usize].template)

+ db.variances_of(parent).get(index).map(Into::into)

+ }

+}

+

+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]

+pub enum Variance {

+ Bivariant,

+ Covariant,

+ Contravariant,

+ Invariant,

+}

+

+impl From<rustc_type_ir::Variance> for Variance {

+ #[inline]

+ fn from(value: rustc_type_ir::Variance) -> Self {

+ match value {

+ rustc_type_ir::Variance::Covariant => Variance::Covariant,

+ rustc_type_ir::Variance::Invariant => Variance::Invariant,

+ rustc_type_ir::Variance::Contravariant => Variance::Contravariant,

+ rustc_type_ir::Variance::Bivariant => Variance::Bivariant,

+ }

+ }

+}

+

+impl fmt::Display for Variance {

+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

+ let description = match self {

+ Variance::Bivariant => "bivariant",

+ Variance::Covariant => "covariant",

+ Variance::Contravariant => "contravariant",

+ Variance::Invariant => "invariant",

+ };

+ f.pad(description)

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

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

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

+ .filter_map(|pred| match &pred.kind().skip_binder() {

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

+ 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 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),

+ if let Some(block) = module.id.containing_block()

+ && let Some(trait_impls) = db.trait_impls_in_block(block)

+ {

+ all.extend(trait_impls.for_trait(trait_.id).map(Self::from));

+ let id = trait_ref.skip_binder().def_id;

+ Some(Trait { id: id.0 })

+ let trait_ref = db.impl_trait(self.id)?.instantiate_identity();

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

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

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

+ trait_ref: hir_ty::next_solver::TraitRef<'db>,

+ trait_ref: hir_ty::next_solver::TraitRef<'db>,

+ TraitRef { env, trait_ref }

+ Trait { id: self.trait_ref.def_id.0 }

+ pub fn self_ty(&self) -> TypeNs<'_> {

+ let ty = self.trait_ref.self_ty();

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

+ pub fn get_type_argument(&self, idx: usize) -> Option<TypeNs<'db>> {

+ .args

+ .as_slice()

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

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

+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]

+enum AnyClosureId {

+ ClosureId(InternedClosureId),

+ CoroutineClosureId(InternedCoroutineId),

+#[derive(Clone, Debug, PartialEq, Eq, Hash)]

+pub struct Closure<'db> {

+ id: AnyClosureId,

+ 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);

+ match self.id {

+ AnyClosureId::ClosureId(id) => Ty::new_closure(interner, id.into(), self.subst),

+ AnyClosureId::CoroutineClosureId(id) => {

+ Ty::new_coroutine_closure(interner, 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 AnyClosureId::ClosureId(id) = self.id else {

+ // FIXME: Infer coroutine closures' captures.

+ return Vec::new();

+ };

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

+ let infer = db.infer(owner);

+ let info = infer.closure_info(id);

+ .map(|capture| ClosureCapture { owner, closure: id, capture })

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

+ let AnyClosureId::ClosureId(id) = self.id else {

+ // FIXME: Infer coroutine closures' captures.

+ return Vec::new();

+ };

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

+ let infer = db.infer(owner);

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

+ let env = db.trait_environment_for_body(owner);

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

+ match self.id {

+ AnyClosureId::ClosureId(id) => {

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

+ let infer = db.infer(owner);

+ let info = infer.closure_info(id);

+ info.1

+ }

+ AnyClosureId::CoroutineClosureId(_id) => {

+ // FIXME: Infer kind for coroutine closures.

+ match self.subst.as_coroutine_closure().kind() {

+ rustc_type_ir::ClosureKind::Fn => FnTrait::AsyncFn,

+ rustc_type_ir::ClosureKind::FnMut => FnTrait::AsyncFnMut,

+ rustc_type_ir::ClosureKind::FnOnce => FnTrait::AsyncFnOnce,

+ }

+ }

+ }

+pub struct ClosureCapture<'db> {

+ closure: InternedClosureId,

+ capture: hir_ty::CapturedItem<'db>,

+impl<'db> ClosureCapture<'db> {

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

+ 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 interner = DbInterner::new_with(db, None, None);

+ 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();

+

+ fn is_phantom_data(db: &dyn HirDatabase, adt_id: AdtId) -> bool {

+ match adt_id {

+ AdtId::StructId(s) => {

+ let flags = db.struct_signature(s).flags;

+ flags.contains(StructFlags::IS_PHANTOM_DATA)

+ }

+ 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(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::CoroutineClosure(id, subst) => Callee::CoroutineClosure(id.0, subst),

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

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

+ // This will happen when it implements fn or fn mut, since we add an autoborrow adjustment

+ TyKind::Ref(_, inner_ty, _) => return self.derived(inner_ty).as_callable(db),

+ _ => {

+ let (fn_trait, sig) =

+ hir_ty::callable_sig_from_fn_trait(self.ty, self.env.clone(), db)?;

+ 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: AnyClosureId::ClosureId(id.0), subst })

+ }

+ TyKind::CoroutineClosure(id, subst) => {

+ Some(Closure { id: AnyClosureId::CoroutineClosureId(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)

+ }

+ 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;

+ let def_crates = match method_resolution::def_crates(db, ty_ns, krate.id) {

+ for impl_def in impls.for_self_ty(ty_ns) {

+ 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);

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

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

+ .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())

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

+ // FIXME: This should be `PostAnalysis` I believe.

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

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

+ }

+}

+

+#[derive(Clone, PartialEq, Eq, Debug, Hash)]

+pub struct TypeNs<'db> {

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

+ ty: Ty<'db>,

+}

+

+impl<'db> TypeNs<'db> {

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

+ let resolver = lexical_env.resolver(db);

+ let environment = resolver

+ .generic_def()

+ .map_or_else(|| TraitEnvironment::empty(resolver.krate()), |d| db.trait_environment(d));

+ TypeNs { env: environment, ty }

+ }

+

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

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

+ }

+

+ // FIXME: Find better API that also handles const generics

+ pub fn impls_trait(&self, infcx: InferCtxt<'db>, trait_: Trait, args: &[TypeNs<'db>]) -> bool {

+ let args = GenericArgs::new_from_iter(

+ infcx.interner,

+ [self.ty].into_iter().chain(args.iter().map(|t| t.ty)).map(|t| t.into()),

+ );

+ let trait_ref = hir_ty::next_solver::TraitRef::new(infcx.interner, trait_.id.into(), args);

+

+ let pred_kind = rustc_type_ir::Binder::dummy(rustc_type_ir::PredicateKind::Clause(

+ rustc_type_ir::ClauseKind::Trait(rustc_type_ir::TraitPredicate {

+ trait_ref,

+ polarity: rustc_type_ir::PredicatePolarity::Positive,

+ }),

+ ));

+ let predicate = hir_ty::next_solver::Predicate::new(infcx.interner, pred_kind);

+ let goal = hir_ty::next_solver::Goal::new(

+ infcx.interner,

+ hir_ty::next_solver::ParamEnv::empty(),

+ predicate,

+ );

+ let res = hir_ty::traits::next_trait_solve_in_ctxt(&infcx, goal);

+ res.map_or(false, |res| matches!(res.1, rustc_type_ir::solve::Certainty::Yes))

+ }

+

+ pub fn is_bool(&self) -> bool {

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

+ sig: PolyFnSig<'db>,

+ callee: Callee<'db>,

+enum Callee<'db> {

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

+ CoroutineClosure(InternedCoroutineId, GenericArgs<'db>),

+pub enum CallableKind<'db> {

+ Closure(Closure<'db>),

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

+ Callee::Closure(id, subst) => {

+ CallableKind::Closure(Closure { id: AnyClosureId::ClosureId(id), subst })

+ }

+ Callee::CoroutineClosure(id, subst) => {

+ CallableKind::Closure(Closure { id: AnyClosureId::CoroutineClosureId(id), 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 {

+ self.0.align.bytes()

+

+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(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()

+ })

+}

+

+pub use hir_ty::next_solver;

+pub use hir_ty::setup_tracing;