+#[doc(hidden)]

+pub use hir_def::ModuleId;

+

+ fmt,

+ AdtId, AssocItemId, AssocItemLoc, CallableDefId, ConstId, ConstParamId, CrateRootModuleId,

+ DefWithBodyId, EnumId, EnumVariantId, ExternBlockId, ExternCrateId, FunctionId, GenericDefId,

+ GenericParamId, HasModule, ImplId, InternedModuleId, ItemContainerId, LifetimeParamId,

+ LocalFieldId, Lookup, MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId,

+ TypeAliasId, TypeOrConstParamId, TypeParamId, UnionId,

+ attrs::AttrFlags,

+ lang_item::LangItemTarget,

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

+ AstId, MacroCallKind, RenderedExpandError, ValueResult, proc_macro::ProcMacroKind,

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

+ method_resolution::{

+ self, InherentImpls, MethodResolutionContext, MethodResolutionUnstableFeatures,

+ },

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

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

+ infer::{DbInternerInferExt, InferCtxt},

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

+use rustc_type_ir::{

+ AliasTyKind, TypeSuperVisitable, TypeVisitable, TypeVisitor, fast_reject,

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

+};

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

+ AstNode, AstPtr, SmolStr, SyntaxNode, SyntaxNodePtr, TextRange, ToSmolStr,

+ ast::{self, HasName, HasVisibility as _},

+ attrs::{AttrsWithOwner, HasAttrs, resolve_doc_path_on},

+ attrs::{Docs, IsInnerDoc},

+ lang_item::{LangItemEnum as LangItem, crate_lang_items},

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

+ // FIXME: These are needed for import assets, properly encapsulate them.

+ hir_ty::{method_resolution::TraitImpls, next_solver::SimplifiedType},

+ self.id.transitive_rev_deps(db).into_iter().map(|id| Crate { id })

+ }

+

