//! The implementation of `RustIrDatabase` for Chalk, which provides information

//! about the code that Chalk needs.

pub(crate) type AssocTypeId = chalk_ir::AssocTypeId<Interner>;

pub(crate) type TraitId = chalk_ir::TraitId<Interner>;

pub(crate) type AdtId = chalk_ir::AdtId<Interner>;

pub(crate) type ImplId = chalk_ir::ImplId<Interner>;

pub(crate) type Variances = chalk_ir::Variances<Interner>;

impl chalk_ir::UnificationDatabase<Interner> for &dyn HirDatabase {

}

}

pub(crate) fn fn_def_variance_query(

db: &dyn HirDatabase,

callable_def: CallableDefId,

.map(|pred| pred.substitute(Interner, substs))

.collect()

}

use crate::{

Const, ConstData, ConstScalar, ConstValue, GenericArg, Interner, MemoryMap, Substitution,

};

use super::mir::{MirEvalError, MirLowerError, interpret_mir, lower_to_mir, pad16};

ty: Ty,

krate: Crate,

) -> Const {

let bytes = match value {

LiteralConstRef::Int(i) => {

// FIXME: We should handle failure of layout better.

#[track_caller]

fn check_answer(

#[rust_analyzer::rust_fixture] ra_fixture: &str,

) {

let (db, file_ids) = TestDB::with_many_files(ra_fixture);

let file_id = *file_ids.last().unwrap();

krate: Crate,

) -> Const<'a> {

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

let kind = match value {

LiteralConstRef::Int(i) => {

// FIXME: We should handle failure of layout better.

)

}

let interner = DbInterner::new_with(db, None, None);

ConstKind::Param(_) => None,

ConstKind::Infer(_) => None,

ConstKind::Bound(_, _) => None,

};

let subst = convert_args_for_result(interner, unevaluated_const.args.as_slice());

let ec = db.const_eval(c, subst, None).ok()?.to_nextsolver(interner);

}

ConstKind::Value(val) => Some(u128::from_le_bytes(pad16(&val.value.inner().0, false))),

ConstKind::Error(_) => None,

let c = if is_signed {

try_const_isize(db, &c).unwrap()

} else {

};

Ok(c)

}

//! The home of `HirDatabase`, which is the Salsa database containing all the

//! type inference-related queries.

use base_db::Crate;

use hir_def::{

AdtId, BlockId, CallableDefId, ConstParamId, DefWithBodyId, EnumVariantId, FunctionId,

#[salsa::invoke(crate::layout::layout_of_adt_query)]

#[salsa::cycle(cycle_result = crate::layout::layout_of_adt_cycle_result)]

def: AdtId,

) -> Result<Arc<Layout>, LayoutError>;

#[salsa::invoke(crate::layout::layout_of_ty_query)]

#[salsa::cycle(cycle_result = crate::layout::layout_of_ty_cycle_result)]

#[salsa::invoke(crate::layout::target_data_layout_query)]

fn target_data_layout(&self, krate: Crate) -> Result<Arc<TargetDataLayout>, Arc<str>>;

#[salsa::invoke(crate::lower::generic_predicates_query)]

fn generic_predicates(&self, def: GenericDefId) -> GenericPredicates;

#[salsa::invoke(crate::lower::trait_environment_for_body_query)]

#[salsa::transparent]

fn trait_environment_for_body(&self, def: DefWithBodyId) -> Arc<TraitEnvironment>;

#[salsa::interned]

fn intern_coroutine(&self, id: InternedCoroutine) -> InternedCoroutineId;

#[salsa::invoke(chalk_db::fn_def_variance_query)]

fn fn_def_variance(&self, fn_def_id: CallableDefId) -> chalk_db::Variances;

)]

fn variances_of(&self, def: GenericDefId) -> Option<Arc<[crate::variance::Variance]>>;

#[salsa::invoke(crate::traits::normalize_projection_query)]

#[salsa::transparent]

fn normalize_projection(

// next trait solver

#[salsa::invoke(crate::lower_nextsolver::ty_query)]

#[salsa::transparent]

fn ty_ns<'db>(

use std::fmt;

use base_db::Crate;

use either::Either;

use hir_def::{

AdtId, AssocItemId, DefWithBodyId, HasModule, ItemContainerId, Lookup,

value_or_partial.is_none_or(|v| !matches!(v, ValueNs::StaticId(_)))

}

Expr::Field { expr, .. } => match self.infer.type_of_expr[*expr].kind(Interner) {

_ => self.is_known_valid_scrutinee(*expr, db),

},

Expr::Index { base, .. } => self.is_known_valid_scrutinee(*base, db),

use chalk_ir::{BoundVar, Safety, TyKind};

use either::Either;

use hir_def::{

ModuleId, TraitId,

db::DefDatabase,

expr_store::{ExpressionStore, path::Path},

ieee::{Half as f16, Quad as f128},

};

use rustc_hash::FxHashSet;

use smallvec::SmallVec;

use span::Edition;

use stdx::never;

use triomphe::Arc;

use crate::{

db::{HirDatabase, InternedClosure},

generics::generics,

infer::normalize,

layout::Layout,

lt_from_placeholder_idx,

mir::pad16,

primitive, to_assoc_type_id,

utils::{self, ClosureSubst, detect_variant_from_bytes},

};

DisplayLifetime::Never => false,

}

}

}

pub trait HirDisplay {

matches!(self, Self::SourceCode { .. })

}

fn allows_opaque(self) -> bool {

match self {

Self::SourceCode { allow_opaque, .. } => allow_opaque,

}

}

impl HirDisplay for Const {

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

let generics = generics(f.db, id.parent);

let param_data = &generics[id.local_id];

write!(f, "{}", param_data.name().unwrap().display(f.db, f.edition()))?;

Ok(())

}

}

}

}

fn render_const_scalar(

f: &mut HirFormatter<'_>,

b: &[u8],

ty: &Ty,

) -> Result<(), HirDisplayError> {

let trait_env = TraitEnvironment::empty(f.krate());

let ty = normalize(f.db, trait_env.clone(), ty.clone());

}

}

},

TyKind::Str => {

let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());

let size = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());

TyKind::Slice(ty) => {

let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());

let count = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());

return f.write_str("<layout-error>");

};

let size_one = layout.size.bytes_usize();

f.write_str(", ")?;

}

let offset = size_one * i;

}

f.write_str("]")

}

let addr = usize::from_le_bytes(b[0..b.len() / 2].try_into().unwrap());

let ty_id = usize::from_le_bytes(b[b.len() / 2..].try_into().unwrap());

let Ok(t) = memory_map.vtable_ty(ty_id) else {

return f.write_str("<ty-missing-in-vtable-map>");

};

return f.write_str("<layout-error>");

};

let size = layout.size.bytes_usize();

return f.write_str("<ref-data-not-available>");

};

f.write_str("&")?;

}

let data = f.db.struct_signature(s);

write!(f, "&{}", data.name.display(f.db, f.edition()))?;

Ok(())

}

},

_ => {

let addr = usize::from_le_bytes(match b.try_into() {

return f.write_str("<layout-error>");

}

});

return f.write_str("<layout-error>");

};

let size = layout.size.bytes_usize();

return f.write_str("<ref-data-not-available>");

};

f.write_str("&")?;

}

},

return f.write_str("<layout-error>");

};

f.write_str("(")?;

let mut first = true;

if first {

first = false;

} else {

f.write_str(", ")?;

}

let offset = layout.fields.offset(id).bytes_usize();

f.write_str("<layout-error>")?;

continue;

};

let size = layout.size.bytes_usize();

}

f.write_str(")")

}

return f.write_str("<layout-error>");

};

hir_def::AdtId::StructId(s) => {

let data = f.db.struct_signature(s);

write!(f, "{}", data.name.display(f.db, f.edition()))?;

s.fields(f.db),

f,

&field_types,

&layout,

b,

memory_map,

)

var_id.fields(f.db),

