+#[doc(hidden)]

+pub use hir_def::ModuleId;

+

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

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

+ GenericParamId, HasModule, ImplId, ItemContainerId, LifetimeParamId, LocalFieldId, Lookup,

+ MacroExpander, MacroId, StaticId, StructId, SyntheticSyntax, TupleId, TypeAliasId,

+ TypeOrConstParamId, TypeParamId, UnionId,

+ attrs::AttrFlags,

+ builtin_derive::BuiltinDeriveImplMethod,

+ lang_item::LangItemTarget,

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

+ AstId, MacroCallKind, RenderedExpandError, ValueResult, builtin::BuiltinDeriveExpander,

+ GenericPredicates, InferenceResult, ParamEnvAndCrate, TyDefId, TyLoweringDiagnostic,

+ ValueTyDefId, all_super_traits, autoderef, check_orphan_rules,

+ method_resolution::{

+ self, InherentImpls, MethodResolutionContext, MethodResolutionUnstableFeatures,

+ },

+ AliasTy, AnyImplId, ClauseKind, ConstKind, DbInterner, EarlyBinder, EarlyParamRegion,

+ ErrorGuaranteed, GenericArg, GenericArgs, ParamConst, ParamEnv, PolyFnSig, Region,

+ RegionKind, SolverDefId, Ty, TyKind, TypingMode,

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

+ AliasTyKind, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable,

+ TypeVisitor, fast_reject,

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

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

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

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

+ LintAttr, PathResolution, PathResolutionPerNs, Semantics, SemanticsImpl, SemanticsScope,

+ TypeInfo, VisibleTraits,

+ attrs::{Docs, IsInnerDoc},

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

+ next_solver::{clear_tls_solver_cache, collect_ty_garbage},

+ // 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 root_module(self, db: &dyn HirDatabase) -> Module {

+ Module { id: crate_def_map(db, self.id).root_module_id() }

+ def_map.modules().map(|(id, _)| id.into()).collect()

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

