use either::Either;

use hir_def::{

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

attrs::AttrFlags,

builtin_derive::BuiltinDeriveImplMethod,

hir::{

BindingAnnotation, BindingId, Expr, ExprId, ExprOrPatId, LabelId, Pat,

},

item_tree::ImportAlias,

lang_item::LangItemTarget,

},

per_ns::PerNs,

resolver::{HasResolver, Resolver},

src::HasSource as _,

visibility::visibility_from_ast,

};

Complete,

FindPathConfig,

attrs::{Docs, IsInnerDoc},

find_path::PrefixKind,

import_map,

lang_item::{LangItemEnum as LangItem, crate_lang_items},

Function(Function),

Adt(Adt),

// Can't be directly declared, but can be imported.

Const(Const),

Static(Static),

Trait(Trait),

Module,

Function,

Adt(Struct, Enum, Union),

Const,

Static,

Trait,

for ModuleDef

);

match var {

}

}

}

ModuleDef::Module(it) => it.parent(db),

ModuleDef::Function(it) => Some(it.module(db)),

ModuleDef::Adt(it) => Some(it.module(db)),

ModuleDef::Const(it) => Some(it.module(db)),

ModuleDef::Static(it) => Some(it.module(db)),

ModuleDef::Trait(it) => Some(it.module(db)),

ModuleDef::Adt(it) => it.name(db),

ModuleDef::Trait(it) => it.name(db),

ModuleDef::Function(it) => it.name(db),

ModuleDef::TypeAlias(it) => it.name(db),

ModuleDef::Static(it) => it.name(db),

ModuleDef::Macro(it) => it.name(db),

ModuleDef::Module(it) => it.id.into(),

ModuleDef::Const(it) => it.id.into(),

ModuleDef::Static(it) => it.id.into(),

ModuleDef::BuiltinType(_) | ModuleDef::Macro(_) => return Vec::new(),

};

ModuleDef::Function(it) => Some(it.into()),

ModuleDef::Const(it) => Some(it.into()),

ModuleDef::Static(it) => Some(it.into()),

ModuleDef::Module(_)

| ModuleDef::Adt(_)

ModuleDef::Trait(it) => Some(it.into()),

ModuleDef::TypeAlias(it) => Some(it.into()),

ModuleDef::Module(_)

| ModuleDef::Static(_)

| ModuleDef::Const(_)

| ModuleDef::BuiltinType(_)

}

}

pub fn attrs(&self, db: &dyn HirDatabase) -> Option<AttrsWithOwner> {

Some(match self {

ModuleDef::Module(it) => it.attrs(db),

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

ModuleDef::Adt(it) => it.attrs(db),

ModuleDef::Const(it) => it.attrs(db),

ModuleDef::Static(it) => it.attrs(db),

ModuleDef::Trait(it) => it.attrs(db),

ModuleDef::Static(it) => it.visibility(db),

ModuleDef::Trait(it) => it.visibility(db),

ModuleDef::TypeAlias(it) => it.visibility(db),

ModuleDef::Macro(it) => it.visibility(db),

ModuleDef::BuiltinType(_) => Visibility::Public,

}

ModuleDef::Adt(adt) => {

match adt {

Adt::Struct(s) => {

let source_map = &s.id.fields_with_source_map(db).1;

expr_store_diagnostics(db, acc, source_map);

push_ty_diagnostics(

);

}

Adt::Union(u) => {

let source_map = &u.id.fields_with_source_map(db).1;

expr_store_diagnostics(db, acc, source_map);

push_ty_diagnostics(

);

}

Adt::Enum(e) => {

let (variants, diagnostics) = e.id.enum_variants_with_diagnostics(db);

let file = e.id.lookup(db).id.file_id;

let ast_id_map = db.ast_id_map(file);

}

ModuleDef::Macro(m) => emit_macro_def_diagnostics(db, acc, m),

ModuleDef::TypeAlias(type_alias) => {

push_ty_diagnostics(

db,

acc,

db.type_for_type_alias_with_diagnostics(type_alias.id).1,

);

acc.extend(def.diagnostics(db, style_lints));

}

continue;

};

let loc = impl_id.lookup(db);

let file_id = loc.id.file_id;

if file_id.macro_file().is_some_and(|it| it.kind(db) == MacroKind::DeriveBuiltIn) {

if let (false, Some(trait_)) = (impl_is_negative, trait_) {

let items = &trait_.id.trait_items(db).items;

let required_items = items.iter().filter(|&(_, assoc)| match *assoc {

});

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

let self_ty = structurally_normalize_ty(

&infcx,

self_ty,

);

let self_ty_is_guaranteed_unsized = matches!(

self_ty.kind(),

continue;

}

return false;

}

}

impl_assoc_items_scratch.clear();

}

push_ty_diagnostics(

db,

acc,

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

);

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

let file_id = loc.kind.file_id();

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

let RenderedExpandError { message, error, kind } = err.render_to_string(db);

range.value = err.span().range

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

}

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

pub struct Field {

pub(crate) id: LocalFieldId,

}

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

pub struct TupleField {

pub tuple: TupleId,

pub index: u32,

}

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

let interner = DbInterner::new_no_crate(db);

.tuple_field_access_type(self.tuple)

.as_slice()

.get(self.index as usize)

) -> Type<'db> {