f,

&field_types,

var_layout,

b,

memory_map,

)

}

}

TyKind::FnDef(..) => ty.hir_fmt(f),

let it = u128::from_le_bytes(pad16(b, false));

write!(f, "{it:#X} as ")?;

ty.hir_fmt(f)

}

TyKind::Array(ty, len) => {

return f.write_str("<unknown-array-len>");

};

return f.write_str("<layout-error>");

};

let size_one = layout.size.bytes_usize();

f.write_str(", ")?;

}

let offset = size_one * i;

}

f.write_str("]")

}

TyKind::Closure(_, _) => f.write_str("<closure>"),

TyKind::Coroutine(_, _) => f.write_str("<coroutine>"),

TyKind::CoroutineWitness(_, _) => f.write_str("<coroutine-witness>"),

// The below arms are unreachable, since const eval will bail out before here.

TyKind::Foreign(_) => f.write_str("<extern-type>"),

| TyKind::Placeholder(_)

// The below arms are unreachable, since we handled them in ref case.

}

}

field_types: &ArenaMap<LocalFieldId, Binders<Ty>>,

trait_env: Arc<TraitEnvironment>,

layout: &Layout,

b: &[u8],

) -> Result<(), HirDisplayError> {

match data.shape {

FieldsShape::Record | FieldsShape::Tuple => {

let render_field = |f: &mut HirFormatter<'_>, id: LocalFieldId| {

let offset = layout.fields.offset(u32::from(id.into_raw()) as usize).bytes_usize();

return f.write_str("<layout-error>");

};

let size = layout.size.bytes_usize();

&self,

f @ &mut HirFormatter { db, .. }: &mut HirFormatter<'_>,

) -> Result<(), HirDisplayError> {

if f.should_truncate() {

return write!(f, "{TYPE_HINT_TRUNCATION}");

}

TyKind::Never => write!(f, "!")?,

TyKind::Str => write!(f, "str")?,

TyKind::Slice(t) => {

write!(f, "[")?;

t.hir_fmt(f)?;

write!(f, "[")?;

t.hir_fmt(f)?;

write!(f, "; ")?;

write!(f, "]")?;

}

f.write_char('&')?;

f.write_char(' ')?;

}

match m {

}

} else {

write!(

f,

"*{}",

match m {

}

)?;

}

}

})

};

}

if let ImplTraitId::ReturnTypeImplTrait(func, idx) = impl_trait_id {

let datas = db

.return_type_impl_traits(func)

.expect("impl trait id without data");

let data =

(*datas).as_ref().map(|rpit| rpit.impl_traits[idx].bounds.clone());

let mut len = bounds.skip_binders().len();

// Don't count Sized but count when it absent

t.hir_fmt(f)?;

}

}

write!(f, "(")?;

write!(f, ",)")?;

} else {

write!(f, "(")?;

write!(f, ")")?;

}

}

sig.hir_fmt(f)?;

}

if f.display_kind.is_source_code() {

// `FnDef` is anonymous and there's no surface syntax for it. Show it as a

};

f.end_location_link();

if parameters.len(Interner) > 0 {

let generic_def_id = GenericDefId::from_callable(db, def);

let generics = generics(db, generic_def_id);

ret.hir_fmt(f)?;

}

}

match f.display_kind {

DisplayKind::Diagnostics | DisplayKind::Test => {

hir_def::AdtId::StructId(it) => db.struct_signature(it).name.clone(),

hir_def::AdtId::UnionId(it) => db.union_signature(it).name.clone(),

hir_def::AdtId::EnumId(it) => db.enum_signature(it).name.clone(),

DisplayKind::SourceCode { target_module_id: module_id, allow_opaque: _ } => {

if let Some(path) = find_path::find_path(

db,

module_id,

PrefixKind::Plain,

false,

}

f.end_location_link();

}

};

}

TyKind::Foreign(type_alias) => {

let type_alias = db.type_alias_signature(alias);

f.start_location_link(alias.into());

write!(f, "{}", type_alias.name.display(f.db, f.edition()))?;

f.end_location_link();

}

if !f.display_kind.allows_opaque() {

return Err(HirDisplayError::DisplaySourceCodeError(

DisplaySourceCodeError::OpaqueType,

));

}

match impl_trait_id {

ImplTraitId::ReturnTypeImplTrait(func, idx) => {

let datas =

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

bounds.skip_binders(),

SizedByDefault::Sized { anchor: krate },

)?;

}

}

TyKind::Closure(id, substs) => {

if f.display_kind.is_source_code() {

if !f.display_kind.allows_opaque() {

return Err(HirDisplayError::DisplaySourceCodeError(

never!("Only `impl Fn` is valid for displaying closures in source code");

}

}

match f.closure_style {

ClosureStyle::Hide => return write!(f, "{TYPE_HINT_TRUNCATION}"),

ClosureStyle::ClosureWithId => {

}

ClosureStyle::ClosureWithSubst => {

return hir_fmt_generics(f, substs.as_slice(Interner), None, None);

}

_ => (),

}

if let Some(sig) = sig {

let infer = db.infer(def);

match f.closure_style {

ClosureStyle::ImplFn => write!(f, "impl {kind:?}(")?,

ClosureStyle::RANotation => write!(f, "|")?,

}

}

TyKind::Placeholder(idx) => {

let generics = generics(db, id.parent);

let param_data = &generics[id.local_id];

match param_data {

.map(|pred| pred.clone().substitute(Interner, &substs))

.filter(|wc| match wc.skip_binders() {

WhereClause::Implemented(tr) => {

}

WhereClause::AliasEq(AliasEq {

alias: AliasTy::Projection(proj),

ty: _,

WhereClause::AliasEq(_) => false,

WhereClause::LifetimeOutlives(_) => false,

})

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

write_bounds_like_dyn_trait_with_prefix(

f,

"impl",

&bounds,

SizedByDefault::Sized { anchor: krate },

)?;

}

}

}

// Reorder bounds to satisfy `write_bounds_like_dyn_trait()`'s expectation.

// FIXME: `Iterator::partition_in_place()` or `Vec::extract_if()` may make it

// more efficient when either of them hits stable.

bounds.push(Binders::empty(

Interner,

chalk_ir::WhereClause::TypeOutlives(chalk_ir::TypeOutlives {

lifetime: dyn_ty.lifetime.clone(),

}),

));

write_bounds_like_dyn_trait_with_prefix(

f,

"dyn",

&bounds,

SizedByDefault::NotSized,

)?;

}

if f.display_kind.is_source_code() {

f.write_char('_')?;

} else {

write!(f, "{{unknown}}")?;

}

}

TyKind::Coroutine(_, subst) => {

if f.display_kind.is_source_code() {

return Err(HirDisplayError::DisplaySourceCodeError(

DisplaySourceCodeError::Coroutine,

));

}

let subst = subst.as_slice(Interner);

let a: Option<SmallVec<[&Ty; 3]>> = subst

.get(subst.len() - 3..)

}

}

TyKind::CoroutineWitness(..) => write!(f, "{{coroutine witness}}")?,

}

Ok(())

}

Ok(())

}

fn generic_args_sans_defaults<'ga>(

f: &mut HirFormatter<'_>,

generic_def: Option<hir_def::GenericDefId>,

}

}

fn hir_fmt_generic_arguments(

f: &mut HirFormatter<'_>,

parameters: &[GenericArg],

Ok(())

}

impl HirDisplay for CallableSig {

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

let CallableSig { params_and_return: _, is_varargs, safety, abi: _ } = *self;

}

}

impl HirDisplay for WhereClause {

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

if f.should_truncate() {

}

}

impl HirDisplay for DomainGoal {

fn hir_fmt(&self, f: &mut HirFormatter<'_>) -> Result<(), HirDisplayError> {

match self {

use std::ops::ControlFlow;

use hir_def::{

AssocItemId, ConstId, CrateRootModuleId, FunctionId, GenericDefId, HasModule, TraitId,

TypeAliasId, lang_item::LangItem, signatures::TraitFlags,

};

use rustc_hash::FxHashSet;

use smallvec::SmallVec;

use crate::{

};

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

db: &dyn HirDatabase,

trait_: TraitId,

) -> Option<DynCompatibilityViolation> {

}

}

}