+ ModuleDef::Function(it) => match it.id {

+ AnyFunctionId::FunctionId(it) => it.into(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => return Vec::new(),

+ },

+ ModuleDef::Function(it) => HasAttrs::attrs(*it, db),

+ Some(module) => module.krate(db),

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

+ Crate { id: self.id.krate(db) }

+ let def_map = crate_def_map(db, self.id.krate(db));

+ Module { id: def_map.crate_root(db) }

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

+ self.crate_root(db) == self

+ let children = def_map[self.id]

+ .map(|module_id| Module { id: *module_id })

+ let parent_id = def_map.containing_module(self.id)?;

+ while id.is_block_module(db) {

+ self.id.def_map(db)[self.id]

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

+ if diag.in_module != self.id {

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

+ if !self.id.is_block_module(db) {

+ let scope = &def_map[self.id].scope;

+ if def_map[m.id].origin.is_inline() {

+ let krate = t.krate(db);

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

+ db.field_types_with_diagnostics(s.id.into()).1.clone(),

+ db.field_types_with_diagnostics(u.id.into()).1.clone(),

+ db.field_types_with_diagnostics(v.into()).1.clone(),

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

+ let AnyImplId::ImplId(impl_id) = impl_def.id else {

+ continue;

+ };

+ let loc = impl_id.lookup(db);

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

+ for diag in impl_id.impl_items_with_diagnostics(db).1.iter() {

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

+ if impl_signature.target_trait.is_none()

+ && !is_inherent_impl_coherent(db, def_map, impl_id)

+ {

+ let drop_trait = interner.lang_items().Drop?;

+ let parent = impl_id.into();

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

+ impl_assoc_items_scratch.extend(impl_id.impl_items(db).items.iter().cloned());

+ let self_ty = db.impl_self_ty(impl_id).instantiate_identity();

+ db.trait_environment(impl_id.into()),

+ AssocItem::Function(it) => match it.id {

+ AnyFunctionId::FunctionId(id) => id.into(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => {

+ never!("should not have an `AnyFunctionId::BuiltinDeriveImplMethod` here");

+ return false;

+ },

+ },

+ push_ty_diagnostics(db, acc, db.impl_self_ty_with_diagnostics(impl_id).1, &source_map);

+ db.impl_trait_with_diagnostics(impl_id).and_then(|it| it.1),

+ for &(_, item) in impl_id.impl_items(db).items.iter() {

+ let scope = &def_map[self.id].scope;

+ let scope = &def_map[self.id].scope;

+ let scope = &def_map[self.id].scope;

+ scope.impls().map(Impl::from).chain(scope.builtin_derive_impls().map(Impl::from)).collect()

+ item.into().try_into().ok()?,

+ hir_def::find_path::find_path(

+ db,

+ item.into().try_into().ok()?,

+ self.into(),

+ prefix_kind,

+ true,

+ cfg,

+ )

+ }

+

+ #[inline]

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

+ AttrFlags::doc_keyword(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 module_data = &def_map[self.id];

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

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

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

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

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

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

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

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

+ self.ty(db).ty.store(),

+ param_env_from_has_crate(

+ db,

+ match hir_def::VariantId::from(self.parent) {

+ hir_def::VariantId::EnumVariantId(id) => {

+ GenericDefId::AdtId(id.lookup(db).parent.into())

+ }

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

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

+ },

+ )

+ .store(),

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

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

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

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

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

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

+ self.id.lookup(db).container.krate(db),

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

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

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

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

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

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

+ db.layout_of_adt(adt_id, args.store(), param_env_from_has_crate(db, adt_id).store())

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

+ VariantDef::Struct(s) => (*s).name(db),

+ VariantDef::Union(u) => (*u).name(db),

+ VariantDef::Variant(e) => (*e).name(db),

+ fn id(&self) -> Option<DefWithBodyId> {

+ Some(match self {

+ DefWithBody::Function(it) => match it.id {

+ AnyFunctionId::FunctionId(id) => id.into(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => return None,

+ },

+ })

+ let Some(id) = self.id() else {

+ return String::new();

+ };

+ let body = db.body(id);

+ body.pretty_print(db, id, Edition::CURRENT)

+ let Some(id) = self.id() else {

+ return String::new();

+ };

+ let body = db.mir_body(id);

+ Ok(body) => body.pretty_print(db, self.module(db).krate(db).to_display_target(db)),

+ let Ok(id) = self.try_into() else {

+ return;

+ };

+ let krate = self.module(db).id.krate(db);

+ let (body, source_map) = db.body_with_source_map(id);

+ DefWithBody::Function(id) => match id.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature_with_source_map(id).1,

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => return,

+ },

+ Module { id: def_map.root_module_id() }.diagnostics(db, acc, style_lints);

+ let infer = InferenceResult::for_body(db, id);

+ id,

+ expected: Type::new(db, id, mismatch.expected.as_ref()),

+ actual: Type::new(db, id, mismatch.actual.as_ref()),

+ let missing_unsafe = hir_ty::diagnostics::missing_unsafe(db, id);

+ if let Ok(borrowck_results) = db.borrowck(id) {

+ acc.push(

+ MovedOutOfRef { ty: Type::new_for_crate(krate, moof.ty.as_ref()), span }

+ .into(),

+ )

+ let local = Local { parent: id, binding_id };

+ for diagnostic in BodyValidationDiagnostic::collect(db, id, style_lints) {

+ for diag in hir_ty::diagnostics::incorrect_case(db, id.into()) {

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

+

+enum AnyFunctionId {

+ FunctionId(FunctionId),

+ BuiltinDeriveImplMethod { method: BuiltinDeriveImplMethod, impl_: BuiltinDeriveImplId },

+}

+

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

+ pub(crate) id: AnyFunctionId,

+}

+

+impl fmt::Debug for Function {

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

+ fmt::Debug::fmt(&self.id, f)

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => id.module(db).into(),

+ AnyFunctionId::BuiltinDeriveImplMethod { impl_, .. } => impl_.module(db).into(),

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).name.clone(),

+ AnyFunctionId::BuiltinDeriveImplMethod { method, .. } => {

+ Name::new_symbol_root(method.name())

+ }

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => Type::from_value_def(db, id),

+ AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ } => {

+ // Get the type for the trait function, as we can't get the type for the impl function

+ // because it has not `CallableDefId`.

+ let krate = impl_.module(db).krate(db);

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

+ let param_env = hir_ty::builtin_derive::param_env(interner, impl_);

+ let env = ParamEnvAndCrate { param_env, krate };

+ let Some(trait_method) = method.trait_method(db, impl_) else {

+ return Type { env, ty: Ty::new_error(interner, ErrorGuaranteed) };

+ };

+ Function::from(trait_method).ty(db)

+ }

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => {

+ let resolver = id.resolver(db);

+ 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(id.into()).instantiate_identity();

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

+ Type::new_with_resolver_inner(db, &resolver, ty)

+ }

+ AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ } => {

+ struct ParamsShifter<'db> {

+ interner: DbInterner<'db>,

+ shift_by: i32,

+ }

+

+ impl<'db> TypeFolder<DbInterner<'db>> for ParamsShifter<'db> {

+ fn cx(&self) -> DbInterner<'db> {

+ self.interner

+ }

+

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

+ if let TyKind::Param(param) = ty.kind() {

+ Ty::new_param(

+ self.interner,

+ param.id,

+ param.index.checked_add_signed(self.shift_by).unwrap(),

+ )

+ } else {

+ ty.super_fold_with(self)

+ }

+ }

+

+ fn fold_const(

+ &mut self,

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

+ ) -> hir_ty::next_solver::Const<'db> {

+ if let ConstKind::Param(param) = ct.kind() {

+ hir_ty::next_solver::Const::new_param(

+ self.interner,

+ ParamConst {

+ id: param.id,

+ index: param.index.checked_add_signed(self.shift_by).unwrap(),

+ },

+ )

+ } else {

+ ct.super_fold_with(self)

+ }

+ }

+

+ fn fold_region(&mut self, r: Region<'db>) -> Region<'db> {

+ if let RegionKind::ReEarlyParam(param) = r.kind() {

+ Region::new_early_param(

+ self.interner,

+ EarlyParamRegion {

+ id: param.id,

+ index: param.index.checked_add_signed(self.shift_by).unwrap(),

+ },

+ )

+ } else {

+ r

+ }

+ }

+ }

+

+ // Get the type for the trait function, as we can't get the type for the impl function

+ // because it has not `CallableDefId`.

+ let krate = impl_.module(db).krate(db);

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

+ let param_env = hir_ty::builtin_derive::param_env(interner, impl_);

+ let env = ParamEnvAndCrate { param_env, krate };

+ let Some(trait_method) = method.trait_method(db, impl_) else {

+ return Type { env, ty: Ty::new_error(interner, ErrorGuaranteed) };

+ };

+ // The procedure works as follows: the method may have additional generic parameters (e.g. `Hash::hash()`),

+ // and we want them to be params of the impl method as well. So we start with the trait method identity

+ // args and extract from them the trait method own args. In parallel, we retrieve the impl trait ref.

+ // Now we can put our args as [...impl_trait_ref.args, ...trait_method_own_args], but we have one problem:

+ // the args in `trait_method_own_args` use indices appropriate for the trait method, which are not necessarily

+ // good for the impl method. So we shift them by `impl_generics_len - trait_generics_len`, which is essentially

+ // `impl_generics_len - impl_trait_ref.args.len()`.

+ let trait_method_fn_ptr = Ty::new_fn_ptr(

+ interner,

+ db.callable_item_signature(trait_method.into()).instantiate_identity(),

+ );

+ let impl_trait_ref =

+ hir_ty::builtin_derive::impl_trait(interner, impl_).instantiate_identity();

+ let trait_method_args =

+ GenericArgs::identity_for_item(interner, trait_method.into());

+ let trait_method_own_args = GenericArgs::new_from_iter(

+ interner,

+ trait_method_args.iter().skip(impl_trait_ref.args.len()),

+ );

+ let impl_params_count = hir_ty::builtin_derive::generic_params_count(db, impl_);

+ let shift_args_by = impl_params_count as i32 - impl_trait_ref.args.len() as i32;

+ let shifted_trait_method_own_args = trait_method_own_args

+ .fold_with(&mut ParamsShifter { interner, shift_by: shift_args_by });

+ let impl_method_args = GenericArgs::new_from_iter(

+ interner,

+ impl_trait_ref.args.iter().chain(shifted_trait_method_own_args),

+ );

+ let impl_method_fn_ptr =

+ EarlyBinder::bind(trait_method_fn_ptr).instantiate(interner, impl_method_args);

+ Type { env, ty: impl_method_fn_ptr }

+ }

+ }

+ }

+

+ fn fn_sig<'db>(self, db: &'db dyn HirDatabase) -> (ParamEnvAndCrate<'db>, PolyFnSig<'db>) {

+ let fn_ptr = self.fn_ptr_type(db);

+ let TyKind::FnPtr(sig_tys, hdr) = fn_ptr.ty.kind() else {

+ unreachable!();

+ };

+ (fn_ptr.env, sig_tys.with(hdr))

+ let (env, sig) = self.fn_sig(db);

+ Type { env, ty: sig.skip_binder().output() }

+ let ret_type = self.ret_type(db);

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

+ let args = self.adapt_generic_args(interner, generics);

+ ret_type.derived(EarlyBinder::bind(ret_type.ty).instantiate(interner, args))

+ }

+

+ fn adapt_generic_args<'db>(

+ self,

+ interner: DbInterner<'db>,

+ generics: impl Iterator<Item = Type<'db>>,

+ ) -> GenericArgs<'db> {

+ let generics = generics.map(|ty| ty.ty);

+ match self.id {

+ AnyFunctionId::FunctionId(id) => generic_args_from_tys(interner, id.into(), generics),

+ AnyFunctionId::BuiltinDeriveImplMethod { impl_, .. } => {

+ let impl_args = GenericArgs::identity_for_item(interner, impl_.into());

+ GenericArgs::new_from_iter(

+ interner,

+ impl_args.iter().chain(generics.map(Into::into)),

+ )

+ }

+ }

+ let AnyFunctionId::FunctionId(id) = self.id else {

+ return None;

+ };

+ let resolver = id.resolver(db);

+ let ret_ty =

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

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).has_self_param(),

+ AnyFunctionId::BuiltinDeriveImplMethod { method, .. } => match method {

+ BuiltinDeriveImplMethod::clone

+ | BuiltinDeriveImplMethod::fmt

+ | BuiltinDeriveImplMethod::hash

+ | BuiltinDeriveImplMethod::cmp

+ | BuiltinDeriveImplMethod::partial_cmp

+ | BuiltinDeriveImplMethod::eq => true,

+ BuiltinDeriveImplMethod::default => false,

+ },

+ }