let var_id = self.parent.into();

let def_id: AdtId = match self.parent {

};

let interner = DbInterner::new_no_crate(db);

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

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

}

self.parent

}

}

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

impl Union {

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

}

pub fn num_variants(self, db: &dyn HirDatabase) -> usize {

}

}

DefWithBodyId::VariantId(v.into())

}

}

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

pub(crate) id: EnumVariantId,

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

Module { id: self.id.module(db) }

}

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

}

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

// FIXME: Rename to `EnumVariant`

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

pub struct InstantiatedVariant<'db> {

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

}

}

/// Variants inherit visibility from the parent enum.

fn visibility(&self, db: &dyn HirDatabase) -> Visibility {

self.parent_enum(db).visibility(db)

}

}

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

Struct(Struct),

Union(Union),

}

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

match self {

}

}

pub fn module(self, db: &dyn HirDatabase) -> Module {

match self {

}

}

pub fn name(&self, db: &dyn HirDatabase) -> Name {

match self {

}

}

}

Function(Function),

Static(Static),

Const(Const),

}

impl DefWithBody {

pub fn module(self, db: &dyn HirDatabase) -> Module {

DefWithBody::Const(c) => c.module(db),

DefWithBody::Function(f) => f.module(db),

DefWithBody::Static(s) => s.module(db),

}

}

DefWithBody::Function(f) => Some(f.name(db)),

DefWithBody::Static(s) => Some(s.name(db)),

DefWithBody::Const(c) => c.name(db),

}

}

DefWithBody::Function(it) => it.ret_type(db),

DefWithBody::Static(it) => it.ty(db),

DefWithBody::Const(it) => it.ty(db),

}

}

},

DefWithBody::Static(it) => it.id.into(),

DefWithBody::Const(it) => it.id.into(),

})

}

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

return String::new();

};

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

}

};

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

let sig_source_map = match self {

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

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

},

let enum_id = variant.parent_enum(db).id;

}

};

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

}

for d in infer.diagnostics() {

}

for (pat_or_expr, mismatch) in infer.type_mismatches() {

{

need_mut = &mir::MutabilityReason::Not;

}

let is_mut = body[binding_id].mode == BindingAnnotation::Mutable;

match (need_mut, is_mut) {

}

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

}

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

acc.push(diag.into())

}

}

}

fn expr_store_diagnostics<'db>(

pub fn name(self, db: &dyn HirDatabase) -> Name {

match self.id {

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

Name::new_symbol_root(method.name())

}

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

match self.id {

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

BuiltinDeriveImplMethod::clone

| BuiltinDeriveImplMethod::fmt

pub fn num_params(self, db: &dyn HirDatabase) -> usize {

match self.id {

AnyFunctionId::BuiltinDeriveImplMethod { .. } => {

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

}

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

match self.id {

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

}

}

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

match self.id {

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

}

}

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

match self.id {

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

}

}

AnyFunctionId::FunctionId(id) => {

self.exported_main(db)

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

}

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

}

/// This is false in the case of required (not provided) trait methods.

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

match self.id {

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

}

}

id.into(),

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

ParamEnvAndCrate {

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

}

.store(),