pub fn dyn_compatibility_with_callback<F>(

where

F: FnMut(DynCompatibilityViolation) -> ControlFlow<()>,

{

if db.dyn_compatibility_of_trait(super_trait).is_some() {

cb(DynCompatibilityViolation::HasNonCompatibleSuperTrait(trait_))?;

}

return false;

};

}

}

})

}

// but we don't have good way to render such locations.

// So, just return single boolean value for existence of such `Self` reference

fn predicates_reference_self(db: &dyn HirDatabase, trait_: TraitId) -> bool {

.iter()

.any(|pred| predicate_references_self(db, trait_, pred, AllowSelfProjection::No))

}

.items

.iter()

.filter_map(|(_, it)| match *it {

_ => None,

})

})

})

}

No,

}

trait_: TraitId,

allow_self_projection: AllowSelfProjection,

) -> bool {

})

}

_ => false,

}

}

trait_: TraitId,

t: &T,

allow_self_projection: AllowSelfProjection,

) -> bool {

trait_: TraitId,

super_traits: Option<SmallVec<[TraitId; 4]>>,

allow_self_projection: AllowSelfProjection,

}

AllowSelfProjection::Yes => {

if self.super_traits.is_none() {

}

if self.super_traits.as_ref().is_some_and(|s| s.contains(&trait_)) {

ControlFlow::Continue(())

} else {

}

}

},

}

}

}

}

fn dyn_compatibility_violation_for_assoc_item<F>(

cb(MethodViolationCode::AsyncFn)?;

}

cb(MethodViolationCode::ReferencesSelfInput)?;

}

if contains_illegal_self_type_reference(

db,

trait_,

AllowSelfProjection::Yes,

) {

cb(MethodViolationCode::ReferencesSelfOutput)?;

cb(MethodViolationCode::UndispatchableReceiver)?;

}

for pred in predicates {

continue;

}

// Allow `impl AutoTrait` predicates

}

cb(MethodViolationCode::WhereClauseReferencesSelf)?;

break;

}

ControlFlow::Continue(())

}

db: &dyn HirDatabase,

trait_: TraitId,

func: FunctionId,

) -> bool {

// `self: Self` can't be dispatched on, but this is already considered dyn-compatible

// See rustc's comment on https://github.com/rust-lang/rust/blob/3f121b9461cce02a703a0e7e450568849dfaa074/compiler/rustc_trait_selection/src/traits/object_safety.rs#L433-L437

return true;

}

return false;

};

return false;

};

return false;

};

);

}

);

}

) -> Option<MethodViolationCode> {

}

}

}

let mut visitor = OpaqueTypeCollector(FxHashSet::default());

// Since we haven't implemented RPITIT in proper way like rustc yet,

// just check whether `ret` contains RPIT for now

for opaque_ty in visitor.0 {

if matches!(impl_trait_id, ImplTraitId::ReturnTypeImplTrait(..)) {

return Some(MethodViolationCode::ReferencesImplTraitInTrait);

}

//! Type cast logic. Basically coercion + additional casts.

use chalk_ir::{Mutability, Scalar, TyVariableKind, UintTy};

use stdx::never;

use crate::{

Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,

infer::{coerce::CoerceNever, unify::InferenceTable},

};

return Ok(());

}

let src_principal =

let dst_principal =

Ok(())

} else {

Err(CastError::DifferingKinds)

visit::{TypeSuperVisitable, TypeVisitable, TypeVisitor},

};

use either::Either;

use hir_def::{

DefWithBodyId, FieldId, HasModule, TupleFieldId, TupleId, VariantId,

expr_store::path::Path,

resolver::ValueNs,

type_ref::TypeRefId,

};

use hir_expand::name::Name;

use intern::sym;

use rustc_hash::{FxHashMap, FxHashSet};

use syntax::utils::is_raw_identifier;

use crate::{

db::{HirDatabase, InternedClosure, InternedCoroutine},

error_lifetime, from_assoc_type_id, from_chalk_trait_id, from_placeholder_idx,

generics::Generics,

infer::{BreakableKind, CoerceMany, Diverges, coerce::CoerceNever},

make_binders,

mir::{BorrowKind, MirSpan, MutBorrowKind, ProjectionElem},

traits::FnTrait,

utils::{self, elaborate_clause_supertraits},

};

fn deduce_sig_from_dyn_ty(&self, dyn_ty: &DynTy) -> Option<FnPointer> {

// Search for a predicate like `<$self as FnX<Args>>::Output == Ret`

let self_ty = self.result.standard_types.unknown.clone();

let bounds = dyn_ty.bounds.clone().substitute(Interner, &[self_ty.cast(Interner)]);

if let WhereClause::AliasEq(AliasEq { alias: AliasTy::Projection(projection), ty }) =

bound.skip_binders()

{

return None;

}

},

};

pub(crate) mod adt;

pub(crate) mod target;

return Err(LayoutError::InvalidSimdType);

};

let cx = LayoutCx::new(dl);

Ok(Arc::new(cx.calc.simd_type(e_ly, e_len, repr_packed)?))

}

db: &'db dyn HirDatabase,

ty: Ty<'db>,

trait_env: Arc<TraitEnvironment>,

}

_ => {}

}

}

TyKind::Bool => Layout::scalar(

dl,

let fields = tys

.iter()

.collect::<Result<Vec<_>, _>>()?;

let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();

let fields = fields.iter().collect::<IndexVec<_, _>>();

cx.calc.univariant(&fields, &ReprOptions::default(), kind)?

}

TyKind::Array(element, count) => {

cx.calc.array_like::<_, _, ()>(&element, Some(count))?

}

TyKind::Slice(element) => {

cx.calc.array_like::<_, _, ()>(&element, None)?

}

TyKind::Str => {

let ty =

convert_binder_to_early_binder(interner, it.ty.to_nextsolver(interner))

.instantiate(interner, args);

})

.collect::<Result<Vec<_>, _>>()?;

let fields = fields.iter().map(|it| &**it).collect::<Vec<_>>();

Ok(Arc::new(result))

}

_: &dyn HirDatabase,

_: Ty<'db>,

_: Arc<TraitEnvironment>,

use triomphe::Arc;

use crate::{

db::HirDatabase,

layout::{Layout, LayoutCx, LayoutError, field_ty},

};

db: &'db dyn HirDatabase,

def: AdtId,

args: GenericArgs<'db>,

let handle_variant = |def: VariantId, var: &VariantFields| {

var.fields()

.iter()

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

};

let (variants, repr, is_special_no_niche) = match def {

Ok(Arc::new(result))

}

_: &'db dyn HirDatabase,

_def: AdtId,

_args: GenericArgs<'db>,

Interner, Substitution,

db::HirDatabase,

layout::{Layout, LayoutError},

setup_tracing,

test_db::TestDB,

};

db.ty(ty_id.into()).substitute(Interner, &Substitution::empty(Interner))

}

};

}

/// A version of `eval_goal` for types that can not be expressed in ADTs, like closures and `impl Trait`

.0;

let infer = db.infer(function_id.into());

let goal_ty = infer.type_of_binding[b].clone();

}

#[track_caller]

use la_arena::{Arena, Idx};

use mir::{MirEvalError, VTableMap};

use rustc_hash::{FxBuildHasher, FxHashMap, FxHashSet};

use syntax::ast::{ConstArg, make};

use traits::FnTrait;

use triomphe::Arc;

display::{DisplayTarget, HirDisplay},

generics::Generics,

infer::unify::InferenceTable,

};

pub use autoderef::autoderef;

pub use interner::Interner;