+ self.has_self_param(db).then_some(SelfParam { func: self })

+ let (env, sig) = self.fn_sig(db);

+ let func = match self.id {

+ AnyFunctionId::FunctionId(id) => Callee::Def(CallableDefId::FunctionId(id)),

+ AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ } => {

+ Callee::BuiltinDeriveImplMethod { method, impl_ }

+ }

+ };

+ sig.skip_binder()

+ .map(|(idx, &ty)| Param { func: func.clone(), ty: Type { env, ty }, idx })

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).params.len(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => {

+ self.fn_sig(db).1.skip_binder().inputs().len()

+ }

+ }

+ let mut params = self.assoc_fn_params(db);

+ if self.has_self_param(db) {

+ params.remove(0);

+ }

+ params

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

+ let args = self.adapt_generic_args(interner, generics);

+ let params = self.params_without_self(db);

+ params

+ .into_iter()

+ .map(|param| Param {

+ func: param.func,

+ idx: param.idx,

+ ty: Type {

+ env: param.ty.env,

+ ty: EarlyBinder::bind(param.ty.ty).instantiate(interner, args),

+ },

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).is_const(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).is_async(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).is_varargs(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,

+ }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => match id.lookup(db).container {

+ ItemContainerId::ExternBlockId(id) => Some(ExternBlock { id }),

+ _ => None,

+ },

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => None,

+ 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).contains(AttrFlags::IS_TEST)

