TypeAliasSignature, UnionSignature, VariantFields,

},

src::HasSource as _,

visibility::visibility_from_ast,

};

use hir_expand::{

proc_macro::ProcMacroKind,

};

use hir_ty::{

consteval::try_const_usize,

diagnostics::BodyValidationDiagnostic,

direct_super_traits, known_const_to_ast,

layout::{Layout as TyLayout, RustcEnumVariantIdx, RustcFieldIdx, TagEncoding},

mir::interpret_mir,

next_solver::{

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

use rustc_type_ir::{

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

TypeVisitor, fast_reject,

};

use span::{AstIdNode, Edition, FileId};

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

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

format_smolstr,

};

use crate::db::{DefDatabase, HirDatabase};

// FIXME: Properly encapsulate mir

hir_ty::mir,

hir_ty::{

consteval::ConstEvalError,

diagnostics::UnsafetyReason,

display::{ClosureStyle, DisplayTarget, HirDisplay, HirDisplayError, HirWrite},

hir_def::expr_store::path::Path,

hir_expand::{

name::AsName,

},

};

}

pub fn is_unstable_feature_enabled(self, db: &dyn HirDatabase, feature: &Symbol) -> bool {

}

}

push_ty_diagnostics(

db,

acc,

source_map,

);

}

push_ty_diagnostics(

db,

acc,

source_map,

);

}

push_ty_diagnostics(

db,

acc,

source_map,

);

expr_store_diagnostics(db, acc, source_map);

push_ty_diagnostics(

db,

acc,

source_map,

);

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

}

let drop_maybe_dangle = (|| {

let trait_ = trait_?;

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

if drop_trait != trait_.into() {

.collect();

if !missing.is_empty() {

let self_ty = structurally_normalize_ty(

&infcx,

self_ty,

// relationship here would be significantly more expensive.

if !missing.is_empty() {

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

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

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

return true;

impl_assoc_items_scratch.clear();

}

push_ty_diagnostics(

db,

acc,

source_map,

);

let Some(e) = db.parse_macro_expansion_error(macro_call_id) else {

return;

};

if let Some(err) = err {

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

}

if !parse_errors.is_empty() {

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

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

}

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

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

TypeNs::new(db, var_id, ty)

}

}

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

pub struct TupleField {

pub tuple: TupleId,

pub index: u32,

}

.get(self.index as usize)

.copied()

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

}

}

};

let interner = DbInterner::new_no_crate(db);

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

Type::new(db, var_id, ty)

}

db.layout_of_ty(

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

param_env_from_has_crate(

}

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

InstantiatedStruct { inner: self, args }

}

}

let interner = DbInterner::new_no_crate(db);

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

}

}

self.variants(db).iter().any(|v| !matches!(v.kind(db), StructKind::Unit))

}

Adt::from(self).layout(db)

}

let interner = DbInterner::new_no_crate(db);

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

}

}

db.const_eval_discriminant(self.into())

}

let parent_enum = self.parent_enum(db);

let parent_layout = parent_enum.layout(db)?;

Ok(match &parent_layout.0.variants {

}

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

InstantiatedVariant { inner: self, args }

}

}

has_non_default_type_params(db, self.into())

}

let interner = DbInterner::new_no_crate(db);

let adt_id = AdtId::from(self);

let args = GenericArgs::for_item_with_defaults(interner, adt_id.into(), |_, id, _| {

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

}

}

}

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

})

}

/// A textual representation of the HIR of this def's body for debugging purposes.

pub fn debug_hir(self, db: &dyn HirDatabase) -> String {

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

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

return String::new();

};

match body {

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

Err(e) => format!("error:\n{e:?}"),

return;

};

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

let (body, source_map) = Body::with_source_map(db, id);

let sig_source_map = match self {

let infer = InferenceResult::of(db, id);

for d in infer.diagnostics() {

}

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

}

}

