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

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

+ builtin_derive::BuiltinDeriveImplMethod,

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

+ proc_macro::ProcMacroKind,

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

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

+ RegionKind, SolverDefId, Ty, TyKind, TypingMode,

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

+ TypeVisitor, fast_reject,

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

+ {GenericParamId, ModuleDefId, TraitId},

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

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

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

+ },

+ ModuleDef::Function(it) => HasAttrs::attrs(*it, 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() {

+ let trait_impl = impl_signature.target_trait.is_some();

+ if !trait_impl && !is_inherent_impl_coherent(db, def_map, impl_id) {

+ if trait_impl && !impl_def.check_orphan_rules(db) {

+ let trait_ = trait_impl.then(|| impl_def.trait_(db)).flatten();

+ let trait_is_unresolved = trait_.is_none() && trait_impl;

+ let parent = impl_id.into();

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

+ },

+ },

+ // HACK: When specialization is enabled in the current crate, and there exists

+ // *any* blanket impl that provides a default implementation for the missing item,

+ // suppress the missing associated item diagnostic.

+ // This can lead to false negatives when the impl in question does not actually

+ // specialize that blanket impl, but determining the exact specialization

+ // relationship here would be significantly more expensive.

+ if !missing.is_empty() {

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

+ let def_map = crate_def_map(db, krate);

+ if def_map.is_unstable_feature_enabled(&sym::specialization)

+ || def_map.is_unstable_feature_enabled(&sym::min_specialization)

+ {

+ missing.retain(|(assoc_name, assoc_item)| {

+ let AssocItem::Function(_) = assoc_item else {

+ return true;

+ };

+

+ for &impl_ in TraitImpls::for_crate(db, krate).blanket_impls(trait_.id)

+ {

+ if impl_ == impl_id {

+ continue;

+ }

+

+ for (name, item) in &impl_.impl_items(db).items {

+ let AssocItemId::FunctionId(fn_) = item else {

+ continue;

+ };

+ if name != assoc_name {

+ continue;

+ }

+

+ if db.function_signature(*fn_).is_default() {

+ return false;

+ }

+ }

+ }

+

+ true

+ });

+ }

+ }

+

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

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

+ )

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

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

+ return;

+ };

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

+ },

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

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

+

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

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

+ return None;

+ };

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

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

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

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

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

+ )));

+ };

+ id.into(),

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

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

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

+ }

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

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

+

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

+ return None;

+ };

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

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

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

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

+ }

+ }

+

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

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

+ }

+ pub(crate) id: AnyImplId,

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

+ module.impl_defs(db)

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

+ });

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

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

+ });

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

+ }

+ let id = Function { id: AnyFunctionId::FunctionId(id) };

+ let id = Function { id: AnyFunctionId::FunctionId(id) };

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

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

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

+ }),

+

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

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