+ match self.id {

+ AnyFunctionId::FunctionId(id) => {

+ self.exported_main(db)

+ || self.module(db).is_crate_root(db)

+ && db.function_signature(id).name == sym::main

+ }

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => false,

+ }

+ }

+

+ fn attrs(self, db: &dyn HirDatabase) -> AttrFlags {

+ match self.id {

+ AnyFunctionId::FunctionId(id) => AttrFlags::query(db, id.into()),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => AttrFlags::empty(),

+ }

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

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

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

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

+ let AnyFunctionId::FunctionId(id) = self.id else {

+ return false;

+ };

+ let target_features = match caller.id {

+ AnyFunctionId::FunctionId(id) => hir_ty::TargetFeatures::from_fn(db, id),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => {

+ hir_ty::TargetFeatures::default()

+ }

+ };

+ id,

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.function_signature(id).has_body(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => true,

+ }

+ let AnyFunctionId::FunctionId(id) = self.id else {

+ };

+ let def_map = crate_def_map(db, HasModule::krate(&id, db));

+ def_map.fn_as_proc_macro(id).map(|id| Macro { id: id.into() })

+ ) -> Result<String, ConstEvalError> {

+ let AnyFunctionId::FunctionId(id) = self.id else {

+ return Err(ConstEvalError::MirEvalError(MirEvalError::NotSupported(

+ "evaluation of builtin derive impl methods is not supported".to_owned(),

+ )));

+ };

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

+ id.into(),

+ GenericArgs::empty(interner).store(),

+ ParamEnvAndCrate {

+ param_env: db.trait_environment(id.into()),

+ krate: id.module(db).krate(db),

+ }

+ .store(),

+ func: Function,

+ match self.func.id {

+ AnyFunctionId::FunctionId(id) => {

+ let func_data = db.function_signature(id);

+ func_data

+ .params

+ .first()

+ .map(|&param| match &func_data.store[param] {

+ TypeRef::Reference(ref_) => match ref_.mutability {

+ hir_def::type_ref::Mutability::Shared => Access::Shared,

+ hir_def::type_ref::Mutability::Mut => Access::Exclusive,

+ },

+ _ => Access::Owned,

+ })

+ .unwrap_or(Access::Owned)

+ }

+ AnyFunctionId::BuiltinDeriveImplMethod { method, .. } => match method {

+ BuiltinDeriveImplMethod::clone

+ | BuiltinDeriveImplMethod::fmt

+ | BuiltinDeriveImplMethod::hash

+ | BuiltinDeriveImplMethod::cmp

+ | BuiltinDeriveImplMethod::partial_cmp

+ | BuiltinDeriveImplMethod::eq => Access::Shared,

+ BuiltinDeriveImplMethod::default => {

+ unreachable!("this function does not have a self param")

+ }

+ },

+ }

+ self.func

+ let (env, sig) = self.func.fn_sig(db);

+ Type { env, ty: sig.skip_binder().inputs()[0] }

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

+ let args = self.func.adapt_generic_args(interner, generics);

+ let Type { env, ty } = self.ty(db);

+ Type { env, ty: EarlyBinder::bind(ty).instantiate(interner, args) }

+ match self.id {

+ AnyFunctionId::FunctionId(id) => db.assoc_visibility(id.into()),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => Visibility::Public,

+ }

+ let krate = loc.container.krate(db);

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

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

+ db.const_eval(self.id, GenericArgs::empty(interner), None).map(|it| EvaluatedConst {

+ const_: it,

+ def: self.id.into(),

+ ty,

+ })

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

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

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

+ }