pub use lower::{

ImplTraitLoweringMode, LifetimeElisionKind, ParamLoweringMode, TyDefId, TyLoweringContext,

};

pub use mapping::{

ToChalk, from_assoc_type_id, from_chalk_trait_id, from_foreign_def_id, from_placeholder_idx,

lt_from_placeholder_idx, lt_to_placeholder_idx, to_assoc_type_id, to_chalk_trait_id,

/// the necessary bits of memory of the const eval session to keep the constant

/// meaningful.

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

#[default]

Empty,

Simple(Box<[u8]>),

}

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

memory: IndexMap<usize, Box<[u8]>, FxBuildHasher>,

}

fn insert(&mut self, addr: usize, val: Box<[u8]>) {

match self.memory.entry(addr) {

Entry::Occupied(mut e) => {

}

}

match self {

MemoryMap::Empty | MemoryMap::Simple(_) => Err(MirEvalError::InvalidVTableId(id)),

MemoryMap::Complex(cm) => cm.vtable.ty(id),

}

}

/// A concrete constant value

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

pub enum ConstScalar {

// FIXME: this is a hack to get around chalk not being able to represent unevaluatable

// constants

UnevaluatedConst(GeneralConstId, Substitution),

}

}

/// Return an index of a parameter in the generic type parameter list by it's id.

pub fn param_idx(db: &dyn HirDatabase, id: TypeOrConstParamId) -> Option<usize> {

generics::generics(db, id.parent).type_or_const_param_idx(id)

abi: fn_ptr.sig.abi,

}

}

pub fn to_fn_ptr(&self) -> FnPointer {

FnPointer {

}

}

fn named_associated_type_shorthand_candidates<R>(

db: &dyn HirDatabase,

// If the type parameter is defined in an impl and we're in a method, there

generic_predicates_filtered_by(db, def, |_, _| true).0

}

/// Resolve the where clause(s) of an item with generics,

/// with a given filter

fn generic_predicates_filtered_by<F>(

use std::{

cell::OnceCell,

iter, mem,

};

use base_db::Crate;

use either::Either;

use hir_def::{

AdtId, AssocItemId, CallableDefId, ConstParamId, EnumVariantId, FunctionId, GenericDefId,

TypeOrConstParamId, VariantId,

expr_store::{

ExpressionStore,

inherent::{GenericArg as _, GenericArgs as _, IntoKind as _, Region as _, SliceLike, Ty as _},

};

use salsa::plumbing::AsId;

use stdx::never;

use triomphe::Arc;

lower::{Diagnostics, PathDiagnosticCallbackData, create_diagnostics},

next_solver::{

AdtDef, AliasTy, Binder, BoundExistentialPredicates, BoundRegionKind, BoundTyKind,

},

};

}))

}

pub(crate) fn associated_type_by_name_including_super_traits<'db>(

db: &'db dyn HirDatabase,

trait_ref: TraitRef<'db>,

Some((t.skip_binder(), assoc_type))

})

}

use either::Either;

use hir_def::{

builtin_type::BuiltinType,

expr_store::{

ExpressionStore, HygieneId,

signatures::TraitFlags,

type_ref::{TypeRef, TypeRefId},

};

use intern::sym;

use rustc_hash::FxHashSet;

use rustc_type_ir::{

db::HirDatabase,

generics::{Generics, generics},

lower::PathDiagnosticCallbackData,

next_solver::{

AdtDef, Binder, Clause, Const, DbInterner, ErrorGuaranteed, Predicate, ProjectionPredicate,

Region, SolverDefId, TraitRef, Ty,

let Some(res) = res else {

return Ty::new_error(self.ctx.interner, ErrorGuaranteed);

};

let db = self.ctx.db;

let def = self.ctx.def;

}

};

}

fn lower_path_inner(&mut self, typeable: TyDefId, infer_args: bool) -> Ty<'db> {

//! Chalk (in both directions); plus some helper functions for more specialized

//! conversions.

use hir_def::{LifetimeParamId, TraitId, TypeAliasId, TypeOrConstParamId};

use salsa::{

Id,

}

}

impl From<OpaqueTyId> for crate::db::InternedOpaqueTyId {

fn from(id: OpaqueTyId) -> Self {

FromId::from_id(id.0)

}

impl Operand {

Operand {

kind: OperandKind::Constant(intern_const_scalar(

ConstScalar::Bytes(data, memory_map),

ieee::{Half as f16, Quad as f128},

};

use rustc_hash::{FxHashMap, FxHashSet};

use span::FileId;

use stdx::never;

use syntax::{SyntaxNodePtr, TextRange};

use triomphe::Arc;

use crate::{

consteval::{ConstEvalError, intern_const_scalar, try_const_usize},

db::{HirDatabase, InternedClosure},

display::{ClosureStyle, DisplayTarget, HirDisplay},

infer::PointerCast,

layout::{Layout, LayoutError, RustcEnumVariantIdx},

method_resolution::{is_dyn_method, lookup_impl_const},

static_lifetime,

traits::FnTrait,

utils::{ClosureSubst, detect_variant_from_bytes},

}

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

}

const OFFSET: usize = 1000; // We should add some offset to ids to make 0 (null) an invalid id.

if let Some(it) = self.ty_to_id.get(&ty) {

return *it;

}

let id = self.id_to_ty.len() + VTableMap::OFFSET;

self.ty_to_id.insert(ty, id);

id

}

id.checked_sub(VTableMap::OFFSET)

.ok_or(MirEvalError::InvalidVTableId(id))

}

let id = from_bytes!(usize, bytes);

self.ty(id)

}

/// We don't really have function pointers, i.e. pointers to some assembly instructions that we can run. Instead, we

/// store the type as an interned id in place of function and vtable pointers, and we recover back the type at the

/// time of use.

thread_local_storage: TlsData,

random_state: oorandom::Rand64,

stdout: Vec<u8>,

stderr: Vec<u8>,

projected_ty_cache: RefCell<FxHashMap<(Ty, PlaceElem), Ty>>,

not_special_fn_cache: RefCell<FxHashSet<FunctionId>>,

mir_or_dyn_index_cache: RefCell<FxHashMap<(FunctionId, Substitution), MirOrDynIndex>>,

Self { addr, size }

}

memory.read_memory(self.addr, self.size)

}

}

impl IntervalAndTy {

memory.read_memory(self.interval.addr, self.interval.size)

}

}

impl IntervalOrOwned {

Ok(match self {

IntervalOrOwned::Owned(o) => o,

IntervalOrOwned::Borrowed(b) => b.get(memory)?,

memory_map.vtable.shrink_to_fit();

MemoryMap::Complex(Box::new(memory_map))

};

})();

Ok((it, MirOutput { stdout: evaluator.stdout, stderr: evaluator.stderr }))

}

#[cfg(not(test))]

const EXECUTION_LIMIT: usize = 10_000_000;

pub fn new(

db: &dyn HirDatabase,

owner: DefWithBodyId,

p: &Place,

locals: &'a Locals,

) -> Result<(Address, Ty, Option<IntervalOrOwned>)> {

let mut addr = locals.ptr[p.local].addr;

let mut ty: Ty = locals.body.locals[p.local].ty.clone();

let mut metadata: Option<IntervalOrOwned> = None; // locals are always sized

addr = addr.offset(ty_size * (from as usize));

}

&ProjectionElem::ClosureField(f) => {

let offset = layout.fields.offset(f).bytes_usize();

addr = addr.offset(offset);

metadata = None;

}

ProjectionElem::Field(Either::Right(f)) => {

let offset = layout.fields.offset(f.index as usize).bytes_usize();

addr = addr.offset(offset);

metadata = None; // tuple field is always sized FIXME: This is wrong, the tail can be unsized

}

ProjectionElem::Field(Either::Left(f)) => {

let variant_layout = match &layout.variants {

Variants::Single { .. } | Variants::Empty => &layout,

Variants::Multiple { variants, .. } => {

Ok((addr, ty, metadata))

}

return Ok(x.clone());

}

let r = self

.db

Ok(r)

}