+ pub fn notable_traits_in_deps(self, db: &dyn HirDatabase) -> impl Iterator<Item = &TraitId> {

+ self.id

+ .transitive_deps(db)

+ .into_iter()

+ .filter_map(|krate| db.crate_notable_traits(krate))

+ .flatten()

+ pub fn get_html_root_url(self, db: &dyn HirDatabase) -> Option<String> {

+ let doc_url = AttrFlags::doc_html_root_url(db, self.id);

+ doc_url.as_ref().map(|s| s.trim_matches('"').trim_end_matches('/').to_owned() + "/")

+ emit_def_diagnostic(db, acc, diag, edition, def_map.krate());

+ let krate = t.krate(db);

+ emit_def_diagnostic(db, acc, diag, edition, krate.id);

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

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

+ let (impl_signature, source_map) = db.impl_signature_with_source_map(impl_def.id);

+ emit_def_diagnostic(db, acc, diag, edition, loc.container.krate());

+ if impl_signature.target_trait.is_none()

+ && !is_inherent_impl_coherent(db, def_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 drop_trait = interner.lang_items().Drop?;

+ let (lifetimes_attrs, type_and_consts_attrs) =

+ AttrFlags::query_generic_params(db, parent);

+ let res = lifetimes_attrs.values().any(|it| it.contains(AttrFlags::MAY_DANGLE))

+ || type_and_consts_attrs.values().any(|it| it.contains(AttrFlags::MAY_DANGLE));

+ 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

+

+ #[inline]

+ pub fn doc_keyword(self, db: &dyn HirDatabase) -> Option<Symbol> {

+ AttrFlags::doc_keyword(db, InternedModuleId::new(db, self.id))

+ }

+

+ /// Whether it has `#[path = "..."]` attribute.

+ #[inline]

+ pub fn has_path(&self, db: &dyn HirDatabase) -> bool {

+ self.attrs(db).attrs.contains(AttrFlags::HAS_PATH)

+ }

+ let mut range = precise_macro_call_location(&loc.kind, db, loc.krate);

+ if Some(err.span().anchor.file_id) == file_id.file_id().map(|it| it.editioned_file_id(db)) {

+ range.value = err.span().range

+ + db.ast_id_map(file_id).get_erased(err.span().anchor.ast_id).text_range().start();

+ }

+ acc.push(MacroError { range, message, error, kind }.into());

+ let range = precise_macro_call_location(&loc.kind, db, loc.krate);

+ acc.push(MacroExpansionParseError { range, errors: parse_errors.clone() }.into())

+ m.krate(db).id,

+ krate: base_db::Crate,

+ emit_def_diagnostic_(db, acc, &diag.kind, edition, krate)

+ krate: base_db::Crate,

+ range: InFile::new(ast.file_id, item.text_range()),

+ let location = precise_macro_call_location(ast, db, krate);

+ range: location,

+ let derive = id.find_attr_range(db, krate, *ast).3.path_range();

+ acc.push(InvalidDeriveTarget { range: ast.with_value(derive) }.into());

+ let derive = id.find_attr_range(db, krate, *ast).2;

+ acc.push(MalformedDerive { range: ast.with_value(derive) }.into());

+ krate: base_db::Crate,

+) -> InFile<TextRange> {

+ let range = node

+ .path()

+ .and_then(|it| it.segment())

+ .and_then(|it| it.name_ref())

+ .map(|it| it.syntax().text_range());

+ let range = range.unwrap_or_else(|| node.syntax().text_range());

+ ast_id.with_value(range)

+ let range = derive_attr_index.find_derive_range(db, krate, *ast_id, *derive_index);

+ ast_id.with_value(range)

+ MacroCallKind::Attr { ast_id, censored_attr_ids: attr_ids, .. } => {

+ let attr_range = attr_ids.invoc_attr().find_attr_range(db, krate, *ast_id).2;

+ ast_id.with_value(attr_range)

+ let interner = DbInterner::new_no_crate(db);

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

+ let interner = DbInterner::new_no_crate(db);

+ let ty = InferenceResult::for_body(db, self.owner)

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

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

+ self.ty(db).ty,

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

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

+ AttrFlags::repr(db, self.id.into())

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_UNSTABLE)

+ let interner = DbInterner::new_no_crate(db);

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

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

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

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_UNSTABLE)

+ AttrFlags::repr(db, self.id.into())

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

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

+ let interner = DbInterner::new_no_crate(db);

+ match EnumSignature::variant_body_type(db, self.id) {

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

+ },

+ ),

+ },

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_UNSTABLE)

+ let interner = DbInterner::new_no_crate(db);

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

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

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_UNSTABLE)

+ has_non_default_type_params(db, self.into())

+ let interner = DbInterner::new_no_crate(db);

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

+ let ty = Ty::new_adt(

+ interner,

+ id,

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

+ );

+ let infer = InferenceResult::for_body(db, self.into());

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

+ range: node.map(|ptr| ptr.text_range()),

+ let interner = DbInterner::new_no_crate(db);

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

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

+ let interner = DbInterner::new_no_crate(db);

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

+ 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 lang_items = hir_def::lang_item::lang_items(db, self.krate(db).id);

+ let Some(future_trait_id) = lang_items.Future else {

+ let Some(sized_trait_id) = lang_items.Sized else {

+ self.attrs(db).is_test()

+ self.exported_main(db)

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_EXPORT_NAME_MAIN)

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_IGNORE)

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_BENCH)

+ AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_UNSTABLE)

+ let target_features = hir_ty::TargetFeatures::from_fn(db, caller.id);

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

+ let interner = DbInterner::new_no_crate(db);

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

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

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

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