+ AssocItemId::FunctionId(id) => Some(id.into()),

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

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

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

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

+ let expander = match self.id {

+ MacroId::Macro2Id(it) => it.lookup(db).expander,

+ MacroId::MacroRulesId(it) => it.lookup(db).expander,

+ MacroId::ProcMacroId(_) => return None,

+ };

+ match expander {

+ MacroExpander::BuiltInDerive(kind) => Some(BuiltinDeriveMacroKind(kind)),

+ _ => None,

+

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

+ let attrs = self.attrs(db);

+ MacroBraces::extract(attrs.attrs)

+ }

+}

+

+// Feature: Macro Brace Style Attribute

+// Crate authors can declare the preferred brace style for their macro. This will affect how completion

+// insert calls to it.

+//

+// This is only supported on function-like macros.

+//

+// To do that, insert the `#[rust_analyzer::macro_style(style)]` attribute on the macro (for proc macros,

+// insert it for the macro's function). `style` can be one of:

+//

+// - `braces` for `{...}` style.

+// - `brackets` for `[...]` style.

+// - `parentheses` for `(...)` style.

+//

+// Malformed attributes will be ignored without warnings.

+//

+// Note that users have no way to override this attribute, so be careful and only include things

+// users definitely do not want to be completed!

+

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

+pub enum MacroBraces {

+ Braces,

+ Brackets,

+ Parentheses,

+}

+

+impl MacroBraces {

+ fn extract(attrs: AttrFlags) -> Option<Self> {

+ if attrs.contains(AttrFlags::MACRO_STYLE_BRACES) {

+ Some(Self::Braces)

+ } else if attrs.contains(AttrFlags::MACRO_STYLE_BRACKETS) {

+ Some(Self::Brackets)

+ } else if attrs.contains(AttrFlags::MACRO_STYLE_PARENTHESES) {

+ Some(Self::Parentheses)

+ } else {

+ None

+ }

+ }

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

+pub struct BuiltinDeriveMacroKind(BuiltinDeriveExpander);

+

+ ItemInNs::Types(did) | ItemInNs::Values(did) => did.module(db).map(|m| m.krate(db)),

+ ItemInNs::Macros(id) => Some(id.module(db).krate(db)),

+ let AnyFunctionId::FunctionId(id) = self.id else {

+ return None;

+ };

+ as_extern_assoc_item(db, ExternAssocItem::Function, id)

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

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

+ match value {

+ method_resolution::CandidateId::FunctionId(id) => AssocItem::Function(id.into()),

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

+ }

+ }

+}

+

+ match self.id {

+ AnyFunctionId::FunctionId(id) => as_assoc_item(db, AssocItem::Function, id),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => Some(AssocItem::Function(self)),

+ }

+ AssocItem::Function(it) => match it.id {

+ AnyFunctionId::FunctionId(id) => id.lookup(db).container,

+ AnyFunctionId::BuiltinDeriveImplMethod { impl_, .. } => {

+ return AssocItemContainer::Impl(Impl {

+ id: AnyImplId::BuiltinDeriveImplId(impl_),

+ });

+ }

+ },

+ let Ok(id) = self.try_into() else {

+ // Let's pretend builtin derive impls don't have generic parameters.

+ return Vec::new();

+ };

+ let generics = db.generic_params(id);

+ let toc = TypeOrConstParam { id: TypeOrConstParamId { parent: id, local_id } };

+ let Ok(id) = self.try_into() else {

+ // Let's pretend builtin derive impls don't have generic parameters.

+ return Vec::new();

+ };