fn layout_adt(&self, adt: AdtId, subst: Substitution) -> Result<Arc<Layout>> {

}

fn place_ty<'a>(&'a self, p: &Place, locals: &'a Locals) -> Result<Ty> {

)?

}

TyKind::FnDef(def, generic_args) => self.exec_fn_def(

generic_args,

destination_interval,

&args,

}

fn eval_rvalue(&mut self, r: &Rvalue, locals: &mut Locals) -> Result<IntervalOrOwned> {

use IntervalOrOwned::*;

Ok(match r {

Rvalue::Use(it) => Borrowed(self.eval_operand(it, locals)?),

Owned(r)

}

AggregateKind::Tuple(ty) => {

Owned(self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

)?)

}

AggregateKind::Closure(ty) => {

Owned(self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

if let TyKind::FnDef(_, _) | TyKind::Closure(_, _) =

&current_ty.kind(Interner)

{

let id = self.vtable_map.id(current_ty);

let ptr_size = self.ptr_size();

Owned(id.to_le_bytes()[0..ptr_size].to_vec())

}

fn compute_discriminant(&self, ty: Ty, bytes: &[u8]) -> Result<i128> {

let &TyKind::Adt(chalk_ir::AdtId(AdtId::EnumId(e)), _) = ty.kind(Interner) else {

return Ok(0);

};

}

},

TyKind::Dyn(_) => {

let vtable = self.vtable_map.id(current_ty);

let mut r = Vec::with_capacity(16);

let addr = addr.get(self)?;

subst: Substitution,

locals: &Locals,

) -> Result<(usize, Arc<Layout>, Option<(usize, usize, i128)>)> {

let adt = it.adt_id(self.db);

if let DefWithBodyId::VariantId(f) = locals.body.owner

&& let VariantId::EnumVariantId(it) = it

// Computing the exact size of enums require resolving the enum discriminants. In order to prevent loops (and

// infinite sized type errors) we use a dummy layout

let i = self.const_eval_discriminant(it)?;

}

let layout = self.layout_adt(adt, subst)?;

Ok(match &layout.variants {

#[allow(clippy::double_parens)]

fn allocate_const_in_heap(&mut self, locals: &Locals, konst: &Const) -> Result<Interval> {

let ConstData { ty, value: chalk_ir::ConstValue::Concrete(c) } = &konst.data(Interner)

else {

not_supported!("evaluating non concrete constant");

MemoryMap::Complex(cm) => cm.vtable.ty_of_bytes(bytes),

},

addr,

locals,

)?;

Ok(Interval::new(addr, size))

}

fn size_align_of(&self, ty: &Ty, locals: &Locals) -> Result<Option<(usize, usize)>> {

return Ok(layout

.is_sized()

.then(|| (layout.size.bytes_usize(), layout.align.abi.bytes() as usize)));

// infinite sized type errors) we use a dummy size

return Ok(Some((16, 16)));

}

if self.assert_placeholder_ty_is_unused

&& matches!(layout, Err(MirEvalError::LayoutError(LayoutError::HasPlaceholder, _)))

{

bytes: &[u8],

ty: &Ty,

locals: &Locals,

bytes: &[u8],

ty: &Ty,

locals: &Locals,

stack_depth_limit: usize,

) -> Result<()> {

if stack_depth_limit.checked_sub(1).is_none() {

return Err(MirEvalError::StackOverflow);

}

let element_size = match t.kind(Interner) {

TyKind::Str => 1,

TyKind::Slice(t) => {

this.size_of_sized(t, locals, "slice inner type")?

}

TyKind::Dyn(_) => {

let t = this.vtable_map.ty_of_bytes(meta)?;

}

_ => return Ok(()),

};

let addr = Address::from_bytes(addr)?;

let b = this.read_memory(addr, size)?;

mm.insert(addr.to_usize(), b.into());

for i in 0..count {

let offset = element_size * i;

rec(

}

}

TyKind::Tuple(_, subst) => {

for (id, ty) in subst.iter(Interner).enumerate() {

let ty = ty.assert_ty_ref(Interner); // Tuple only has type argument

let offset = layout.fields.offset(id).bytes_usize();

rec(

this,

&bytes[offset..offset + size],

TyKind::Adt(adt, subst) => match adt.0 {

AdtId::StructId(s) => {

let data = s.fields(this.db);

let field_types = this.db.field_types(s.into());

for (f, _) in data.fields().iter() {

let offset = layout

.offset(u32::from(f.into_raw()) as usize)

.bytes_usize();

let ty = &field_types[f].clone().substitute(Interner, subst);

rec(

this,

&bytes[offset..offset + size],

}

}

AdtId::EnumId(e) => {

if let Some((v, l)) = detect_variant_from_bytes(

&layout,

this.db,

let offset =

l.fields.offset(u32::from(f.into_raw()) as usize).bytes_usize();

let ty = &field_types[f].clone().substitute(Interner, subst);

rec(

this,

&bytes[offset..offset + size],

Ok(mm)

}

&mut self,

patch_map: &FxHashMap<usize, usize>,

addr: Address,

locals: &Locals,

) -> Result<()> {

// FIXME: support indirect references

let layout = self.layout(ty)?;

match size {

Some(_) => {

let current = from_bytes!(usize, self.read_memory(addr, my_size)?);

}

}

}

let new_id = self.vtable_map.id(ty);

self.write_memory(addr, &new_id.to_le_bytes())?;

}

let offset = layout.fields.offset(i).bytes_usize();

self.patch_addresses(

patch_map,

ty_of_bytes,

addr.offset(offset),

locals,

)?;

}

}

if let Some((ev, layout)) = detect_variant_from_bytes(

&layout,

self.db,

self.read_memory(addr, layout.size.bytes_usize())?,

e,

) {

let offset = layout.fields.offset(i).bytes_usize();

self.patch_addresses(

patch_map,

ty_of_bytes,

addr.offset(offset),

locals,

)?;

}

}

}

},

let offset = layout.fields.offset(id).bytes_usize();

self.patch_addresses(patch_map, ty_of_bytes, addr.offset(offset), ty, locals)?;

}

}

TyKind::Array(inner, len) => {

Some(it) => it as usize,

None => not_supported!("non evaluatable array len in patching addresses"),

};

for i in 0..len {

self.patch_addresses(

patch_map,

)?;

}

}

| TyKind::Slice(_)

| TyKind::FnDef(_, _)

| TyKind::Str

| TyKind::Never

| TyKind::Coroutine(_, _)

| TyKind::CoroutineWitness(_, _)

| TyKind::Foreign(_)

| TyKind::Placeholder(_)

}

Ok(())

}

span: MirSpan,

) -> Result<Option<StackFrame>> {

let id = from_bytes!(usize, bytes.get(self)?);

TyKind::FnDef(def, generic_args) => {

}

}

_ => Err(MirEvalError::InternalError("function pointer to non function".into())),

}