+ db.const_eval(self.id, 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_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();

+ db.const_eval_static(self.id).map(|it| EvaluatedConst {

+ const_: it,

+ def: self.id.into(),

+ ty,

+ })

+ pub fn lang(db: &dyn HirDatabase, krate: Crate, lang_item: LangItem) -> Option<Trait> {

+ let lang_items = hir_def::lang_item::lang_items(db, krate.id);

+ match lang_item.from_lang_items(lang_items)? {

+ LangItemTarget::TraitId(it) => Some(it.into()),

+ _ => None,

+ }

+ Complete::extract(true, self.attrs(db).attrs)

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

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

+ ProcMacroKind::CustomDerive => AttrFlags::derive_info(db, self.id).map_or_else(

+ || as_name_opt(source.value.name()),

+ |info| Name::new_symbol_root(info.trait_name.clone()),

+ ),

+ matches!(self.id, MacroId::MacroRulesId(_) if AttrFlags::query(db, self.id.into()).contains(AttrFlags::IS_MACRO_EXPORT))

+ MacroExpander::Declarative { .. } => MacroKind::Declarative,

+ MacroExpander::Declarative { .. } => MacroKind::Declarative,

+impl From<method_resolution::CandidateId> for AssocItem {

+ fn from(value: method_resolution::CandidateId) -> Self {

+ match value {

+ method_resolution::CandidateId::FunctionId(id) => AssocItem::Function(Function { id }),

+ method_resolution::CandidateId::ConstId(id) => AssocItem::Const(Const { id }),

+ }

+ }

+}

+

+ GenericPredicates::query_with_diagnostics(db, def).1.clone(),

+ 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 infer = InferenceResult::for_body(db, def);

+ let ty = infer[self.binding_id];

+ AttrFlags::derive_info(db, self.derive)

+ .and_then(|it| it.helpers.get(self.idx as usize))

+ .map(|helper| Name::new_symbol_root(helper.clone()))

+ .unwrap_or_else(Name::missing)

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

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

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

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

+ GenericPredicates::query_explicit(db, self.id.parent())

+ .iter_identity_copied()

+ ClauseKind::Trait(trait_ref) if trait_ref.self_ty() == self_ty => {

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

+ self.attrs(db).is_unstable()

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

+ let mut result = Vec::new();

+ extend_with_def_map(db, crate_def_map(db, krate.id), &mut result);

+ return result;

+ fn extend_with_def_map(db: &dyn HirDatabase, def_map: &DefMap, result: &mut Vec<Impl>) {

+ for (_, module) in def_map.modules() {

+ result.extend(module.scope.impls().map(Impl::from));

+

+ for unnamed_const in module.scope.unnamed_consts() {

+ for (_, block_def_map) in db.body(unnamed_const.into()).blocks(db) {

+ extend_with_def_map(db, block_def_map, result);

+ }

+ }

+ }

+ }

+ /// **Note:** This is an **approximation** that strives to give the *human-perceived notion* of an "impl for type",

+ /// **not** answer the technical question "what are all impls applying to this type". In particular, it excludes

+ /// blanket impls, and only does a shallow type constructor check. In fact, this should've probably been on `Adt`

+ /// etc., and not on `Type`. If you would want to create a precise list of all impls applying to a type,

+ /// you would need to include blanket impls, and try to prove to predicates for each candidate.

+ Type { ty, env: _ }: Type<'db>,

+ let mut result = Vec::new();

+ let interner = DbInterner::new_no_crate(db);

+ let Some(simplified_ty) =

+ fast_reject::simplify_type(interner, ty, fast_reject::TreatParams::AsRigid)

+ else {

+ return Vec::new();

+ let mut extend_with_impls =

+ |impls: &[ImplId]| result.extend(impls.iter().copied().map(Impl::from));

+ extend_with_impls(method_resolution::incoherent_inherent_impls(db, simplified_ty));

+ if let Some(module) = method_resolution::simplified_type_module(db, &simplified_ty) {

+ InherentImpls::for_each_crate_and_block(

+ db,

+ module.krate(),

+ module.containing_block(),

+ &mut |impls| extend_with_impls(impls.for_self_ty(&simplified_ty)),

+ std::iter::successors(module.containing_block(), |block| {

+ block.loc(db).module.containing_block()

+ })

+ .filter_map(|block| TraitImpls::for_block(db, block).as_deref())

+ .for_each(|impls| impls.for_self_ty(&simplified_ty, &mut extend_with_impls));

+ for &krate in &**db.all_crates() {

+ TraitImpls::for_crate(db, krate)

+ .for_self_ty(&simplified_ty, &mut extend_with_impls);

+ } else {

+ for &krate in &**db.all_crates() {

+ TraitImpls::for_crate(db, krate)

+ .for_self_ty(&simplified_ty, &mut extend_with_impls);

+ result

+ let module = trait_.module(db).id;

+ let mut handle_impls = |impls: &TraitImpls| {

+ impls.for_trait(trait_.id, |impls| all.extend(impls.iter().copied().map(Impl::from)));

+ };

+ for krate in module.krate().transitive_rev_deps(db) {

+ handle_impls(TraitImpls::for_crate(db, krate));

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

+ && let Some(impls) = TraitImpls::for_block(db, block)

+ handle_impls(impls);

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

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

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

+#[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_no_crate(db);

+ 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 = InferenceResult::for_body(db, 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 = InferenceResult::for_body(db, 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 = InferenceResult::for_body(db, owner);

+ let info = infer.closure_info(id);

+ info.1.into()

+ }

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

+ }

+ }

+ }

+ }

+}

+

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

+pub enum FnTrait {

+ FnOnce,

+ FnMut,

+ Fn,

+

+ AsyncFnOnce,

+ AsyncFnMut,

+ AsyncFn,

+}

+

+impl From<traits::FnTrait> for FnTrait {

+ fn from(value: traits::FnTrait) -> Self {

+ match value {

+ traits::FnTrait::FnOnce => FnTrait::FnOnce,

+ traits::FnTrait::FnMut => FnTrait::FnMut,

+ traits::FnTrait::Fn => FnTrait::Fn,

+ traits::FnTrait::AsyncFnOnce => FnTrait::AsyncFnOnce,

+ traits::FnTrait::AsyncFnMut => FnTrait::AsyncFnMut,

+ traits::FnTrait::AsyncFn => FnTrait::AsyncFn,

+ }

+ }

+}

+

+impl fmt::Display for FnTrait {

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

+ match self {

+ FnTrait::FnOnce => write!(f, "FnOnce"),

+ FnTrait::FnMut => write!(f, "FnMut"),

+ FnTrait::Fn => write!(f, "Fn"),

+ FnTrait::AsyncFnOnce => write!(f, "AsyncFnOnce"),

+ FnTrait::AsyncFnMut => write!(f, "AsyncFnMut"),

+ FnTrait::AsyncFn => write!(f, "AsyncFn"),

+ }

+ }

+}

+

+impl FnTrait {

+ pub const fn function_name(&self) -> &'static str {

+ match self {

+ FnTrait::FnOnce => "call_once",

+ FnTrait::FnMut => "call_mut",

+ FnTrait::Fn => "call",

+ FnTrait::AsyncFnOnce => "async_call_once",

+ FnTrait::AsyncFnMut => "async_call_mut",

+ FnTrait::AsyncFn => "async_call",

+ }

+ }

+

+ pub fn lang_item(self) -> LangItem {

+ match self {

+ FnTrait::FnOnce => LangItem::FnOnce,

+ FnTrait::FnMut => LangItem::FnMut,

+ FnTrait::Fn => LangItem::Fn,

+ FnTrait::AsyncFnOnce => LangItem::AsyncFnOnce,

+ FnTrait::AsyncFnMut => LangItem::AsyncFnMut,

+ FnTrait::AsyncFn => LangItem::AsyncFn,

+ }

+ }

+

+ pub fn get_id(self, db: &dyn HirDatabase, krate: Crate) -> Option<Trait> {

+ Trait::lang(db, krate, self.lang_item())

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

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

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

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

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let trait_ = lang_items

+ .IntoFutureIntoFuture

+ .or(lang_items.Future)?;

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

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let future_output = lang_items.FutureOutput?;

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let iterator_trait = lang_items.Iterator?;

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let Some(iterator_trait) = lang_items.Iterator else {

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

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let trait_ = lang_items.IntoIterIntoIter.and_then(|into_iter_fn| {

+ let assoc_item = as_assoc_item(db, AssocItem::Function, into_iter_fn)?;

+ let into_iter_trait = assoc_item.container_or_implemented_trait(db)?;

+ Some(into_iter_trait.id)

+ })?;

+

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

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let fnonce_trait = match lang_items.FnOnce {

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

+ let interner = DbInterner::new_no_crate(db);

+ 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, self.env.krate);

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

+ );

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

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

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

+ let lang_items = hir_def::lang_item::lang_items(db, self.env.krate);

+ let Some(copy_trait) = lang_items.Copy else {

+ let interner = DbInterner::new_no_crate(db);

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

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

+ pub fn fingerprint_for_trait_impl(&self) -> Option<SimplifiedType> {

+ fast_reject::simplify_type(

+ DbInterner::conjure(),

+ self.ty,

+ fast_reject::TreatParams::AsRigid,

+ )

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

+ let interner = DbInterner::new_no_crate(db);

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

+ self.iterate_assoc_items_dyn(db, &mut |assoc_item_id| {

+ let mut handle_impls = |impls: &[ImplId]| {

+ for &impl_def in impls {

+ };

+

+ let interner = DbInterner::new_no_crate(db);

+ let Some(simplified_type) =

+ fast_reject::simplify_type(interner, self.ty, fast_reject::TreatParams::AsRigid)

+ else {

+ return;

+ };

+

+ handle_impls(method_resolution::incoherent_inherent_impls(db, simplified_type));

+

+ if let Some(module) = method_resolution::simplified_type_module(db, &simplified_type) {

+ InherentImpls::for_each_crate_and_block(

+ db,

+ module.krate(),

+ module.containing_block(),

+ &mut |impls| {

+ handle_impls(impls.for_self_ty(&simplified_type));

+ },

+ );

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

+ self.iterate_method_candidates_split_inherent(db, scope, traits_in_scope, name, |f| {

+ match callback(f) {

+ }

+ });

+ fn with_method_resolution<R>(

+ &self,

+ db: &'db dyn HirDatabase,

+ resolver: &Resolver<'db>,

+ traits_in_scope: &FxHashSet<TraitId>,

+ f: impl FnOnce(&MethodResolutionContext<'_, 'db>) -> R,

+ ) -> R {

+ let module = resolver.module();

+ let interner = DbInterner::new_with(db, module.krate());

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

+ let unstable_features =

+ MethodResolutionUnstableFeatures::from_def_map(resolver.top_level_def_map());

+ let environment = resolver

+ .generic_def()

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

+ let ctx = MethodResolutionContext {

+ infcx: &infcx,

+ resolver,

+ env: &environment,

+ traits_in_scope,

+ edition: resolver.krate().data(db).edition,

+ unstable_features: &unstable_features,

+ };

+ f(&ctx)

+ }

+

+ mut callback: impl MethodCandidateCallback,

+ "iterate_method_candidates_split_inherent",

+ self.with_method_resolution(db, scope.resolver(), traits_in_scope, |ctx| {

+ // There should be no inference vars in types passed here

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

+ let (self_ty, _) = ctx.infcx.instantiate_canonical(&canonical);

+

+ match name {

+ Some(name) => {

+ match ctx.probe_for_name(

+ method_resolution::Mode::MethodCall,

+ name.clone(),

+ self_ty,

+ ) {

+ Ok(candidate)

+ | Err(method_resolution::MethodError::PrivateMatch(candidate)) => {

+ let method_resolution::CandidateId::FunctionId(id) = candidate.item

+ else {

+ unreachable!("`Mode::MethodCall` can only return functions");

+ };

+ let id = Function { id };

+ match candidate.kind {

+ method_resolution::PickKind::InherentImplPick(_)

+ | method_resolution::PickKind::ObjectPick(..)

+ | method_resolution::PickKind::WhereClausePick(..) => {

+ // Candidates from where clauses and trait objects are considered inherent.

+ _ = callback.on_inherent_method(id);

+ }

+ method_resolution::PickKind::TraitPick(..) => {

+ _ = callback.on_trait_method(id);

+ }

+ }

+ }

+ Err(_) => {}

+ };

+ }

+ None => {

+ _ = ctx.probe_all(method_resolution::Mode::MethodCall, self_ty).try_for_each(

+ |candidate| {

+ let method_resolution::CandidateId::FunctionId(id) =

+ candidate.candidate.item

+ else {

+ unreachable!("`Mode::MethodCall` can only return functions");

+ };

+ let id = Function { id };

+ match candidate.candidate.kind {

+ method_resolution::CandidateKind::InherentImplCandidate {

+ ..

+ }

+ | method_resolution::CandidateKind::ObjectCandidate(..)

+ | method_resolution::CandidateKind::WhereClauseCandidate(..) => {

+ // Candidates from where clauses and trait objects are considered inherent.

+ callback.on_inherent_method(id)

+ }

+ method_resolution::CandidateKind::TraitCandidate(..) => {

+ callback.on_trait_method(id)

+ }

+ }

+ },

+ );

+ }

+ }

+ })

+ self.iterate_path_candidates_split_inherent(db, scope, traits_in_scope, name, |item| {

+ match callback(item) {

+ }

+ });

+ mut callback: impl PathCandidateCallback,

+ let _p = tracing::info_span!(

+ "iterate_path_candidates_split_inherent",

+ traits_in_scope = traits_in_scope.len(),

+ ?name,

+ )

+ .entered();

+ self.with_method_resolution(db, scope.resolver(), traits_in_scope, |ctx| {

+ // There should be no inference vars in types passed here

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

+ let (self_ty, _) = ctx.infcx.instantiate_canonical(&canonical);

+

+ match name {

+ Some(name) => {

+ match ctx.probe_for_name(

+ method_resolution::Mode::MethodCall,

+ name.clone(),

+ self_ty,

+ ) {

+ Ok(candidate)

+ | Err(method_resolution::MethodError::PrivateMatch(candidate)) => {

+ let id = candidate.item.into();

+ match candidate.kind {

+ method_resolution::PickKind::InherentImplPick(_)

+ | method_resolution::PickKind::ObjectPick(..)

+ | method_resolution::PickKind::WhereClausePick(..) => {

+ // Candidates from where clauses and trait objects are considered inherent.

+ _ = callback.on_inherent_item(id);

+ }

+ method_resolution::PickKind::TraitPick(..) => {

+ _ = callback.on_trait_item(id);

+ }

+ }

+ }

+ Err(_) => {}

+ };

+ }

+ None => {

+ _ = ctx.probe_all(method_resolution::Mode::Path, self_ty).try_for_each(

+ |candidate| {

+ let id = candidate.candidate.item.into();

+ match candidate.candidate.kind {

+ method_resolution::CandidateKind::InherentImplCandidate {

+ ..

+ }

+ | method_resolution::CandidateKind::ObjectCandidate(..)

+ | method_resolution::CandidateKind::WhereClauseCandidate(..) => {

+ // Candidates from where clauses and trait objects are considered inherent.

+ callback.on_inherent_item(id)

+ }

+ method_resolution::CandidateKind::TraitCandidate(..) => {

+ callback.on_trait_item(id)

+ }

+ }

+ },

+ );

+ }

+ })

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

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

+ let interner = DbInterner::new_no_crate(db);

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

+ let interner = DbInterner::new_no_crate(db);

+ 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, self.env.krate);

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

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

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

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

+

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

+ FnImpl(traits::FnTrait),

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

+ Callee::FnImpl(fn_) => CallableKind::FnImpl(fn_.into()),

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

+ })

+}

+