+ let generics = db.generic_params(id);

+ .map(|(local_id, _)| LifetimeParam { id: LifetimeParamId { parent: id, local_id } })

+ let Ok(id) = self.try_into() else {

+ // Let's pretend builtin derive impls don't have generic parameters.

+ return Vec::new();

+ };

+ let generics = db.generic_params(id);

+ id: TypeOrConstParamId { parent: id, local_id },

+ fn id(self) -> Option<GenericDefId> {

+ Some(match self {

+ GenericDef::Function(it) => match it.id {

+ AnyFunctionId::FunctionId(it) => it.into(),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => return None,

+ },

+ GenericDef::Impl(it) => match it.id {

+ AnyImplId::ImplId(it) => it.into(),

+ AnyImplId::BuiltinDeriveImplId(_) => return None,

+ },

+ })

+ let Some(def) = self.id() else { return };

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

+ env: ParamEnvAndCrate<'db>,

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

+ fn new_from_fn(

+ def: Function,

+ subst: GenericArgs<'db>,

+ env: ParamEnvAndCrate<'db>,

+ ) -> Option<Self> {

+ match def.id {

+ AnyFunctionId::FunctionId(def) => Some(Self::new(def.into(), subst, env)),

+ AnyFunctionId::BuiltinDeriveImplMethod { .. } => None,

+ }

+ }

+

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

+ DefWithBodyId::FunctionId(func) if self.is_self(db) => {

+ Some(SelfParam { func: func.into() })

+ }

+ let infer = InferenceResult::for_body(db, def);

+ let ty = infer.binding_ty(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)

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

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

+ rustc_type_ir::GenericArgKind::Type(it) if !it.is_ty_error() => {

+ self.attrs(db).is_unstable()

+ pub(crate) id: AnyImplId,

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

+ result.extend(module.scope.builtin_derive_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);

+ }

+ }

+ }

+ }

+ module.impl_defs(db)

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

+ 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: Either<&[ImplId], &[BuiltinDeriveImplId]>| match impls {

+ Either::Left(impls) => result.extend(impls.iter().copied().map(Impl::from)),

+ Either::Right(impls) => result.extend(impls.iter().copied().map(Impl::from)),

+ method_resolution::with_incoherent_inherent_impls(db, env.krate, &simplified_ty, |impls| {

+ extend_with_impls(Either::Left(impls))

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

+ InherentImpls::for_each_crate_and_block(

+ db,

+ module.krate(db),

+ module.block(db),

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

+ std::iter::successors(module.block(db), |block| block.loc(db).module.block(db))

+ .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| match impls {

+ Either::Left(impls) => all.extend(impls.iter().copied().map(Impl::from)),

+ Either::Right(impls) => all.extend(impls.iter().copied().map(Impl::from)),

+ });

+ };

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

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

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

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

+ handle_impls(impls);

+ match self.id {

+ AnyImplId::ImplId(id) => {

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

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

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

+ }

+ AnyImplId::BuiltinDeriveImplId(id) => {

+ let loc = id.loc(db);

+ let lang_items = hir_def::lang_item::lang_items(db, loc.adt.module(db).krate(db));

+ loc.trait_.get_id(lang_items).map(Trait::from)

+ }

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => {

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

+ let resolver = id.resolver(db);

+ Some(TraitRef::new_with_resolver(db, &resolver, trait_ref))

+ }

+ AnyImplId::BuiltinDeriveImplId(id) => {

+ let loc = id.loc(db);

+ let krate = loc.module(db).krate(db);

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

+ let env = ParamEnvAndCrate {

+ param_env: hir_ty::builtin_derive::param_env(interner, id),

+ krate,

+ };

+ let trait_ref =

+ hir_ty::builtin_derive::impl_trait(interner, id).instantiate_identity();

+ Some(TraitRef { env, trait_ref })

+ }

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => {

+ let resolver = id.resolver(db);

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

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

+ Type::new_with_resolver_inner(db, &resolver, ty)

+ }

+ AnyImplId::BuiltinDeriveImplId(id) => {

+ let loc = id.loc(db);

+ let krate = loc.module(db).krate(db);

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

+ let env = ParamEnvAndCrate {

+ param_env: hir_ty::builtin_derive::param_env(interner, id),

+ krate,

+ };

+ let ty = hir_ty::builtin_derive::impl_trait(interner, id)

+ .instantiate_identity()

+ .self_ty();

+ Type { env, ty }

+ }

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => {

+ id.impl_items(db).items.iter().map(|&(_, it)| it.into()).collect()

+ }

+ AnyImplId::BuiltinDeriveImplId(impl_) => impl_

+ .loc(db)

+ .trait_

+ .all_methods()

+ .iter()

+ .map(|&method| {

+ AssocItem::Function(Function {

+ id: AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ },

+ })

+ })

+ .collect(),

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => db.impl_signature(id).flags.contains(ImplFlags::NEGATIVE),

+ AnyImplId::BuiltinDeriveImplId(_) => false,

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => db.impl_signature(id).flags.contains(ImplFlags::UNSAFE),

+ AnyImplId::BuiltinDeriveImplId(_) => false,

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => id.module(db).into(),

+ AnyImplId::BuiltinDeriveImplId(id) => id.module(db).into(),

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => check_orphan_rules(db, id),

+ AnyImplId::BuiltinDeriveImplId(_) => true,

+ }

+ match self.id {

+ AnyImplId::ImplId(id) => id.impl_items(db).macro_calls.to_vec().into_boxed_slice(),

+ AnyImplId::BuiltinDeriveImplId(_) => Box::default(),

+ }

+ env: ParamEnvAndCrate<'db>,

+ let env = param_env_from_resolver(db, resolver);

+ TypeNs { env: self.env, ty }

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

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

+ let infer = InferenceResult::for_body(db, owner);

+ .map(|capture| ClosureCapture {

+ owner,

+ closure: id,

+ capture,

+ _marker: PhantomCovariantLifetime::new(),

+ })

+ let infer = InferenceResult::for_body(db, owner);

+ let env = body_param_env_from_has_crate(db, owner);

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

+ let infer = InferenceResult::for_body(db, owner);

+ info.1.into()

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

+ }