fn exec_fn_def(

&mut self,

generic_args: &Substitution,

destination: Interval,

args: &[IntervalAndTy],

target_bb: Option<BasicBlockId>,

span: MirSpan,

) -> Result<Option<StackFrame>> {

let generic_args = generic_args.clone();

match def {

CallableDefId::FunctionId(def) => {

target_bb: Option<BasicBlockId>,

span: MirSpan,

) -> Result<Option<StackFrame>> {

if self.detect_and_exec_special_function(

def,

args,

.vtable_map

.ty_of_bytes(&first_arg[self.ptr_size()..self.ptr_size() * 2])?;

let mut args_for_target = args.to_vec();

args_for_target[0] = IntervalAndTy {

interval: args_for_target[0].interval.slice(0..self.ptr_size()),

ty: ty.clone(),

target_bb: Option<BasicBlockId>,

span: MirSpan,

) -> Result<Option<StackFrame>> {

let func = args

.first()

.ok_or_else(|| MirEvalError::InternalError("fn trait with no arg".into()))?;

let id =

from_bytes!(usize, &func_data.get(self)?[self.ptr_size()..self.ptr_size() * 2]);

func_data = func_data.slice(0..self.ptr_size());

}

let size = self.size_of_sized(&func_ty, locals, "self type of fn trait")?;

func_data = Interval { addr: Address::from_bytes(func_data.get(self)?)?, size };

}

match &func_ty.kind(Interner) {

TyKind::Function(_) => {

self.exec_fn_pointer(func_data, destination, &args[1..], locals, target_bb, span)

}

Substitution::from_iter(Interner, args.iter().map(|it| it.ty.clone())),

)

.intern(Interner);

let result = self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

owner: DefWithBodyId,

c: &Const,

) -> Result<String> {

let mut evaluator = Evaluator::new(db, owner, false, None)?;

let locals = &Locals {

ptr: ArenaMap::new(),

CallableDefId::FunctionId(debug_fmt_fn).to_chalk(db),

Substitution::from1(Interner, c.data(Interner).ty.clone()),

)

evaluator.write_memory(a2.offset(evaluator.ptr_size()), &debug_fmt_fn_ptr.to_le_bytes())?;

// a3 = ::core::fmt::Arguments::new_v1(a1, a2)

// FIXME: similarly, we should call function here, not directly working with memory.

LangItem, Layout, Locals, Lookup, MirEvalError, MirSpan, Mutability, Result, Substitution,

Ty, TyBuilder, TyExt, pad16,

},

};

mod simd;

destination: Interval,

span: MirSpan,

) -> Result<()> {

match self_ty.kind(Interner) {

TyKind::Function(_) => {

let [arg] = args else {

let InternedClosure(closure_owner, _) = self.db.lookup_intern_closure((*id).into());

let infer = self.db.infer(closure_owner);

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

let ty_iter = captures.iter().map(|c| c.ty(subst));

self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?;

}

not_supported!("wrong arg count for clone");

};

let addr = Address::from_bytes(arg.get(self)?)?;

let ty_iter = subst.iter(Interner).map(|ga| ga.assert_ty_ref(Interner).clone());

self.exec_clone_for_fields(ty_iter, layout, addr, def, locals, destination, span)?;

}

destination: Interval,

span: MirSpan,

) -> Result<()> {

for (i, ty) in ty_iter.enumerate() {

let tmp = self.heap_allocate(self.ptr_size(), self.ptr_size())?;

let arg = IntervalAndTy {

interval: Interval { addr: tmp, size: self.ptr_size() },

span: MirSpan,

needs_override: bool,

) -> Result<bool> {

if let Some(name) = name.strip_prefix("atomic_") {

return self

.exec_atomic_intrinsic(name, args, generic_args, destination, locals, span)

"align_of generic arg is not provided".into(),

));

};

destination.write_from_bytes(self, &align.to_le_bytes()[0..destination.size])

}

"size_of_val" => {

let is_overflow = u128overflow

|| ans.to_le_bytes()[op_size..].iter().any(|&it| it != 0 && it != 255);

let is_overflow = vec![u8::from(is_overflow)];

let result = self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

"const_eval_select arg[0] is not a tuple".into(),

));

};

for (i, field) in fields.iter(Interner).enumerate() {

let field = field.assert_ty_ref(Interner).clone();

let offset = layout.fields.offset(i).bytes_usize();

metadata: Interval,

locals: &Locals,

) -> Result<(usize, usize)> {

Ok(match ty.kind(Interner) {

TyKind::Str => (from_bytes!(usize, metadata.get(self)?), 1),

TyKind::Slice(inner) => {

(size * len, align)

}

TyKind::Dyn(_) => self.size_align_of_sized(

locals,

"dyn concrete type",

)?,

locals: &Locals,

_span: MirSpan,

) -> Result<()> {

// We are a single threaded runtime with no UB checking and no optimization, so

// we can implement atomic intrinsics as normal functions.

Substitution::from_iter(Interner, [ty.clone(), TyBuilder::bool()]),

)

.intern(Interner);

let result = self.construct_with_layout(

layout.size.bytes_usize(),

&layout,

)

.map_err(|e| MirEvalError::MirLowerError(func_id, e))?;

result?;

Ok((output.stdout().into_owned(), output.stderr().into_owned()))

}

Terminator, TerminatorKind, TupleFieldId, Ty, UnOp, VariantId, intern_const_scalar,

return_slot,

},

static_lifetime,

traits::FnTrait,

utils::ClosureSubst,

}

fn lower_literal_to_operand(&mut self, ty: Ty, l: &Literal) -> Result<Operand> {

const USIZE_SIZE: usize = size_of::<usize>();

let bytes: Box<[_]> = match l {

hir_def::hir::Literal::String(b) => {

}

impl<'db> ValueConst<'db> {

let value = Valtree::new(bytes);

ValueConst { ty, value }

}

}

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

fn hash<H: std::hash::Hasher>(&self, state: &mut H) {

self.0.hash(state)

}

#[salsa::interned(constructor = new_, debug)]

pub struct Valtree<'db> {

#[returns(ref)]

}

impl<'db> Valtree<'db> {

salsa::with_attached_database(|db| unsafe {

// SAFETY: ¯\_(ツ)_/¯

std::mem::transmute(Valtree::new_(db, bytes))

.unwrap()

}

salsa::with_attached_database(|db| {

let inner = self.bytes_(db);

// SAFETY: The caller already has access to a `Valtree<'db>`, so borrowchecking will

}

}

impl<'db> From<Term<'db>> for GenericArg<'db> {

fn from(value: Term<'db>) -> Self {

match value {

interner: DbInterner<'db>,

def_id: <DbInterner<'db> as rustc_type_ir::Interner>::DefId,

) -> <DbInterner<'db> as rustc_type_ir::Interner>::GenericArgs {

}

fn extend_with_error(

}

}

let name = name.clone();

match kind {

GenericParamDefKind::Lifetime => {

}

}

}

shift_vars,

solve::Goal,

};

use crate::{

db::{

},

from_assoc_type_id, from_chalk_trait_id,

mapping::ToChalk,

}

}

pub fn convert_binder_to_early_binder<'db, T: rustc_type_ir::TypeFoldable<DbInterner<'db>>>(

interner: DbInterner<'db>,

binder: rustc_type_ir::Binder<DbInterner<'db>, T>,

.intern(Interner)

}