match self.func {

Callee::Def(CallableDefId::FunctionId(it)) => {

let parent = DefWithBodyId::FunctionId(it);

if let Some(self_param) = body.self_param.filter(|_| self.idx == 0) {

} else if let Pat::Bind { id, .. } =

&body[body.params[self.idx - body.self_param.is_some() as usize]]

{

} else {

None

}

}

Callee::Closure(closure, _) => {

let c = db.lookup_intern_closure(closure);

{

}

None

}

pub fn access(self, db: &dyn HirDatabase) -> Access {

match self.func.id {

AnyFunctionId::FunctionId(id) => {

func_data

.params

.first()

}

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

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

}

pub fn value(self, db: &dyn HirDatabase) -> Option<ast::Expr> {

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

pub fn direct_supertraits(self, db: &dyn HirDatabase) -> Vec<Trait> {

}

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

}

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

}

pub fn type_or_const_param_count(

db: &dyn HirDatabase,

count_required_only: bool,

) -> usize {

.iter_type_or_consts()

.filter(|(_, ty)| !matches!(ty, TypeOrConstParamData::TypeParamData(ty) if ty.provenance != TypeParamProvenance::TypeParamList))

.filter(|(_, ty)| !count_required_only || !ty.has_default())

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

}

match self {

DefWithBody::Function(it) => it.as_assoc_item(db),

DefWithBody::Const(it) => it.as_assoc_item(db),

}

}

}

db,

acc,

db.type_for_type_alias_with_diagnostics(type_alias.id).1,

);

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

acc.push(diag.into());

);

impl GenericDef {

pub fn params(self, db: &dyn HirDatabase) -> Vec<GenericParam> {

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

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

return Vec::new();

};

let ty_params = generics.iter_type_or_consts().map(|(local_id, _)| {

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

match toc.split(db) {

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

return Vec::new();

};

generics

.iter_lt()

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

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

return Vec::new();

};

generics

.iter_type_or_consts()

.map(|(local_id, _)| TypeOrConstParam {

pub fn diagnostics<'db>(self, db: &'db dyn HirDatabase, acc: &mut Vec<AnyDiagnostic<'db>>) {

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

if generics.is_empty() && generics.has_no_predicates() {

return;

}

let source_map = match def {

GenericDefId::ConstId(_) => return,

GenericDefId::StaticId(_) => return,

};

push_ty_diagnostics(

db,

acc,

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

);

for (param_id, param) in generics.iter_type_or_consts() {

if let TypeOrConstParamData::ConstParamData(_) = param {

TypeOrConstParamId { parent: def, local_id: param_id },

))

.1,

);

}

}

_ => None,

})

.map(|container| {

.iter_type_or_consts()

.filter_map(|param| match param.1 {

TypeOrConstParamData::TypeParamData(param) => Some(param.name.clone()),

})

.collect::<Vec<_>>()

});

let type_params = generics.iter_type_or_consts().filter_map(|param| match param.1 {

TypeOrConstParamData::TypeParamData(param) => Some(param.name.clone()),

TypeOrConstParamData::ConstParamData(_) => None,

/// A single local definition.

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

pub struct Local {

pub(crate) binding_id: BindingId,

}

pub fn as_self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {

match self.parent {

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

}

_ => None,

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

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

}

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

}

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

}

self.parent.into()

}

self.parent(db).module(db)

}

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

let def = self.parent;

let ty = infer.binding_ty(self.binding_id);

Type::new(db, def, ty)

}

/// All definitions for this local. Example: `let (a$0, _) | (_, a$0) = it;`

pub fn sources(self, db: &dyn HirDatabase) -> Vec<LocalSource> {

}

local: self,

}

/// The leftmost definition for this local. Example: `let (a$0, _) | (_, a) = it;`

pub fn primary_source(self, db: &dyn HirDatabase) -> LocalSource {

LocalSource {

local: self,

}

}

}

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

pub struct Label {

pub(crate) label_id: LabelId,

}

self.parent(db).module(db)

}

self.parent.into()

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

}

}

/// Is this type parameter implicitly introduced (eg. `Self` in a trait or an `impl Trait`

/// argument)?

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

let data = &params[self.id.local_id()];