+}

+

+ capture: hir_ty::CapturedItem,

+ _marker: PhantomCovariantLifetime<'db>,

+ env: ParamEnvAndCrate<'db>,

+ let environment = param_env_from_resolver(db, resolver);

+ Type { env: empty_param_env(krate), ty }

+ let environment = param_env_from_resolver(db, &resolver);

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

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

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

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

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

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

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

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

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

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

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

+ 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 (fn_trait, sig) = hir_ty::callable_sig_from_fn_trait(self.ty, self.env, db)?;

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

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

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

+ fast_reject::simplify_type(

+ DbInterner::conjure(),

+ self.ty,

+ fast_reject::TreatParams::AsRigid,

+ )

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

+ autoderef(db, self.env, canonical)

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

+ };

+

+ method_resolution::with_incoherent_inherent_impls(

+ db,

+ self.env.krate,

+ &simplified_type,

+ &mut handle_impls,

+ );

+

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

+ InherentImpls::for_each_crate_and_block(

+ db,

+ module.krate(db),

+ module.block(db),

+ &mut |impls| {

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

+ },

+ );

+ .filter_map(move |arg| match arg.kind() {

+ rustc_type_ir::GenericArgKind::Type(ty) => {

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

+ }

+ rustc_type_ir::GenericArgKind::Const(const_) => {

+ rustc_type_ir::GenericArgKind::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(db));

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

+ let unstable_features =

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

+ let environment = param_env_from_resolver(db, resolver);

+ let ctx = MethodResolutionContext {

+ infcx: &infcx,

+ resolver,

+ param_env: environment.param_env,

+ 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: AnyFunctionId::FunctionId(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: AnyFunctionId::FunctionId(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)

+ }

+ }

+ },

+ );

+ }

+ }

+ })

+ .param_env

+ .clauses()

+ .iter()

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

+ ClauseKind::Trait(tr) if tr.self_ty() == ty => Some(tr.def_id().0),

+ _ => None,

+ })

+ Type { env: self.env, ty }

+ env: ParamEnvAndCrate<'db>,

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

+ let mut visitor = Visitor { db, env: self.env, callback, visited: FxHashSet::default() };

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

+ hir_ty::could_unify(db, self.env, &tys)

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

+ hir_ty::could_unify_deeply(db, self.env, &tys)

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

+ hir_ty::could_coerce(db, self.env, &tys)

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

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

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

+ env: ParamEnvAndCrate<'db>,

+ let environment = param_env_from_resolver(db, &resolver);

+ Type { env: self.env, ty: self.ty }

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

+ let trait_ref =

+ hir_ty::next_solver::TraitRef::new_from_args(infcx.interner, trait_.id.into(), args);

+ FnImpl(traits::FnTrait),

+ BuiltinDeriveImplMethod { method: BuiltinDeriveImplMethod, impl_: BuiltinDeriveImplId },

+ Callee::BuiltinDeriveImplMethod { method, impl_ } => CallableKind::Function(Function {

+ id: AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ },

+ }),

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

+ }

+ }

+