let value: chalk_ir::ConstValue<Interner> = match const_.kind() {

rustc_type_ir::ConstKind::Param(_) => unimplemented!(),

rustc_type_ir::ConstKind::Infer(rustc_type_ir::InferConst::Var(var)) => {

rustc_type_ir::ConstKind::Value(value_const) => {

let bytes = value_const.value.inner();

let value = chalk_ir::ConstValue::Concrete(chalk_ir::ConcreteConst {

});

return chalk_ir::ConstData {

ty: convert_ty_for_result(interner, value_const.ty),

chalk_ir::ConstData { ty: crate::TyKind::Error.intern(Interner), value }.intern(Interner)

}

match region.kind() {

rustc_type_ir::RegionKind::ReEarlyParam(early) => unimplemented!(),

rustc_type_ir::RegionKind::ReBound(db, bound) => chalk_ir::Lifetime::new(

use crate::next_solver::{

Binder, Const, ConstKind, DbInterner, Goal, ParamEnv, Predicate, PredicateKind, Span, Term, Ty,

fulfill::{FulfillmentCtxt, NextSolverError},

infer::{

at::At,

traits::{Obligation, ObligationCause},

},

util::PlaceholderReplacer,

};

/// Deeply normalize all aliases in `value`. This does not handle inference and expects

/// its input to be already fully resolved.

pub fn deeply_normalize<'db, T>(at: At<'_, 'db>, value: T) -> Result<T, Vec<NextSolverError<'db>>>

WithCachedTypeInfo,

inherent::{

AdtDef, BoundVarLike, GenericArgs as _, IntoKind, ParamLike, PlaceholderLike, SliceLike,

},

relate::Relate,

solve::SizedTraitKind,

Ty::new_infer(interner, InferTy::FreshFloatTy(n))

}

/// Returns the `Size` for primitive types (bool, uint, int, char, float).

pub fn primitive_size(self, interner: DbInterner<'db>) -> Size {

match self.kind() {

}

}

pub(super) fn int_ty_from_builtin(t: BuiltinInt) -> IntTy {

match t {

BuiltinInt::Isize => IntTy::Isize,

};

let range = node.as_ref().original_file_range_rooted(&db);

if let Some(expected) = types.remove(&range) {

assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);

}

}

};

let range = node.as_ref().original_file_range_rooted(&db);

if let Some(expected) = types.remove(&range) {

assert_eq!(actual, expected, "type annotation differs at {:#?}", range.range);

}

if let Some(expected) = adjustments.remove(&range) {

continue;

};

let range = node.as_ref().original_file_range_rooted(&db);

match mismatches.remove(&range) {

Some(annotation) => assert_eq!(actual, annotation),

None => format_to!(unexpected_type_mismatches, "{:?}: {}\n", range.range, actual),

for (def, krate) in defs {

let (body, source_map) = db.body_with_source_map(def);

let infer = db.infer(def);

}

buf.truncate(buf.trim_end().len());

.join(", "),

};

let place = capture.display_place(closure.0, db);

let spans = capture

.spans()

.iter()

let x = S3.baz();

//^ Binary<impl Foo + ?Sized, Unary<impl Bar + ?Sized>>

let y = x.1.0.bar();

}

"#,

);

}

"#,

expect![[r#"

105..133 '{ ... }': ()

"#]],

);

}

let x: <S as Iterable>::Item = 1;

// ^ u32

let y: <T as Iterable>::Item = u;

let z: T::Item = u;

let a: <T>::Item = u;

}"#,

);

}

fn test<T: Iterable>() {

let s: S<T>;

s.foo();

}"#,

);

}

type A;

fn test(a: Self::A, _: impl Bar) {

a;

}

}"#,

);

fn test<T: ApplyL>() {

let y: <RefMutL<T> as ApplyL>::Out = no_matter;

y;

"#,

);

}

fn test<T: ApplyL>(t: T) {

let y = foo(t);

y;

"#,

);

}

}"#,

expect![[r#"

49..50 't': T

111..112 't': T

122..124 '{}': U

154..155 't': T

}"#,

expect![[r#"

40..44 'self': &'? Self

126..130 'self': &'? S

132..133 'x': u32

147..161 '{ let y = x; }': ()

fn test<T: Trait>() where T: Trait2<T::Item> {

let x: T::Item = no_matter;

"#,

);

}

fn test<T>() where T: Trait<OtherItem = T::Item> {

let x: T::Item = no_matter;

"#,

);

}

t.push(x);

let y: Key<T>;

(x, y);

"#,

);

}

let x = <F as Bar>::boo();

}"#,

expect![[r#"

146..153 'loop {}': !

151..153 '{}': ()

306..358 '{ ...o(); }': ()

let a = v.get::<T>();

//^ &'a T

let a = v.get::<()>();

}

fn h<'a>(v: impl Trait<Assoc<i32> = &'a i32> + Trait<Assoc<i64> = &'a i64>) {

let a = v.get::<i32>();

let a = t.get::<isize>();

//^ usize

let a = t.get::<()>();

}

"#,

37..38 'a': T

43..83 '{ ...ait; }': ()

43..83 '{ ...ait; }': impl Future<Output = ()>

60..61 'a': T

62..63 '0': u32

70..80 'fut1.await': i32

124..129 'mut b': T

134..174 '{ ...ait; }': ()

134..174 '{ ...ait; }': impl Future<Output = ()>

151..152 'b': T

153..154 '0': u32

161..171 'fut2.await': i32

216..217 'c': T

222..262 '{ ...ait; }': ()

222..262 '{ ...ait; }': impl Future<Output = ()>

239..240 'c': T

241..242 '0': u32

249..259 'fut3.await': i32

"#]],

);

"#,

expect![[r#"

84..86 'de': D

"#]],

);

}

294..298 'iter': Box<dyn Iterator<Item = &'? [u8]> + 'static>

294..310 'iter.i...iter()': Box<dyn Iterator<Item = &'? [u8]> + 'static>

152..156 'self': &'? mut Box<I>

191..198 'loop {}': !

196..198 '{}': ()

"#]],

use std::{cell::LazyCell, iter};

use base_db::Crate;

use hir_def::{

EnumId, EnumVariantId, FunctionId, Lookup, TraitId, TypeAliasId, TypeOrConstParamId,

db::DefDatabase,

use intern::sym;

use rustc_abi::TargetDataLayout;

use rustc_hash::FxHashSet;

use smallvec::{SmallVec, smallvec};

use span::Edition;

use stdx::never;

db::HirDatabase,

layout::{Layout, TagEncoding},

mir::pad16,

};

pub(crate) fn fn_traits(db: &dyn DefDatabase, krate: Crate) -> impl Iterator<Item = TraitId> + '_ {

}

fn direct_super_trait_refs(db: &dyn HirDatabase, trait_ref: &TraitRef, cb: impl FnMut(TraitRef)) {

let generic_params = db.generic_params(trait_ref.hir_trait_id().into());

let trait_self = match generic_params.trait_self_param() {

Some(p) => TypeOrConstParamId { parent: trait_ref.hir_trait_id().into(), local_id: p },

None => return,

};

.iter()

.filter_map(|pred| {

_ => None,

})

.for_each(cb);

}

},

per_ns::PerNs,

resolver::{HasResolver, Resolver},

src::HasSource as _,

visibility::visibility_from_ast,

};

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

method_resolution,

mir::{MutBorrowKind, interpret_mir},

primitive::UintTy,

traits::FnTrait,

};

VisibleTraits,

},

};

// Be careful with these re-exports.

//

}

pub fn layout(&self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

db.layout_of_ty(

db.trait_environment(match hir_def::VariantId::from(self.parent) {

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

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

}

pub fn layout(self, db: &dyn HirDatabase) -> Result<Layout, LayoutError> {

db.layout_of_adt(

self.into(),

TyBuilder::adt(db, self.into())

.fill_with_defaults(db, || TyKind::Error.intern(Interner))

)

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

}

push_ty_diagnostics(

db,

acc,

&source_map,

);

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

/// parameter, not additional bounds that might be added e.g. by a method if

/// the parameter comes from an impl!

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

.iter()

}

_ => None,

})

}

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

Some(Trait { id })

}

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

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

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

}

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

pub struct TraitRef<'db> {

env: Arc<TraitEnvironment>,

_pd: PhantomCovariantLifetime<'db>,

}

pub(crate) fn new_with_resolver(

db: &'db dyn HirDatabase,

resolver: &Resolver<'_>,

) -> Self {

let env = resolver

.generic_def()

}

pub fn trait_(&self) -> Trait {

Trait { id }

}

}

/// Returns `idx`-th argument of this trait reference if it is a type argument. Note that the

/// first argument is the `Self` type.

}

}

}

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

match ty.kind(Interner) {

// Reference itself

TyKind::Ref(_, _, _) => true,

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

.into_iter()

|| substitution

.iter(Interner)

.filter_map(|x| x.ty(Interner))

}

// And for `PhantomData<T>`, we check `T`.

TyKind::Adt(_, substitution)

| TyKind::Tuple(_, substitution)

| TyKind::OpaqueType(_, substitution)

| TyKind::AssociatedType(_, substitution)

// For `[T]` or `*T` we check `T`

// Consider everything else as not reference

_ => false,

}

pub fn layout(&self, db: &'db dyn HirDatabase) -> Result<Layout, LayoutError> {

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

}

/// Iterates over associated types that may be specified after the given path (using

/// `Ty::Assoc` syntax).

&self,