for borrowck_result in borrowck_results.iter() {

for moof in &borrowck_result.moved_out_of_ref {

let span: InFile<SyntaxNodePtr> = match moof.span {

mir::MirSpan::ExprId(e) => match source_map.expr_syntax(e) {

{

need_mut = &mir::MutabilityReason::Not;

}

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

match (need_mut, is_mut) {

ExpressionStoreDiagnostics::UndeclaredLabel { node, name } => {

UndeclaredLabel { node: *node, name: name.clone() }.into()

}

});

}

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 ty = Ty::new_fn_ptr(interner, callable_sig);

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

}

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

let trait_method_fn_ptr = Ty::new_fn_ptr(

interner,

);

let trait_method_args =

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

let trait_method_own_args = GenericArgs::new_from_iter(

interner,

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

);

Type { env, ty: impl_method_fn_ptr }

}

}

let ret_type = self.ret_type(db);

let interner = DbInterner::new_no_crate(db);

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

}

fn adapt_generic_args<'db>(

idx: param.idx,

ty: Type {

env: param.ty.env,

},

})

.collect()

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

let parent = DefWithBodyId::FunctionId(it);

let body = Body::of(db, parent);

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

{

} else {

None

}

}

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

let c = closure.loc(db);

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

{

}

None

}

let interner = DbInterner::new_no_crate(db);

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

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

}

}

/// Evaluate the constant.

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 {

allocation: it,

def: self.id.into(),

}

pub struct EvaluatedConst<'db> {

allocation: hir_ty::next_solver::Allocation<'db>,

ty: Ty<'db>,

}

/// Evaluate the static initializer.

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

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

allocation: it,

def: self.id.into(),

push_ty_diagnostics(

db,

acc,

&TypeAliasSignature::with_source_map(db, type_alias.id).1,

);

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

};

expr_store_diagnostics(db, acc, source_map);

push_ty_diagnostics(

db,

acc,

source_map,

);

}

/// Returns a string describing the kind of this type.

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

pub struct Local {

pub(crate) parent: ExpressionStoreOwnerId,

pub(crate) binding_id: BindingId,

}

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)

}

}

ExpressionStoreOwnerId::Body(def_with_body_id) => {

b = Body::with_source_map(db, def_with_body_id);

{

let root = source.file_syntax(db);

return vec![LocalSource {

}

ExpressionStoreOwnerId::Body(def_with_body_id) => {

b = Body::with_source_map(db, def_with_body_id);

{

let root = source.file_syntax(db);

return LocalSource {

GenericParam::ConstParam(_) => return None,

GenericParam::LifetimeParam(it) => it.id.parent,

};

let index = match self {

GenericParam::ConstParam(_) => return None,

};

}

}

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

let resolver = self.id.parent().resolver(db);

let interner = DbInterner::new_no_crate(db);

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

}

}

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

}

self,

db: &dyn HirDatabase,

) -> Option<ast::ConstArg> {

let arg = generic_arg_from_param(db, self.id.into())?;

}

}

fn generic_arg_from_param(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<GenericArg<'_>> {

let defaults = db.generic_defaults(id.parent);

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

}

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

pub fn trait_ref(self, db: &dyn HirDatabase) -> Option<TraitRef<'_>> {

match self.id {

AnyImplId::ImplId(id) => {

let resolver = id.resolver(db);

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

}

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

krate,

};

Some(TraitRef { env, trait_ref })

}

}

AnyImplId::ImplId(id) => {

let resolver = id.resolver(db);

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

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

}

AnyImplId::BuiltinDeriveImplId(id) => {

};

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

.instantiate_identity()

.self_ty();

Type { env, ty }

}

AnyClosureId::ClosureId(it) => it.loc(db),

AnyClosureId::CoroutineClosureId(it) => it.loc(db),

};

let param_env = body_param_env_from_has_crate(db, owner);

infer.closures_data[&closure]

.min_captures

.values()

.flatten()

.collect()

}

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

pub struct ClosureCapture<'db> {

owner: ExpressionStoreOwnerId,

closure: ExprId,

capture: &'db hir_ty::closure_analysis::CapturedPlace,

param_env: ParamEnvAndCrate<'db>,