+ fn as_function(&self) -> Option<Function> {

+ match self.callee {

+ Callee::Def(CallableDefId::FunctionId(it)) => Some(it.into()),

+ Callee::BuiltinDeriveImplMethod { method, impl_ } => {

+ Some(Function { id: AnyFunctionId::BuiltinDeriveImplMethod { method, impl_ } })

+ }

+ _ => None,

+

+ if !self.is_bound_method {

+ return None;

+ }

+ let func = self.as_function()?;

+ ScopeDef::ModuleDef(it) => it.module(db).map(|m| m.krate(db)),

+ ScopeDef::GenericParam(it) => Some(it.module(db).krate(db)),

+ ScopeDef::AdtSelfType(it) => Some(it.module(db).krate(db)),

+ ScopeDef::Local(it) => Some(it.module(db).krate(db)),

+ ScopeDef::Label(it) => Some(it.module(db).krate(db)),

+ self.module(db).krate(db).into()

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.parent_def(db).module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ self.module(db).krate(db)

+ fn krate(&self, db: &dyn HirDatabase) -> Crate {

+ Module::krate(*self, db)

+ match def_map[self.id].parent {

+ Some(parent_id) => ItemContainer::Module(Module { id: parent_id }),

+ match self.id {

+ AnyFunctionId::FunctionId(id) => container_id_to_hir(id.lookup(db).container),

+ AnyFunctionId::BuiltinDeriveImplMethod { impl_, .. } => {

+ ItemContainer::Impl(Impl { id: AnyImplId::BuiltinDeriveImplId(impl_) })

+ }

+ }

+pub trait HasName {

+ fn name(&self, db: &dyn HirDatabase) -> Option<Name>;

+}

+

+macro_rules! impl_has_name {

+ ( $( $ty:ident ),* $(,)? ) => {

+ $(

+ impl HasName for $ty {

+ fn name(&self, db: &dyn HirDatabase) -> Option<Name> {

+ (*self).name(db).into()

+ }

+ }

+ )*

+ };

+}

+

+impl_has_name!(

+ ModuleDef,

+ Module,

+ Field,

+ Struct,

+ Union,

+ Enum,

+ Variant,

+ Adt,

+ VariantDef,

+ DefWithBody,

+ Function,

+ ExternCrateDecl,

+ Const,

+ Static,

+ Trait,

+ TypeAlias,

+ Macro,

+ ExternAssocItem,

+ AssocItem,

+ Local,

+ DeriveHelper,

+ ToolModule,

+ Label,

+ GenericParam,

+ TypeParam,

+ LifetimeParam,

+ ConstParam,

+ TypeOrConstParam,

+ InlineAsmOperand,

+);

+

+macro_rules! impl_has_name_no_db {

+ ( $( $ty:ident ),* $(,)? ) => {

+ $(

+ impl HasName for $ty {

+ fn name(&self, _db: &dyn HirDatabase) -> Option<Name> {

+ (*self).name().into()

+ }

+ }

+ )*

+ };

+}

+

+impl_has_name_no_db!(TupleField, StaticLifetime, BuiltinType, BuiltinAttr);

+

+impl HasName for Param<'_> {

+ fn name(&self, db: &dyn HirDatabase) -> Option<Name> {

+ self.name(db)

+ }

+}

+

+ ItemContainerId::ImplId(id) => ItemContainer::Impl(id.into()),

+ let mut module = &def_map[def_map.root_module_id()];

+ module = &def_map[res];

+fn param_env_from_resolver<'db>(

+ db: &'db dyn HirDatabase,

+ resolver: &Resolver<'_>,

+) -> ParamEnvAndCrate<'db> {

+ ParamEnvAndCrate {

+ param_env: resolver

+ .generic_def()

+ .map_or_else(ParamEnv::empty, |generic_def| db.trait_environment(generic_def)),

+ krate: resolver.krate(),

+ }

+}

+

+fn param_env_from_has_crate<'db>(

+ db: &'db dyn HirDatabase,

+ id: impl hir_def::HasModule + Into<GenericDefId> + Copy,

+) -> ParamEnvAndCrate<'db> {

+ ParamEnvAndCrate { param_env: db.trait_environment(id.into()), krate: id.krate(db) }

+}

+

+fn body_param_env_from_has_crate<'db>(

+ db: &'db dyn HirDatabase,

+ id: impl hir_def::HasModule + Into<DefWithBodyId> + Copy,

+) -> ParamEnvAndCrate<'db> {

+ ParamEnvAndCrate { param_env: db.trait_environment_for_body(id.into()), krate: id.krate(db) }

+}

+

+fn empty_param_env<'db>(krate: base_db::Crate) -> ParamEnvAndCrate<'db> {

+ ParamEnvAndCrate { param_env: ParamEnv::empty(), krate }

+}

+