resolution: &PathResolution,

}

pub fn generic_def(&self) -> Option<crate::GenericDef> {

db::HirDatabase,

semantics::{PathResolution, PathResolutionPerNs},

};

use either::Either;

use hir_def::{

AdtId, AssocItemId, CallableDefId, ConstId, DefWithBodyId, FieldId, FunctionId, GenericDefId,

Some(unresolved) => resolver

.generic_def()

.and_then(|def| {

})

.map(TypeAlias::from)

.map(Into::into)

db,

def,

res.in_type_ns()?,

)

})

.map(TypeAlias::from)

Qualified::With { resolution: None, .. } => {}

Qualified::With { resolution: Some(resolution), .. } => {

// Add associated types on type parameters and `Self`.

acc.add_type_alias(ctx, alias);

});

match resolution {

hir::PathResolution::Def(hir::ModuleDef::Module(module)) => {

Qualified::With { resolution: None, .. } => {}

Qualified::With { resolution: Some(resolution), .. } => {

// Add associated types on type parameters and `Self`.

acc.add_type_alias(ctx, alias);

});

match resolution {

use expect_test::{Expect, expect};

use hir::HirDisplay;

let ty = completion_context

.expected_type

.unwrap_or("?".to_owned());

let name =

let edition =

sema.attach_first_edition(file_id).map(|it| it.edition(db)).unwrap_or(Edition::CURRENT);

let display_target = sema.first_crate(file_id)?.to_display_target(db);

if let HoverDocFormat::PlainText = config.format {

res.info.markup = remove_markdown(res.info.markup.as_str()).into();

});

}

let ty = match def {

Definition::Local(it) => Some(it.ty(db)),

};

let ty = ty.display(sema.db, display_target);

match value {

Ok(value) => {

let backtick_len = value.chars().filter(|c| *c == '`').count();

config: &InlayHintsConfig,

display_target: DisplayTarget,

) -> Result<(), HirDisplayError> {

}

}

let mut label_builder = InlayHintLabelBuilder {

Adjust, Adjustment, AutoBorrow, DisplayTarget, HirDisplay, Mutability, OverloadedDeref,

PointerCast, Safety,

};

use ide_db::text_edit::TextEditBuilder;

use syntax::ast::{self, AstNode, prec::ExprPrecedence};

text: if postfix { format!(".{}", text.trim_end()) } else { text.to_owned() },

linked_location: None,

tooltip: Some(config.lazy_tooltip(|| {

})),

};

if postfix { &mut post } else { &mut pre }.label.append_part(label);

FxHashMap, FxIndexSet, LineIndexDatabase,

base_db::{

CrateOrigin, CrateWorkspaceData, Env, FileSet, RootQueryDb, SourceDatabase, VfsPath,

},

prime_caches, symbol_index,

};

hasher: impl Fn(&InlayHint) -> u64 + Send + UnwindSafe,

) -> Cancellable<Option<InlayHint>> {

self.with_db(|db| {

})

}

let search_scope = AssertUnwindSafe(search_scope);

self.with_db(|db| {

let _ = &search_scope;

})

}

config: &HoverConfig,

range: FileRange,

) -> Cancellable<Option<RangeInfo<HoverResult>>> {

}

/// Returns moniker of symbol at position.

&self,

position: FilePosition,

) -> Cancellable<Option<RangeInfo<Vec<moniker::MonikerResult>>>> {

}

/// Returns URL(s) for the documentation of the symbol under the cursor.

&self,

position: FilePosition,

) -> Cancellable<Option<RangeInfo<Vec<NavigationTarget>>>> {

}

/// Computes incoming calls for the given file position.

/// Returns the set of possible targets to run for the current file.

pub fn runnables(&self, file_id: FileId) -> Cancellable<Vec<Runnable>> {

}

/// Returns the set of tests for the given file position.

position: FilePosition,

) -> Cancellable<Option<Vec<HighlightedRange>>> {

self.with_db(|db| {

})

}

};

use ide_db::{

FileId, FileRange, RootDatabase, SymbolKind,

defs::Definition,

documentation::{Documentation, HasDocs},

};

)

.map(|mut res| {

res.docs = self.docs(db);

res.container_name = self.container_name(db);

res

}),

NavigationTarget::from_named(db, src.with_value(it), SymbolKind::Field).map(

|mut res| {

res.docs = self.docs(db);

res

},

)

use ide_assists::utils::{has_test_related_attribute, test_related_attribute_syn};

use ide_db::{

FilePosition, FxHashMap, FxIndexMap, FxIndexSet, RootDatabase, SymbolKind,

defs::Definition,

documentation::docs_from_attrs,

helpers::visit_file_defs,

let ty = def.self_ty(sema.db);

let adt_name = ty.as_adt()?.name(sema.db);

let mut ty_args = ty.generic_parameters(sema.db, display_target).peekable();

let mut test_id = format!("{}{params}", adt_name.display(sema.db, edition));

test_id.retain(|c| c != ' ');

let test_id = TestId::Path(test_id);

let mut ty_args = ty.generic_parameters(db, display_target).peekable();

format_to!(path, "{}", name.display(db, edition));

if ty_args.peek().is_some() {

}

format_to!(path, "::{}", def_name.display(db, edition));

path.retain(|c| c != ' ');

use ide_db::{

FilePosition, FxIndexMap,

active_parameter::{callable_for_arg_list, generic_def_for_node},

documentation::{Documentation, HasDocs},

};

use itertools::Itertools;

// In that case, fall back to render definitions of the respective parameters.

// This is overly conservative: we do not substitute known type vars

// (see FIXME in tests::impl_trait) and falling back on any unknowns.

(true, Some(fn_params)) => {

format_to!(buf, "{}", fn_params[idx].ty().display(db, display_target))

}

_ => format_to!(buf, "{}", p.ty().display(db, display_target)),

res.push_call_param(&buf);

}

}

use hir::{Crate, Module, Semantics, db::HirDatabase};

use ide_db::{

FileId, FileRange, FxHashMap, FxHashSet, RootDatabase,

defs::{Definition, IdentClass},

documentation::Documentation,

famous_defs::FamousDefs,

let id = if let Some(it) = self.def_map.get(&def) {

*it

} else {

});

self.def_map.insert(def, it);

it

use hir::{DisplayTarget, Field, HirDisplay, Layout, Semantics, Type};

use ide_db::{

RootDatabase,

defs::Definition,

helpers::{get_definition, pick_best_token},

};

nodes[parent_idx].children_len = fields.len() as u64;

for (field, child_ty) in fields.iter() {

nodes.push(MemoryLayoutNode {

item_name: field.name(db),

size: child_layout.size(),

alignment: child_layout.align(),

offset: match *field {

}

for (i, (_, child_ty)) in fields.iter().enumerate() {

read_layout(nodes, db, child_ty, &child_layout, children_start + i, display_target);

}

}

}

.map(|layout| {

let item_name = match def {

// def is a datatype

def => def.name(db).map(|n| n.as_str().to_owned()).unwrap_or("[ROOT]".to_owned()),

};

let mut nodes = vec![MemoryLayoutNode {

item_name,

use cfg::{CfgAtom, CfgDiff};

use hir::{

db::{DefDatabase, ExpandDatabase, HirDatabase},

};

use hir_def::{

SyntheticSyntax,

expr_store::BodySourceMap,

hir::{ExprId, PatId},

};

use ide::{

Analysis, AnalysisHost, AnnotationConfig, DiagnosticsConfig, Edition, InlayFieldsToResolve,

InlayHintsConfig, LineCol, RootDatabase,

let mut all = 0;

let mut fail = 0;

for &a in adts {

let generic_params = db.generic_params(a.into());

if generic_params.iter_type_or_consts().next().is_some()

|| generic_params.iter_lt().next().is_some()

all += 1;

let Err(e) = db.layout_of_adt(

hir_def::AdtId::from(a),

db.trait_environment(a.into()),

) else {

continue;