match data.type_param().unwrap().provenance {

TypeParamProvenance::TypeParamList => false,

impl LifetimeParam {

pub fn name(self, db: &dyn HirDatabase) -> Name {

params[self.id.local_id].name.clone()

}

}

pub fn name(self, db: &dyn HirDatabase) -> Name {

match params[self.id.local_id()].name() {

Some(it) => it.clone(),

None => {

impl TypeOrConstParam {

pub fn name(self, db: &dyn HirDatabase) -> Name {

match params[self.id.local_id].name() {

Some(n) => n.clone(),

_ => Name::missing(),

}

pub fn split(self, db: &dyn HirDatabase) -> Either<ConstParam, TypeParam> {

match &params[self.id.local_id] {

TypeOrConstParamData::TypeParamData(_) => {

Either::Right(TypeParam { id: TypeParamId::from_unchecked(self.id) })

}

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

match &params[self.id.local_id] {

TypeOrConstParamData::TypeParamData(_) => {

Some(TypeParam { id: TypeParamId::from_unchecked(self.id) })

}

pub fn as_const_param(self, db: &dyn HirDatabase) -> Option<ConstParam> {

match &params[self.id.local_id] {

TypeOrConstParamData::TypeParamData(_) => None,

TypeOrConstParamData::ConstParamData(_) => {

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

for unnamed_const in module.scope.unnamed_consts() {

extend_with_def_map(db, block_def_map, result);

}

}

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

match self.id {

AnyImplId::BuiltinDeriveImplId(_) => false,

}

}

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

match self.id {

AnyImplId::BuiltinDeriveImplId(_) => false,

}

}

return Vec::new();

};

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

let info = infer.closure_info(id);

info.0

.iter()

return Vec::new();

};

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

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

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

}

match self.id {

AnyClosureId::ClosureId(id) => {

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

let info = infer.closure_info(id);

info.1.into()

}

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

pub struct ClosureCapture<'db> {

closure: InternedClosureId,

capture: hir_ty::CapturedItem,

_marker: PhantomCovariantLifetime<'db>,

#[derive(Debug, Clone)]

pub struct CaptureUsages {

spans: SmallVec<[mir::MirSpan; 3]>,

}

impl CaptureUsages {

pub fn sources(&self, db: &dyn HirDatabase) -> Vec<CaptureUsageSource> {

let mut result = Vec::with_capacity(self.spans.len());

for &span in self.spans.iter() {

match span {

mir::MirSpan::ExprId(expr) => {

if let Ok(expr) = source_map.expr_syntax(expr) {

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

match adt_id {

AdtId::StructId(s) => {

flags.contains(StructFlags::IS_PHANTOM_DATA)

}

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

) -> R {

let module = resolver.module();

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

let unstable_features =

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

let environment = param_env_from_resolver(db, resolver);

match name {

Some(name) => {

Ok(candidate)

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

let id = candidate.item.into();

Some(adt.into())

}

pub fn as_builtin(&self) -> Option<BuiltinType> {

self.ty.as_builtin().map(|inner| BuiltinType { inner })

}

self.autoderef_(db)

.filter_map(|ty| ty.dyn_trait())

.flat_map(move |dyn_trait_id| hir_ty::all_super_traits(db, dyn_trait_id))

.map(Trait::from)

}

_ => None,

})

.flat_map(|t| hir_ty::all_super_traits(db, t))

})

.map(Trait::from)

}

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

pub struct InlineAsmOperand {

expr: ExprId,

index: usize,

}

impl InlineAsmOperand {

self.owner.into()

}

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

hir_def::hir::Expr::InlineAsm(e) => e.operands.get(self.index)?.0.clone(),

_ => None,

}

pub enum CallableKind<'db> {

Function(Function),

TupleStruct(Struct),

Closure(Closure<'db>),

FnPtr,

FnImpl(FnTrait),

}

}

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

self.module(db).krate(db)

}

Struct,

Union,

Enum,

Adt,

DefWithBody,

Function,

ExternCrateDecl,

}

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

let defaults = db.generic_defaults(generic_def);

params

.iter_type_or_consts()

ParamEnvAndCrate {

param_env: resolver

.generic_def()

krate: resolver.krate(),

}

}

db: &'db dyn HirDatabase,

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

) -> ParamEnvAndCrate<'db> {

}

fn body_param_env_from_has_crate<'db>(

db: &'db dyn HirDatabase,

) -> ParamEnvAndCrate<'db> {

}

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