impl<'db> ClosureCapture<'db> {

pub fn local(&self) -> Local {

}

/// Returns whether this place has any field (aka. non-deref) projections.

match ty.kind() {

TyKind::Tuple(_) => format_to!(result, "_{field_idx}"),

TyKind::Adt(adt_def, _) => {

AdtId::StructId(id) => VariantId::from(id),

AdtId::UnionId(id) => id.into(),

AdtId::EnumId(id) => {

match ty.kind() {

TyKind::Tuple(_) => format_to!(result, ".{field_idx}"),

TyKind::Adt(adt_def, _) => {

AdtId::StructId(id) => VariantId::from(id),

AdtId::UnionId(id) => id.into(),

AdtId::EnumId(id) => {

}

};

let args = GenericArgs::error_for_item(interner, def.into());

}

// FIXME: We shouldn't leak `TyKind::Param`s.

fn from_def_params(db: &'db dyn HirDatabase, def: impl Into<TyDefId> + HasResolver) -> Self {

let ty = db.ty(def.into());

}

fn from_value_def(

}

};

let args = GenericArgs::error_for_item(interner, def.into());

}

pub fn new_slice(ty: Self) -> Self {

// For non-phantom_data adts we check variants/fields as well as generic parameters

TyKind::Adt(adt_def, args)

{

let _variant_id_to_fields = |id: VariantId| {

let variant_data = &id.fields(self.interner.db());

.fields()

.iter()

.map(|(idx, _)| {

})

.filter(|it| !it.references_non_lt_error())

.collect()

};

let variant_id_to_fields = |_: VariantId| vec![];

AdtId::StructId(id) => {

vec![variant_id_to_fields(id.into())]

}

/// This function is used in `.await` syntax completion.

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

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

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

return None;

}

self.normalize_trait_assoc_type(db, &[], output_assoc_type.into())

}

/// This does **not** resolve `IntoIterator`, only `Iterator`.

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

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

self.normalize_trait_assoc_type(db, &[], iterator_item.into())

}

/// Resolves the projection `<Self as IntoIterator>::IntoIter` and returns the resulting type

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

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

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

return None;

}

self.normalize_trait_assoc_type(db, &[], into_iter_assoc_type.into())

}

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

let adt_id = match self.ty.kind() {

_ => return false,

};

let interner = DbInterner::new_no_crate(db);

let (variant_id, substs) = match self.ty.kind() {

TyKind::Adt(adt_def, substs) => {

AdtId::StructId(id) => id.into(),

AdtId::UnionId(id) => id.into(),

AdtId::EnumId(_) => return Vec::new(),

.iter()

.map(|(local_id, ty)| {

let def = Field { parent: variant_id.into(), id: local_id };

(def, self.derived(ty))

})

.collect()

TypingMode::non_body_analysis()

};

let infcx = interner.infer_ctxt().build(typing_mode);

let environment = param_env_from_resolver(db, resolver);

let ctx = MethodResolutionContext {

infcx: &infcx,

param_env: environment.param_env,

traits_in_scope,

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

};

f(&ctx)

}

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

match name {

Some(name) => {

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

match name {

Some(name) => {

else {

return None;

};

ItemContainerId::TraitId(id) => Some(Trait { id }),

_ => None,

}

.collect()

}

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

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

}

);

let trait_ref =

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

infcx.interner,

);

}

pub fn is_bool(&self) -> bool {

}

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

pub fn size(&self) -> u64 {

self.0.size.bytes()

}

}

pub fn niches(&self) -> Option<u128> {

}

pub fn field_offset(&self, field: Field) -> Option<u64> {

let tag_size =

if let layout::Variants::Multiple { tag, tag_encoding, .. } = &self.0.variants {

match tag_encoding {

TagEncoding::Niche { .. } => 0,

}

} else {

}

}

/// Trait for obtaining the defining crate of an item.

pub trait HasCrate {

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

}

}

pub trait HasContainer {

fn container(&self, db: &dyn HirDatabase) -> ItemContainer;

}

fn push_ty_diagnostics<'db>(

db: &'db dyn HirDatabase,

acc: &mut Vec<AnyDiagnostic<'db>>,

source_map: &ExpressionStoreSourceMap,

) {

}

pub trait MethodCandidateCallback {

.filter(|(_, param)| matches!(param, TypeOrConstParamData::TypeParamData(_)))

.map(|(local_id, _)| TypeOrConstParamId { parent: generic_def, local_id })

.any(|param| {

})

}

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

}

pub use hir_ty::next_solver;

pub use hir_ty::setup_tracing;